Base: Update issue template

2024-08-30 18:12:16 +00:00 · 2021-12-29 01:05:30 -08:00
58 changed files with 948 additions and 4997 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.yaml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yaml
@ -69,7 +69,6 @@ body:
    label: obs-websocket Version
    description: What version of obs-websocket are you using?
    options:
-    - 5.0.0-beta1
    - 5.0.0-alpha3
    - 5.0.0-alpha2
    - 4.9.1
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@ -1,4 +1,4 @@
-name: 'CI Multiplatform Build'
+name: "CI Multiplatform Build"

 on:
  push:
@ -18,15 +18,15 @@ on:
 jobs:
  windows:
    name: 'Windows 32/64-bit'
-    runs-on: [windows-2019]
+    runs-on: [windows-latest]
    if: contains(github.event.head_commit.message, '[skip ci]') != true
    env:
      QT_CACHE_VERSION: '2' # Change whenever updating OBS dependencies URL, in order to force a cache reset
      QT_VERSION: '5.15.2'
      WINDOWS_DEPS_CACHE_VERSION: '1' # Change whenever updating Qt dependency URL, in order to force a cache reset
      WINDOWS_DEPS_VERSION: '2019'
-      CMAKE_GENERATOR: 'Visual Studio 16 2019'
-      CMAKE_SYSTEM_VERSION: '10.0'
+      CMAKE_GENERATOR: "Visual Studio 16 2019"
+      CMAKE_SYSTEM_VERSION: "10.0"
    steps:
      - name: 'Add msbuild to PATH'
        uses: microsoft/setup-msbuild@v1.0.2
@ -35,20 +35,20 @@ jobs:
        with:
          path: ${{ github.workspace }}/obs-websocket
          submodules: 'recursive'
-      - name: 'Checkout OBS Studio'
+      - name: 'Checkout OBS-Studio'
        uses: actions/checkout@v2
        with:
          repository: obsproject/obs-studio
          path: ${{ github.workspace }}/obs-studio
          submodules: 'recursive'
-      - name: 'Get OBS Studio Git Info'
+      - name: 'Get OBS-Studio Git Info'
        shell: bash
        working-directory: ${{ github.workspace }}/obs-studio
        run: |
          git fetch --prune --unshallow
          echo "OBS_GIT_HASH=$(git rev-parse --short HEAD)" >> $GITHUB_ENV
          echo "OBS_GIT_TAG=$(git describe --tags --abbrev=0)" >> $GITHUB_ENV
-      - name: 'Checkout last OBS Studio release (${{ env.OBS_GIT_TAG }})'
+      - name: 'Checkout last OBS-Studio release (${{ env.OBS_GIT_TAG }})'
        shell: bash
        working-directory: ${{ github.workspace }}/obs-studio
        run: |
@ -78,6 +78,8 @@ jobs:
        with:
          path: Qt_${{ env.QT_VERSION }}.7z
          key: 'qtdep-${{ env.QT_CACHE_VERSION }} | ${{ runner.os }}'
+          restore-keys: |
+            qtdep-${{ env.QT_CACHE_VERSION }} | ${{ runner.os }}
      - name: 'Download Prerequisite: Qt'
        if: steps.qtcache.outputs.cache-hit != 'true'
        run: |
@ -85,18 +87,20 @@ jobs:
      - name: 'Extract Prerequisite: Qt'
        run: |
          7z x Qt_${{ env.QT_VERSION }}.7z -o"${{ github.workspace }}\cmbuild\QT"
-      - name: 'Restore Cached OBS Studio Dependencies'
+      - name: 'Restore Cached OBS-Studio Dependencies'
        id: obscache
        uses: actions/cache@v2
        with:
          path: ${{ github.workspace }}\cmbuild\deps\**
          key: 'obsdep-${{ env.WINDOWS_DEPS_CACHE_VERSION }} | ${{ runner.os }}'
-      - name: 'Install Prerequisite: Pre-built OBS Studio dependencies'
+          restore-keys: |
+            obsdep-${{ env.WINDOWS_DEPS_CACHE_VERSION }} | ${{ runner.os }}
+      - name: 'Install Prerequisite: Pre-built OBS-Studio dependencies'
        if: steps.obscache.outputs.cache-hit != 'true'
        run: |
          curl -kLO https://cdn-fastly.obsproject.com/downloads/dependencies${{ env.WINDOWS_DEPS_VERSION }}.zip -f --retry 5 -C -
          7z x dependencies${{ env.WINDOWS_DEPS_VERSION }}.zip -o"${{ github.workspace }}\cmbuild\deps"
-      - name: 'Restore OBS Studio 32-bit Build v${{ env.OBS_GIT_TAG }} from Cache'
+      - name: 'Restore OBS-Studio 32-bit Build v${{ env.OBS_GIT_TAG }} from Cache'
        id: build-cache-obs-32
        uses: actions/cache@v2
        env:
@ -104,20 +108,22 @@ jobs:
        with:
          path: ${{ github.workspace }}/obs-studio/build32
          key: ${{ runner.os }}-${{ env.CACHE_NAME }}-${{ env.OBS_GIT_TAG }}
-      - name: 'Configure OBS Studio 32-bit'
+          restore-keys: |
+            ${{ runner.os }}-${{ env.CACHE_NAME }}-
+      - name: 'Configure OBS-Studio 32-bit'
        if: steps.build-cache-obs-32.outputs.cache-hit != 'true'
        working-directory: ${{ github.workspace }}/obs-studio
        run: |
          if(!(Test-Path -Path ".\build32")){New-Item -ItemType directory -Path .\build32}
          cd .\build32
          cmake -G "${{ env.CMAKE_GENERATOR }}" -A Win32 -DCMAKE_SYSTEM_VERSION="${{ env.CMAKE_SYSTEM_VERSION }}" -DQTDIR="${{ github.workspace }}\cmbuild\QT\${{ env.QT_VERSION }}\msvc2019" -DDepsPath="${{ github.workspace }}\cmbuild\deps\win32" -DCOPIED_DEPENDENCIES=NO -DCOPY_DEPENDENCIES=YES -DBUILD_BROWSER=OFF ..
-      - name: 'Build OBS Studio 32-bit'
+      - name: 'Build OBS-Studio 32-bit'
        if: steps.build-cache-obs-32.outputs.cache-hit != 'true'
        working-directory: ${{ github.workspace }}/obs-studio
        run: |
          msbuild /m /p:Configuration=RelWithDebInfo .\build32\libobs\libobs.vcxproj
          msbuild /m /p:Configuration=RelWithDebInfo .\build32\UI\obs-frontend-api\obs-frontend-api.vcxproj
-      - name: 'Restore OBS Studio 64-bit Build v${{ env.OBS_GIT_TAG }} from Cache'
+      - name: 'Restore OBS-Studio 64-bit Build v${{ env.OBS_GIT_TAG }} from Cache'
        id: build-cache-obs-64
        uses: actions/cache@v1
        env:
@ -125,14 +131,16 @@ jobs:
        with:
          path: ${{ github.workspace }}/obs-studio/build64
          key: ${{ runner.os }}-${{ env.CACHE_NAME }}-${{ env.OBS_GIT_TAG }}
-      - name: 'Configure OBS Studio 64-bit'
+          restore-keys: |
+            ${{ runner.os }}-${{ env.CACHE_NAME }}-
+      - name: 'Configure OBS-Studio 64-bit'
        if: steps.build-cache-obs-64.outputs.cache-hit != 'true'
        working-directory: ${{ github.workspace }}/obs-studio
        run: |
          if(!(Test-Path -Path ".\build64")){New-Item -ItemType directory -Path .\build64}
          cd .\build64
          cmake -G "${{ env.CMAKE_GENERATOR }}" -A x64 -DCMAKE_SYSTEM_VERSION="${{ env.CMAKE_SYSTEM_VERSION }}" -DQTDIR="${{ github.workspace }}\cmbuild\QT\${{ env.QT_VERSION }}\msvc2019_64" -DDepsPath="${{ github.workspace }}\cmbuild\deps\win64" -DCOPIED_DEPENDENCIES=NO -DCOPY_DEPENDENCIES=YES -DBUILD_BROWSER=OFF ..
-      - name: 'Build OBS Studio 64-bit'
+      - name: 'Build OBS-Studio 64-bit'
        if: steps.build-cache-obs-64.outputs.cache-hit != 'true'
        working-directory: ${{ github.workspace }}/obs-studio
        run: |
@ -180,7 +188,7 @@ jobs:
          name: 'obs-websocket-${{ env.PACKAGE_VERSION }}-Windows-Installer'
          path: ${{ github.workspace }}/obs-websocket/package/*.exe
  ubuntu64:
-    name: 'Linux/Ubuntu 64-bit'
+    name: "Linux/Ubuntu 64-bit"
    runs-on: [ubuntu-latest]
    if: contains(github.event.head_commit.message, '[skip ci]') != true
    steps:
@ -189,20 +197,20 @@ jobs:
        with:
          path: ${{ github.workspace }}/obs-websocket
          submodules: 'recursive'
-      - name: 'Checkout OBS Studio'
+      - name: 'Checkout OBS-Studio'
        uses: actions/checkout@v2
        with:
          repository: obsproject/obs-studio
          path: ${{ github.workspace }}/obs-studio
          submodules: 'recursive'
-      - name: 'Get OBS Studio Git Info'
+      - name: 'Get OBS-Studio Git Info'
        shell: bash
        working-directory: ${{ github.workspace }}/obs-studio
        run: |
          git fetch --prune --unshallow
          echo "OBS_GIT_HASH=$(git rev-parse --short HEAD)" >> $GITHUB_ENV
          echo "OBS_GIT_TAG=$(git describe --tags --abbrev=0)" >> $GITHUB_ENV
-      - name: 'Checkout last OBS Studio release (${{ env.OBS_GIT_TAG }})'
+      - name: 'Checkout last OBS-Studio release (${{ env.OBS_GIT_TAG }})'
        shell: bash
        working-directory: ${{ github.workspace }}/obs-studio
        run: |
@ -276,21 +284,21 @@ jobs:
           libx11-xcb-dev \
           libxcb1-dev \
           libxss-dev \
-      - name: 'Configure OBS Studio'
+      - name: 'Configure OBS-Studio'
        working-directory: ${{ github.workspace }}/obs-studio
        shell: bash
        run: |
          mkdir ./build
          cd ./build
          cmake -DDISABLE_PLUGINS=YES -DENABLE_SCRIPTING=NO -DUNIX_STRUCTURE=YES -DCMAKE_INSTALL_PREFIX=/usr ..
-      - name: 'Build OBS Studio'
+      - name: 'Build OBS-Studio'
        working-directory: ${{ github.workspace }}/obs-studio
        shell: bash
        run: |
          set -e
          cd ./build
          make -j4 libobs obs-frontend-api
-      - name: 'Install OBS Studio'
+      - name: 'Install OBS-Studio'
        working-directory: ${{ github.workspace }}/obs-studio
        shell: bash
        run: |
@ -308,7 +316,7 @@ jobs:
          if [ "${{ env.GIT_TAG }}" ] ; then \
            cmake -DLIBOBS_INCLUDE_DIR=${{ github.workspace }}/obs-studio/libobs -DCMAKE_INSTALL_PREFIX=/usr -DUSE_UBUNTU_FIX=TRUE -DOBS_WEBSOCKET_VERSION_SUFFIX="${{ env.CMAKE_VERSION_SUFFIX }}" -DCMAKE_BUILD_TYPE=Release .. ; \
          else \
-            cmake -DLIBOBS_INCLUDE_DIR=${{ github.workspace }}/obs-studio/libobs -DCMAKE_INSTALL_PREFIX=/usr -DUSE_UBUNTU_FIX=TRUE -DOBS_WEBSOCKET_VERSION_SUFFIX="${{ env.CMAKE_VERSION_SUFFIX }}" -DPLUGIN_TESTS=TRUE .. ; \
+            cmake -DLIBOBS_INCLUDE_DIR=${{ github.workspace }}/obs-studio/libobs -DCMAKE_INSTALL_PREFIX=/usr -DUSE_UBUNTU_FIX=TRUE -DOBS_WEBSOCKET_VERSION_SUFFIX="${{ env.CMAKE_VERSION_SUFFIX }}" .. ; \
          fi
      - name: 'Build obs-websocket'
        working-directory: ${{ github.workspace }}/obs-websocket
@ -347,214 +355,3 @@ jobs:
        with:
          name: 'obs-websocket-${{ env.PACKAGE_VERSION }}-Ubuntu64'
          path: '${{ github.workspace }}/obs-websocket/package/*.deb'
-  macOS:
-    name: 'macOS 64-bit'
-    runs-on: [macos-latest]
-    if: contains(github.event.head_commit.message, '[skip ci]') != true
-    env:
-      MACOS_DEPS_VERSION: '2022-01-01'
-      MACOS_DEPS_CACHE_VERSION: '2' # Change whenever updating dependencies version, in order to force a cache reset
-    steps:
-      - name: 'Checkout obs-websocket'
-        uses: actions/checkout@v2
-        with:
-          path: ${{ github.workspace }}/obs-websocket
-          submodules: 'recursive'
-      - name: 'Checkout OBS Studio'
-        uses: actions/checkout@v2
-        with:
-          repository: obsproject/obs-studio
-          path: ${{ github.workspace }}/obs-studio
-          submodules: 'recursive'
-      - name: 'Install Prerequisite: Binary Signing Certificate'
-        if: github.event_name != 'pull_request'
-        uses: apple-actions/import-codesign-certs@v1
-        with:
-          p12-file-base64: ${{ secrets.MACOS_SIGNING_CERT }}
-          p12-password: ${{ secrets.MACOS_SIGNING_CERT_PASSWORD }}
-          create-keychain: true
-          keychain-password: ${{ secrets.MACOS_TEMP_CI_KEYCHAIN_PASSWORD }}
-      - name: 'Install Prerequisite: Installer Signing Certificate'
-        if: github.event_name != 'pull_request'
-        uses: apple-actions/import-codesign-certs@v1
-        with:
-          p12-file-base64: ${{ secrets.MACOS_INSTALLER_CERT }}
-          p12-password: ${{ secrets.MACOS_INSTALLER_CERT_PASSWORD }}
-          create-keychain: false
-          keychain-password: ${{ secrets.MACOS_TEMP_CI_KEYCHAIN_PASSWORD }}
-      - name: 'Get OBS Studio Git Info'
-        shell: bash
-        working-directory: ${{ github.workspace }}/obs-studio
-        run: |
-          git fetch --prune --unshallow
-          echo "OBS_GIT_HASH=$(git rev-parse --short HEAD)" >> $GITHUB_ENV
-          echo "OBS_GIT_TAG=$(git describe --tags --abbrev=0)" >> $GITHUB_ENV
-      - name: 'Checkout last OBS Studio release (${{ env.OBS_GIT_TAG }})'
-        shell: bash
-        working-directory: ${{ github.workspace }}/obs-studio
-        run: |
-          git checkout ${{ env.OBS_GIT_TAG }}
-          git submodule update
-      - name: 'Get obs-websocket git info'
-        shell: bash
-        working-directory: ${{ github.workspace }}/obs-websocket
-        run: |
-          git fetch --prune --unshallow
-          GIT_HASH=$(git rev-parse --short HEAD)
-          echo "GIT_HASH=$GIT_HASH" >> $GITHUB_ENV
-          GIT_TAG=$(git describe --exact-match --tags --abbrev=0) || GIT_TAG=""
-          echo "GIT_TAG=$GIT_TAG" >> $GITHUB_ENV
-          if [ "$GIT_TAG" ] ; then \
-            VERSION="$GIT_TAG" \
-            VERSION_SUFFIX=$(echo "$GIT_TAG" | cut -c6-20) ; \
-          else \
-            VERSION="$GIT_HASH-git" \
-            VERSION_SUFFIX="-$GIT_HASH-git" ; \
-          fi
-          echo "PACKAGE_VERSION=$VERSION" >> $GITHUB_ENV
-          echo "CMAKE_VERSION_SUFFIX=$VERSION_SUFFIX" >> $GITHUB_ENV
-      - name: 'Install Packages'
-        shell: bash
-        run: |
-          curl -L -O http://s.sudre.free.fr/Software/files/Packages.dmg
-          sudo hdiutil attach ./Packages.dmg
-          sudo installer -pkg /Volumes/Packages\ 1.2.10/Install\ Packages.pkg -target /
-      - name: 'Restore Cached Qt & OBS Studio dependencies'
-        id: deps-cache
-        uses: actions/cache@v2
-        with:
-          path: ${{ github.workspace }}/obsdeps/**
-          key: 'deps-cache-${{ env.MACOS_DEPS_CACHE_VERSION }} | ${{ runner.os }}'
-      - name: 'Install Prerequisite: Qt + OBS Studio dependencies'
-        if: steps.deps-cache.outputs.cache-hit != 'true'
-        shell: bash
-        run: |
-          mkdir -p obsdeps
-          curl -L -O https://github.com/obsproject/obs-deps/releases/download/${{ env.MACOS_DEPS_VERSION }}/macos-deps-qt-${{ env.MACOS_DEPS_VERSION }}-universal.tar.xz
-          tar -xf macos-deps-qt-${{ env.MACOS_DEPS_VERSION }}-universal.tar.xz -C "./obsdeps"
-          curl -L -O https://github.com/obsproject/obs-deps/releases/download/${{ env.MACOS_DEPS_VERSION }}/macos-deps-${{ env.MACOS_DEPS_VERSION }}-universal.tar.xz
-          tar -xf macos-deps-${{ env.MACOS_DEPS_VERSION }}-universal.tar.xz -C "./obsdeps"
-      - run: xattr -r -d com.apple.quarantine ./obsdeps
-        shell: bash
-      - name: 'Configue OBS Studio'
-        if: steps.cache-obs-build.outputs.cache-hit != 'true'
-        working-directory: ${{ github.workspace }}/obs-studio
-        shell: bash
-        run: |
-          mkdir -p ./build
-          cd ./build
-          cmake .. \
-                -DQTDIR=${{ github.workspace }}/obsdeps \
-                -DDepsPath=${{ github.workspace }}/obsdeps \
-                -DCMAKE_OSX_DEPLOYMENT_TARGET=10.13 \
-                -DDISABLE_PLUGINS=true \
-                -DENABLE_SCRIPTING=0 \
-                -DCMAKE_PREFIX_PATH=${{ github.workspace }}/obsdeps/lib/cmake
-      - name: 'Build OBS Studio'
-        if: steps.cache-obs-build.outputs.cache-hit != 'true'
-        working-directory: ${{ github.workspace }}/obs-studio/build
-        shell: bash
-        run: |
-          set -e
-          make -j4 libobs obs-frontend-api
-      - name: 'Configure obs-websocket'
-        working-directory: ${{ github.workspace }}/obs-websocket
-        shell: bash
-        run: |
-          mkdir -p build
-          cd build
-          cmake .. \
-                -DCMAKE_OSX_DEPLOYMENT_TARGET=10.13 \
-                -DQTDIR=${{ github.workspace }}/obsdeps \
-                -DLIBOBS_INCLUDE_DIR=${{ github.workspace }}/obs-studio/libobs \
-                -DLIBOBS_LIB=${{ github.workspace }}/obs-studio/libobs \
-                -DOBS_FRONTEND_LIB="${{ github.workspace }}/obs-studio/build/UI/obs-frontend-api/libobs-frontend-api.dylib" \
-                -DCMAKE_BUILD_TYPE=RelWithDebInfo \
-                -DCMAKE_INSTALL_PREFIX=/usr \
-                -DOBS_WEBSOCKET_VERSION_SUFFIX="${{ env.CMAKE_VERSION_SUFFIX }}"
-      - name: 'Build obs-websocket'
-        working-directory: ${{ github.workspace }}/obs-websocket/build
-        shell: bash
-        run: |
-          set -e
-          make -j4
-      - name: 'Relink Qt'
-        shell: bash
-        working-directory: ${{ github.workspace }}/obs-websocket/build
-        run: |
-          install_name_tool \
-              -change /tmp/obsdeps/lib/QtWidgets.framework/Versions/5/QtWidgets \
-                  @executable_path/../Frameworks/QtWidgets.framework/Versions/5/QtWidgets \
-              -change /tmp/obsdeps/lib/QtGui.framework/Versions/5/QtGui \
-                  @executable_path/../Frameworks/QtGui.framework/Versions/5/QtGui \
-              -change /tmp/obsdeps/lib/QtCore.framework/Versions/5/QtCore \
-                  @executable_path/../Frameworks/QtCore.framework/Versions/5/QtCore \
-              -change /tmp/obsdeps/lib/QtNetwork.framework/Versions/5/QtNetwork \
-                  @executable_path/../Frameworks/QtNetwork.framework/Versions/5/QtNetwork \
-              -change /tmp/obsdeps/lib/QtSvg.framework/Versions/5/QtSvg \
-                  @executable_path/../Frameworks/QtSvg.framework/Versions/5/QtSvg \
-              ./obs-websocket.so
-      - name: 'Sign plugin binary'
-        if: github.event_name != 'pull_request'
-        shell: bash
-        working-directory: ${{ github.workspace }}/obs-websocket/build
-        run: |
-          codesign --sign "${{ secrets.MACOS_SIGNING_IDENTITY }}" ./obs-websocket.so
-      - name: 'Set PR Artifact Filename'
-        shell: bash
-        run: |
-          echo "MACOS_FILENAME=obs-websocket-${{ env.PACKAGE_VERSION }}-macOS.pkg" >> $GITHUB_ENV
-          echo "MACOS_FILENAME_UNSIGNED=obs-websocket-${{ env.PACKAGE_VERSION }}-macOS-Unsigned.pkg" >> $GITHUB_ENV
-      - name: 'Package ${{ env.MACOS_FILENAME_UNSIGNED }}'
-        if: success()
-        working-directory: ${{ github.workspace }}/obs-websocket
-        shell: bash
-        run: |
-          packagesbuild ./CI/macos/obs-websocket.pkgproj
-          mv ./release/obs-websocket.pkg ./release/${{ env.MACOS_FILENAME_UNSIGNED }}
-      - name: 'Sign plugin package'
-        if: ${{ env.GIT_TAG != '' }}
-        shell: bash
-        working-directory: ${{ github.workspace }}/obs-websocket
-        run: |
-          productsign \
-            --sign "${{ secrets.MACOS_INSTALLER_IDENTITY }}" \
-            ./release/${{ env.MACOS_FILENAME_UNSIGNED }} \
-            ./release/${{ env.MACOS_FILENAME }}
-          rm ./release/${{ env.MACOS_FILENAME_UNSIGNED }}
-      - name: 'Notarize package'
-        if: ${{ env.GIT_TAG != '' }}
-        shell: bash
-        working-directory: ${{ github.workspace }}/obs-websocket
-        run: |
-          zip -r ./release/${{ env.MACOS_FILENAME }}.zip ./release/${{ env.MACOS_FILENAME }}
-          UPLOAD_RESULT=$(xcrun altool --notarize-app \
-            --primary-bundle-id "com.obsproject.obs-websocket" \
-            --username "${{ secrets.MACOS_NOTARIZATION_USERNAME }}" \
-            --password "${{ secrets.MACOS_NOTARIZATION_PASSWORD }}" \
-            --asc-provider "${{ secrets.ASC_PROVIDER_SHORTNAME }}" \
-            --file "./release/${{ env.MACOS_FILENAME }}.zip")
-
-          rm ./release/${{ env.MACOS_FILENAME }}.zip
-
-          REQUEST_UUID=$(echo $UPLOAD_RESULT | awk -F ' = ' '/RequestUUID/ {print $2}')
-
-          # Pieces of code borrowed from rednoah/notarized-app
-          while sleep 30 && date; do
-            CHECK_RESULT=$(xcrun altool \
-              --notarization-info "$REQUEST_UUID" \
-              --username "${{ secrets.MACOS_NOTARIZATION_USERNAME }}" \
-              --password "${{ secrets.MACOS_NOTARIZATION_PASSWORD }}" \
-              --asc-provider "${{ secrets.ASC_PROVIDER_SHORTNAME }}")
-
-            if ! grep -q "Status: in progress" <<< "$CHECK_RESULT"; then
-              xcrun stapler staple ./release/${{ env.MACOS_FILENAME }}
-              break
-            fi
-          done
-      - name: 'Publish Packages'
-        if: success()
-        uses: actions/upload-artifact@v2-preview
-        with:
-          name: 'obs-websocket-${{ env.PACKAGE_VERSION }}-macOS'
-          path: '${{ github.workspace }}/obs-websocket/release/*.pkg'
--- a/.gitignore
+++ b/.gitignore
@ -11,4 +11,3 @@
 /docs/node_modules/
 /src/plugin-macros.generated.h
 /installer/installer-windows.generated.iss
-/cmake-build-debug/
--- a/CI/macos/Brewfile
+++ b/CI/macos/Brewfile
@ -0,0 +1,5 @@
+brew "jack"
+brew "speexdsp"
+brew "cmake"
+brew "freetype"
+brew "fdk-aac"
--- a/CI/macos/build-plugin-macos.sh
+++ b/CI/macos/build-plugin-macos.sh
@ -0,0 +1,27 @@
+#!/bin/sh
+
+OSTYPE=$(uname)
+
+if [ "${OSTYPE}" != "Darwin" ]; then
+	echo "[obs-websocket - Error] macOS build script can be run on Darwin-type OS only."
+	exit 1
+fi
+
+HAS_CMAKE=$(type cmake 2>/dev/null)
+
+if [ "${HAS_CMAKE}" = "" ]; then
+	echo "[obs-websocket - Error] CMake not installed - please run 'install-dependencies-macos.sh' first."
+	exit 1
+fi
+
+echo "[obs-websocket] Building 'obs-websocket' for macOS."
+mkdir -p build && cd build
+cmake .. \
+ 	-DCMAKE_OSX_DEPLOYMENT_TARGET=10.13 \
+	-DQTDIR=/tmp/obsdeps \
+	-DLIBOBS_INCLUDE_DIR=../../obs-studio/libobs \
+	-DLIBOBS_LIB=../../obs-studio/libobs \
+	-DOBS_FRONTEND_LIB="$(pwd)/../../obs-studio/build/UI/obs-frontend-api/libobs-frontend-api.dylib" \
+	-DCMAKE_BUILD_TYPE=RelWithDebInfo \
+	-DCMAKE_INSTALL_PREFIX=/usr \
+&& make -j4
--- a/CI/macos/install-build-obs-macos.sh
+++ b/CI/macos/install-build-obs-macos.sh
@ -0,0 +1,39 @@
+#!/bin/sh
+
+OSTYPE=$(uname)
+
+if [ "${OSTYPE}" != "Darwin" ]; then
+	echo "[obs-websocket - Error] macOS obs-studio build script can be run on Darwin-type OS only."
+	exit 1
+fi
+
+HAS_CMAKE=$(type cmake 2>/dev/null)
+HAS_GIT=$(type git 2>/dev/null)
+
+if [ "${HAS_CMAKE}" = "" ]; then
+	echo "[obs-websocket - Error] CMake not installed - please run 'install-dependencies-macos.sh' first."
+	exit 1
+fi
+
+if [ "${HAS_GIT}" = "" ]; then
+	echo "[obs-websocket - Error] Git not installed - please install Xcode developer tools or via Homebrew."
+	exit 1
+fi
+
+# Build obs-studio
+cd ..
+echo "[obs-websocket] Cloning obs-studio from GitHub.."
+git clone https://github.com/obsproject/obs-studio
+cd obs-studio
+OBSLatestTag=$(git describe --tags --abbrev=0)
+git checkout $OBSLatestTag
+mkdir build && cd build
+echo "[obs-websocket] Building obs-studio.."
+cmake .. \
+	-DQTDIR=/tmp/obsdeps \
+	-DDepsPath=/tmp/obsdeps \
+	-DCMAKE_OSX_DEPLOYMENT_TARGET=10.13 \
+	-DDISABLE_PLUGINS=true \
+	-DENABLE_SCRIPTING=0 \
+	-DCMAKE_PREFIX_PATH=/tmp/obsdeps/lib/cmake \
+&& make -j4
--- a/CI/macos/install-dependencies-macos.sh
+++ b/CI/macos/install-dependencies-macos.sh
@ -0,0 +1,57 @@
+#!/bin/sh
+
+OSTYPE=$(uname)
+
+if [ "${OSTYPE}" != "Darwin" ]; then
+	echo "[obs-websocket - Error] macOS install dependencies script can be run on Darwin-type OS only."
+	exit 1
+fi
+
+HAS_BREW=$(type brew 2>/dev/null)
+
+if [ "${HAS_BREW}" = "" ]; then
+	echo "[obs-websocket - Error] Please install Homebrew (https://www.brew.sh/) to build obs-websocket on macOS."
+	exit 1
+fi
+
+# OBS Studio Brew Deps
+echo "[obs-websocket] Updating Homebrew.."
+brew update >/dev/null
+echo "[obs-websocket] Checking installed Homebrew formulas.."
+
+if [ -d /usr/local/opt/openssl@1.0.2t ]; then
+  brew uninstall openssl@1.0.2t
+  brew untap local/openssl
+fi
+
+if [ -d /usr/local/opt/python@2.7.17 ]; then
+  brew uninstall python@2.7.17
+  brew untap local/python2
+fi
+
+brew bundle --file ./CI/macos/Brewfile
+
+# Fetch and install Packages app
+# =!= NOTICE =!=
+# Installs a LaunchDaemon under /Library/LaunchDaemons/fr.whitebox.packages.build.dispatcher.plist
+# =!= NOTICE =!=
+
+HAS_PACKAGES=$(type packagesbuild 2>/dev/null)
+
+if [ "${HAS_PACKAGES}" = "" ]; then
+	echo "[obs-websocket] Installing Packaging app (might require password due to 'sudo').."
+	curl -L -O http://s.sudre.free.fr/Software/files/Packages.dmg
+	sudo hdiutil attach ./Packages.dmg
+	sudo installer -pkg /Volumes/Packages\ 1.2.9/Install\ Packages.pkg -target /
+fi
+
+# OBS Deps
+echo "[obs-websocket] Installing obs-websocket dependency 'OBS Deps ${OBS_DEPS_VERSION}'.."
+wget --quiet --retry-connrefused --waitretry=1 https://github.com/obsproject/obs-deps/releases/download/${OBS_DEPS_VERSION}/macos-deps-${OBS_DEPS_VERSION}.tar.gz
+tar -xf ./macos-deps-${OBS_DEPS_VERSION}.tar.gz -C /tmp
+
+# Qt deps
+echo "[obs-websocket] Installing obs-websocket dependency 'Qt ${QT_VERSION}'.."
+curl -L -O https://github.com/obsproject/obs-deps/releases/download/${OBS_DEPS_VERSION}/macos-qt-${QT_VERSION}-${OBS_DEPS_VERSION}.tar.gz
+tar -xf ./macos-qt-${QT_VERSION}-${OBS_DEPS_VERSION}.tar.gz -C "/tmp"
+xattr -r -d com.apple.quarantine /tmp/obsdeps
--- a/CI/macos/obs-websocket.pkgproj
+++ b/CI/macos/obs-websocket.pkgproj
@ -514,7 +514,7 @@
 			<key>CONCLUSION_ACTION</key>
 			<integer>0</integer>
 			<key>IDENTIFIER</key>
-			<string>com.obsproject.obs-websocket</string>
+			<string>fr.palakis.obs-websocket</string>
 			<key>OVERWRITE_PERMISSIONS</key>
 			<false/>
 			<key>VERSION</key>
--- a/CI/macos/package-plugin-macos.sh
+++ b/CI/macos/package-plugin-macos.sh
@ -0,0 +1,93 @@
+#!/bin/bash
+
+set -e
+
+OSTYPE=$(uname)
+
+if [ "${OSTYPE}" != "Darwin" ]; then
+	echo "[obs-websocket - Error] macOS package script can be run on Darwin-type OS only."
+	exit 1
+fi
+
+echo "[obs-websocket] Preparing package build"
+
+GIT_HASH=$(git rev-parse --short HEAD)
+GIT_BRANCH_OR_TAG=$(git name-rev --name-only HEAD | awk -F/ '{print $NF}')
+
+VERSION="$GIT_HASH-$GIT_BRANCH_OR_TAG"
+
+FILENAME_UNSIGNED="obs-websocket-$VERSION-Unsigned.pkg"
+FILENAME="obs-websocket-$VERSION.pkg"
+
+echo "[obs-websocket] Modifying obs-websocket.so linking"
+install_name_tool \
+	-change /tmp/obsdeps/lib/QtWidgets.framework/Versions/5/QtWidgets \
+		@executable_path/../Frameworks/QtWidgets.framework/Versions/5/QtWidgets \
+	-change /tmp/obsdeps/lib/QtGui.framework/Versions/5/QtGui \
+		@executable_path/../Frameworks/QtGui.framework/Versions/5/QtGui \
+	-change /tmp/obsdeps/lib/QtCore.framework/Versions/5/QtCore \
+		@executable_path/../Frameworks/QtCore.framework/Versions/5/QtCore \
+	-change /tmp/obsdeps/lib/QtNetwork.framework/Versions/5/QtNetwork \
+		@executable_path/../Frameworks/QtNetwork.framework/Versions/5/QtNetwork \
+	-change /tmp/obsdeps/lib/QtSvg.framework/Versions/5/QtSvg \
+		@executable_path/../Frameworks/QtSvg.framework/Versions/5/QtSvg \
+	./build/obs-websocket.so
+
+# Check if replacement worked
+echo "[obs-websocket] Dependencies for obs-websocket"
+otool -L ./build/obs-websocket.so
+
+if [[ "$RELEASE_MODE" == "True" ]]; then
+	echo "[obs-websocket] Signing plugin binary: obs-websocket.so"
+	codesign --sign "$CODE_SIGNING_IDENTITY" ./build/obs-websocket.so
+else
+	echo "[obs-websocket] Skipped plugin codesigning"
+fi
+
+echo "[obs-websocket] Actual package build"
+packagesbuild ./CI/macos/obs-websocket.pkgproj
+
+echo "[obs-websocket] Renaming obs-websocket.pkg to $FILENAME"
+mv ./release/obs-websocket.pkg ./release/$FILENAME_UNSIGNED
+
+if [[ "$RELEASE_MODE" == "True" ]]; then
+	echo "[obs-websocket] Signing installer: $FILENAME"
+	productsign \
+		--sign "$INSTALLER_SIGNING_IDENTITY" \
+		./release/$FILENAME_UNSIGNED \
+		./release/$FILENAME
+	rm ./release/$FILENAME_UNSIGNED
+
+	echo "[obs-websocket] Submitting installer $FILENAME for notarization"
+	zip -r ./release/$FILENAME.zip ./release/$FILENAME
+	UPLOAD_RESULT=$(xcrun altool \
+		--notarize-app \
+		--primary-bundle-id "fr.palakis.obs-websocket" \
+		--username "$AC_USERNAME" \
+		--password "$AC_PASSWORD" \
+		--asc-provider "$AC_PROVIDER_SHORTNAME" \
+		--file "./release/$FILENAME.zip")
+	rm ./release/$FILENAME.zip
+
+	REQUEST_UUID=$(echo $UPLOAD_RESULT | awk -F ' = ' '/RequestUUID/ {print $2}')
+	echo "Request UUID: $REQUEST_UUID"
+
+	echo "[obs-websocket] Wait for notarization result"
+	# Pieces of code borrowed from rednoah/notarized-app
+	while sleep 30 && date; do
+		CHECK_RESULT=$(xcrun altool \
+			--notarization-info "$REQUEST_UUID" \
+			--username "$AC_USERNAME" \
+			--password "$AC_PASSWORD" \
+			--asc-provider "$AC_PROVIDER_SHORTNAME")
+		echo $CHECK_RESULT
+
+		if ! grep -q "Status: in progress" <<< "$CHECK_RESULT"; then
+			echo "[obs-websocket] Staple ticket to installer: $FILENAME"
+			xcrun stapler staple ./release/$FILENAME
+			break
+		fi
+	done
+else
+	echo "[obs-websocket] Skipped installer codesigning and notarization"
+fi
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -114,7 +114,6 @@ set(obs-websocket_SOURCES
 	src/requesthandler/RequestHandler_Transitions.cpp
 	src/requesthandler/RequestHandler_Filters.cpp
 	src/requesthandler/RequestHandler_SceneItems.cpp
-	src/requesthandler/RequestHandler_Outputs.cpp
 	src/requesthandler/RequestHandler_Stream.cpp
 	src/requesthandler/RequestHandler_Record.cpp
 	src/requesthandler/RequestHandler_MediaInputs.cpp
--- a/README.md
+++ b/README.md
@ -6,7 +6,7 @@

 WebSocket API for OBS Studio.

-[![CI Multiplatform Build](https://github.com/obsproject/obs-websocket/actions/workflows/main.yml/badge.svg?branch=master)](https://github.com/obsproject/obs-websocket/actions/workflows/main.yml)
+[![CI Multiplatform Build](https://github.com/obsproject/obs-websocket/actions/workflows/main.yml/badge.svg?branch=master)](https://github.com/obs-websocket/obs-websocket/actions/workflows/main.yml)
 [![Discord](https://img.shields.io/discord/715691013825364120.svg?label=&logo=discord&logoColor=ffffff&color=7389D8&labelColor=6A7EC2)](https://discord.gg/WBaSQ3A)
 [![Financial Contributors on Open Collective](https://opencollective.com/obs-websocket-dev/all/badge.svg?label=financial+contributors)](https://opencollective.com/obs-websocket-dev)

@ -27,19 +27,18 @@ It is **highly recommended** to protect obs-websocket with a password against un
 - Automate scene switching with a third-party program (e.g. : auto-pilot, foot pedal, ...)

 ### Client software
- (No known clients supporting 5.0.0 at the moment. Ping us in the Discord if you have one!)
+- (No known clients supporting 5.0.0 at the moment. Send a message in Discord if you have one!)

 ### Client libraries (for developers)

 Here's a list of available language APIs for obs-websocket:
 - Python 3.7+ (Asyncio): [simpleobsws](https://github.com/IRLToolkit/simpleobsws/tree/master) by IRLToolkit
 - Rust: [obws](https://github.com/dnaka91/obws/tree/v5-api) by dnaka91
- Godot 3.4.x: [obs-websocket-gd](https://github.com/you-win/obs-websocket-gd) by you-win

-The 5.x server is a typical WebSocket server running by default on port 4455 (the port number can be changed in the Settings dialog under `Tools`).
+The server is a typical Websockets server running by default on port 4444 (the port number can be changed in the Settings dialog under `Tools`).
 The protocol we use is documented in [PROTOCOL.md](docs/generated/protocol.md).

-We'd like to know what you're building with obs-websocket! If you do something in this fashion, feel free to drop a message in `#project-showoff` in the [discord server!](https://discord.gg/WBaSQ3A)
+We'd like to know what you're building with or for obs-websocket. If you do something in this fashion, feel free to drop a message in `#project-showoff` in the [discord server!](https://discord.gg/WBaSQ3A)

 ## Contributors

--- a/deps/asio
+++ b/deps/asio
--- a/docs/generated/protocol.json
+++ b/docs/generated/protocol.json
--- a/docs/generated/protocol.md
+++ b/docs/generated/protocol.md
--- a/lib/obs-websocket-api.h
+++ b/lib/obs-websocket-api.h
@ -22,8 +22,6 @@ with this program. If not, see <https://www.gnu.org/licenses/>

 #include <obs.h>

-#define OBS_WEBSOCKET_API_VERSION 1
-
 #ifdef __cplusplus
 extern "C" {
 #endif
--- a/src/Config.cpp
+++ b/src/Config.cpp
@ -41,7 +41,7 @@ Config::Config() :
 	PasswordOverridden(false),
 	FirstLoad(true),
 	ServerEnabled(true),
-	ServerPort(4455),
+	ServerPort(4444),
 	DebugEnabled(false),
 	AlertsEnabled(false),
 	AuthRequired(true),
--- a/src/eventhandler/EventHandler.cpp
+++ b/src/eventhandler/EventHandler.cpp
@ -115,7 +115,6 @@ void EventHandler::BroadcastEvent(uint64_t requiredIntent, std::string eventType
 	_broadcastCallback(requiredIntent, eventType, eventData, rpcVersion);
 }

-// Connect source signals for Inputs, Scenes, and Transitions. Filters are automatically connected.
 void EventHandler::ConnectSourceSignals(obs_source_t *source) // Applies to inputs and scenes
 {
 	if (!source || obs_source_removed(source))
@ -129,17 +128,17 @@ void EventHandler::ConnectSourceSignals(obs_source_t *source) // Applies to inpu
 	obs_source_type sourceType = obs_source_get_type(source);

 	// Inputs
+	signal_handler_connect(sh, "activate", HandleInputActiveStateChanged, this);
+	signal_handler_connect(sh, "deactivate", HandleInputActiveStateChanged, this);
+	signal_handler_connect(sh, "show", HandleInputShowStateChanged, this);
+	signal_handler_connect(sh, "hide", HandleInputShowStateChanged, this);
+	signal_handler_connect(sh, "mute", HandleInputMuteStateChanged, this);
+	signal_handler_connect(sh, "volume", HandleInputVolumeChanged, this);
+	signal_handler_connect(sh, "audio_sync", HandleInputAudioSyncOffsetChanged, this);
+	signal_handler_connect(sh, "audio_mixers", HandleInputAudioTracksChanged, this);
+	//signal_handler_connect(sh, "audio_monitoring", HandleInputAudioMonitorTypeChanged, this);
+
 	if (sourceType == OBS_SOURCE_TYPE_INPUT) {
-		signal_handler_connect(sh, "activate", HandleInputActiveStateChanged, this);
-		signal_handler_connect(sh, "deactivate", HandleInputActiveStateChanged, this);
-		signal_handler_connect(sh, "show", HandleInputShowStateChanged, this);
-		signal_handler_connect(sh, "hide", HandleInputShowStateChanged, this);
-		signal_handler_connect(sh, "mute", HandleInputMuteStateChanged, this);
-		signal_handler_connect(sh, "volume", HandleInputVolumeChanged, this);
-		signal_handler_connect(sh, "audio_balance", HandleInputAudioBalanceChanged, this);
-		signal_handler_connect(sh, "audio_sync", HandleInputAudioSyncOffsetChanged, this);
-		signal_handler_connect(sh, "audio_mixers", HandleInputAudioTracksChanged, this);
-		signal_handler_connect(sh, "audio_monitoring", HandleInputAudioMonitorTypeChanged, this);
 		signal_handler_connect(sh, "media_started", HandleMediaInputPlaybackStarted, this);
 		signal_handler_connect(sh, "media_ended", HandleMediaInputPlaybackEnded, this);
 		signal_handler_connect(sh, "media_pause", SourceMediaPauseMultiHandler, this);
@ -157,37 +156,10 @@ void EventHandler::ConnectSourceSignals(obs_source_t *source) // Applies to inpu
 		signal_handler_connect(sh, "reorder", HandleSceneItemListReindexed, this);
 		signal_handler_connect(sh, "item_visible", HandleSceneItemEnableStateChanged, this);
 		signal_handler_connect(sh, "item_locked", HandleSceneItemLockStateChanged, this);
-		signal_handler_connect(sh, "item_select", HandleSceneItemSelected, this);
 		signal_handler_connect(sh, "item_transform", HandleSceneItemTransformChanged, this);
 	}
-
-	// Scenes and Inputs
-	if (sourceType == OBS_SOURCE_TYPE_INPUT || sourceType == OBS_SOURCE_TYPE_SCENE) {
-		signal_handler_connect(sh, "reorder_filters", HandleSourceFilterListReindexed, this);
-		signal_handler_connect(sh, "filter_add", FilterAddMultiHandler, this);
-		signal_handler_connect(sh, "filter_remove", FilterRemoveMultiHandler, this);
-		auto enumFilters = [](obs_source_t *, obs_source_t *filter, void *param){
-			auto eventHandler = static_cast<EventHandler*>(param);
-			eventHandler->ConnectSourceSignals(filter);
-		};
-		obs_source_enum_filters(source, enumFilters, this);
-	}
-
-	// Transitions
-	if (sourceType == OBS_SOURCE_TYPE_TRANSITION) {
-		signal_handler_connect(sh, "transition_start", HandleSceneTransitionStarted, this);
-		signal_handler_connect(sh, "transition_stop", HandleSceneTransitionEnded, this);
-		signal_handler_connect(sh, "transition_video_stop", HandleSceneTransitionVideoEnded, this);
-	}
-
-	// Filters
-	if (sourceType == OBS_SOURCE_TYPE_FILTER) {
-		signal_handler_connect(sh, "enable", HandleSourceFilterEnableStateChanged, this);
-		signal_handler_connect(sh, "rename", HandleSourceFilterNameChanged, this);
-	}
 }

-// Disconnect source signals for Inputs, Scenes, and Transitions. Filters are automatically disconnected.
 void EventHandler::DisconnectSourceSignals(obs_source_t *source)
 {
 	if (!source)
@ -195,120 +167,70 @@ void EventHandler::DisconnectSourceSignals(obs_source_t *source)

 	signal_handler_t* sh = obs_source_get_signal_handler(source);

-	obs_source_type sourceType = obs_source_get_type(source);
-
 	// Inputs
-	if (sourceType == OBS_SOURCE_TYPE_INPUT) {
-		signal_handler_disconnect(sh, "activate", HandleInputActiveStateChanged, this);
-		signal_handler_disconnect(sh, "deactivate", HandleInputActiveStateChanged, this);
-		signal_handler_disconnect(sh, "show", HandleInputShowStateChanged, this);
-		signal_handler_disconnect(sh, "hide", HandleInputShowStateChanged, this);
-		signal_handler_disconnect(sh, "mute", HandleInputMuteStateChanged, this);
-		signal_handler_disconnect(sh, "volume", HandleInputVolumeChanged, this);
-		signal_handler_disconnect(sh, "audio_balance", HandleInputAudioBalanceChanged, this);
-		signal_handler_disconnect(sh, "audio_sync", HandleInputAudioSyncOffsetChanged, this);
-		signal_handler_disconnect(sh, "audio_mixers", HandleInputAudioTracksChanged, this);
-		signal_handler_disconnect(sh, "audio_monitoring", HandleInputAudioMonitorTypeChanged, this);
-		signal_handler_disconnect(sh, "media_started", HandleMediaInputPlaybackStarted, this);
-		signal_handler_disconnect(sh, "media_ended", HandleMediaInputPlaybackEnded, this);
-		signal_handler_disconnect(sh, "media_pause", SourceMediaPauseMultiHandler, this);
-		signal_handler_disconnect(sh, "media_play", SourceMediaPlayMultiHandler, this);
-		signal_handler_disconnect(sh, "media_restart", SourceMediaRestartMultiHandler, this);
-		signal_handler_disconnect(sh, "media_stopped", SourceMediaStopMultiHandler, this);
-		signal_handler_disconnect(sh, "media_next", SourceMediaNextMultiHandler, this);
-		signal_handler_disconnect(sh, "media_previous", SourceMediaPreviousMultiHandler, this);
-	}
+	signal_handler_disconnect(sh, "activate", HandleInputActiveStateChanged, this);
+	signal_handler_disconnect(sh, "deactivate", HandleInputActiveStateChanged, this);
+	signal_handler_disconnect(sh, "show", HandleInputShowStateChanged, this);
+	signal_handler_disconnect(sh, "hide", HandleInputShowStateChanged, this);
+	signal_handler_disconnect(sh, "mute", HandleInputMuteStateChanged, this);
+	signal_handler_disconnect(sh, "volume", HandleInputVolumeChanged, this);
+	signal_handler_disconnect(sh, "audio_sync", HandleInputAudioSyncOffsetChanged, this);
+	signal_handler_disconnect(sh, "audio_mixers", HandleInputAudioTracksChanged, this);
+	//signal_handler_disconnect(sh, "audio_monitoring", HandleInputAudioMonitorTypeChanged, this);
+	signal_handler_disconnect(sh, "media_started", HandleMediaInputPlaybackStarted, this);
+	signal_handler_disconnect(sh, "media_ended", HandleMediaInputPlaybackEnded, this);
+	signal_handler_disconnect(sh, "media_pause", SourceMediaPauseMultiHandler, this);
+	signal_handler_disconnect(sh, "media_play", SourceMediaPlayMultiHandler, this);
+	signal_handler_disconnect(sh, "media_restart", SourceMediaRestartMultiHandler, this);
+	signal_handler_disconnect(sh, "media_stopped", SourceMediaStopMultiHandler, this);
+	signal_handler_disconnect(sh, "media_next", SourceMediaNextMultiHandler, this);
+	signal_handler_disconnect(sh, "media_previous", SourceMediaPreviousMultiHandler, this);

 	// Scenes
-	if (sourceType == OBS_SOURCE_TYPE_SCENE) {
-		signal_handler_disconnect(sh, "item_add", HandleSceneItemCreated, this);
-		signal_handler_disconnect(sh, "item_remove", HandleSceneItemRemoved, this);
-		signal_handler_disconnect(sh, "reorder", HandleSceneItemListReindexed, this);
-		signal_handler_disconnect(sh, "item_visible", HandleSceneItemEnableStateChanged, this);
-		signal_handler_disconnect(sh, "item_locked", HandleSceneItemLockStateChanged, this);
-		signal_handler_disconnect(sh, "item_select", HandleSceneItemSelected, this);
-		signal_handler_disconnect(sh, "item_transform", HandleSceneItemTransformChanged, this);
-	}
-
-	// Inputs and Scenes
-	if (sourceType == OBS_SOURCE_TYPE_INPUT || sourceType == OBS_SOURCE_TYPE_SCENE) {
-		signal_handler_disconnect(sh, "reorder_filters", HandleSourceFilterListReindexed, this);
-		signal_handler_disconnect(sh, "filter_add", FilterAddMultiHandler, this);
-		signal_handler_disconnect(sh, "filter_remove", FilterRemoveMultiHandler, this);
-		auto enumFilters = [](obs_source_t *, obs_source_t *filter, void *param){
-			auto eventHandler = static_cast<EventHandler*>(param);
-			eventHandler->DisconnectSourceSignals(filter);
-		};
-		obs_source_enum_filters(source, enumFilters, this);
-	}
-
-	// Transitions
-	if (sourceType == OBS_SOURCE_TYPE_TRANSITION) {
-		signal_handler_disconnect(sh, "transition_start", HandleSceneTransitionStarted, this);
-		signal_handler_disconnect(sh, "transition_stop", HandleSceneTransitionEnded, this);
-		signal_handler_disconnect(sh, "transition_video_stop", HandleSceneTransitionVideoEnded, this);
-	}
-
-	// Filters
-	if (sourceType == OBS_SOURCE_TYPE_FILTER) {
-		signal_handler_disconnect(sh, "enable", HandleSourceFilterEnableStateChanged, this);
-		signal_handler_disconnect(sh, "rename", HandleSourceFilterNameChanged, this);
-	}
+	signal_handler_disconnect(sh, "item_add", HandleSceneItemCreated, this);
+	signal_handler_disconnect(sh, "item_remove", HandleSceneItemRemoved, this);
+	signal_handler_disconnect(sh, "reorder", HandleSceneItemListReindexed, this);
+	signal_handler_disconnect(sh, "item_visible", HandleSceneItemEnableStateChanged, this);
+	signal_handler_disconnect(sh, "item_locked", HandleSceneItemLockStateChanged, this);
+	signal_handler_disconnect(sh, "item_transform", HandleSceneItemTransformChanged, this);
 }

 void EventHandler::OnFrontendEvent(enum obs_frontend_event event, void *private_data)
 {
-	auto eventHandler = static_cast<EventHandler*>(private_data);
+	auto eventHandler = reinterpret_cast<EventHandler*>(private_data);

-	if (!eventHandler->_obsLoaded.load() && event != OBS_FRONTEND_EVENT_FINISHED_LOADING)
-		return;
-
-	switch (event) {
-		// General
-		case OBS_FRONTEND_EVENT_FINISHED_LOADING:
+	if (!eventHandler->_obsLoaded.load()) {
+		if (event == OBS_FRONTEND_EVENT_FINISHED_LOADING) {
 			blog_debug("[EventHandler::OnFrontendEvent] OBS has finished loading. Connecting final handlers and enabling events...");
-
 			// Connect source signals and enable events only after OBS has fully loaded (to reduce extra logging).
 			eventHandler->_obsLoaded.store(true);

 			// In the case that plugins become hotloadable, this will have to go back into `EventHandler::EventHandler()`
 			// Enumerate inputs and connect each one
-			{
-				auto enumInputs = [](void *param, obs_source_t *source) {
-					auto eventHandler = static_cast<EventHandler*>(param);
-					eventHandler->ConnectSourceSignals(source);
-					return true;
-				};
-				obs_enum_sources(enumInputs, private_data);
-			}
+			obs_enum_sources([](void* param, obs_source_t* source) {
+				auto eventHandler = reinterpret_cast<EventHandler*>(param);
+				eventHandler->ConnectSourceSignals(source);
+				return true;
+			}, private_data);

 			// Enumerate scenes and connect each one
-			{
-				auto enumScenes = [](void *param, obs_source_t *source) {
-					auto eventHandler = static_cast<EventHandler*>(param);
-					eventHandler->ConnectSourceSignals(source);
-					return true;
-				};
-				obs_enum_scenes(enumScenes, private_data);
-			}
-
-			// Enumerate all scene transitions and connect each one
-			{
-				obs_frontend_source_list transitions = {};
-				obs_frontend_get_transitions(&transitions);
-				for (size_t i = 0; i < transitions.sources.num; i++) {
-					obs_source_t* transition = transitions.sources.array[i];
-					eventHandler->ConnectSourceSignals(transition);
-				}
-				obs_frontend_source_list_free(&transitions);
-			}
+			obs_enum_scenes([](void* param, obs_source_t* source) {
+				auto eventHandler = reinterpret_cast<EventHandler*>(param);
+				eventHandler->ConnectSourceSignals(source);
+				return true;
+			}, private_data);

 			blog_debug("[EventHandler::OnFrontendEvent] Finished.");

 			if (eventHandler->_obsLoadedCallback)
 				eventHandler->_obsLoadedCallback();
+		} else {
+			return;
+		}
+	}

-			break;
+	switch (event) {
+		// General
 		case OBS_FRONTEND_EVENT_EXIT:
 			eventHandler->HandleExitStarted();

@ -318,35 +240,18 @@ void EventHandler::OnFrontendEvent(enum obs_frontend_event event, void *private_

 			// In the case that plugins become hotloadable, this will have to go back into `EventHandler::~EventHandler()`
 			// Enumerate inputs and disconnect each one
-			{
-				auto enumInputs = [](void *param, obs_source_t *source) {
-					auto eventHandler = static_cast<EventHandler*>(param);
-					eventHandler->DisconnectSourceSignals(source);
-					return true;
-				};
-				obs_enum_sources(enumInputs, private_data);
-			}
+			obs_enum_sources([](void* param, obs_source_t* source) {
+				auto eventHandler = reinterpret_cast<EventHandler*>(param);
+				eventHandler->DisconnectSourceSignals(source);
+				return true;
+			}, private_data);

 			// Enumerate scenes and disconnect each one
-			{
-				auto enumScenes = [](void *param, obs_source_t *source) {
-					auto eventHandler = static_cast<EventHandler*>(param);
-					eventHandler->DisconnectSourceSignals(source);
-					return true;
-				};
-				obs_enum_scenes(enumScenes, private_data);
-			}
-
-			// Enumerate all scene transitions and disconnect each one
-			{
-				obs_frontend_source_list transitions = {};
-				obs_frontend_get_transitions(&transitions);
-				for (size_t i = 0; i < transitions.sources.num; i++) {
-					obs_source_t* transition = transitions.sources.array[i];
-					eventHandler->DisconnectSourceSignals(transition);
-				}
-				obs_frontend_source_list_free(&transitions);
-			}
+			obs_enum_scenes([](void* param, obs_source_t* source) {
+				auto eventHandler = reinterpret_cast<EventHandler*>(param);
+				eventHandler->DisconnectSourceSignals(source);
+				return true;
+			}, private_data);

 			blog_debug("[EventHandler::OnFrontendEvent] Finished.");

@ -359,36 +264,18 @@ void EventHandler::OnFrontendEvent(enum obs_frontend_event event, void *private_
 			break;

 		// Config
-		case OBS_FRONTEND_EVENT_SCENE_COLLECTION_CHANGING:
-			{
-				obs_frontend_source_list transitions = {};
-				obs_frontend_get_transitions(&transitions);
-				for (size_t i = 0; i < transitions.sources.num; i++) {
-					obs_source_t* transition = transitions.sources.array[i];
-					eventHandler->DisconnectSourceSignals(transition);
-				}
-				obs_frontend_source_list_free(&transitions);
-			}
-			eventHandler->HandleCurrentSceneCollectionChanging();
-			break;
+		//case OBS_FRONTEND_EVENT_SCENE_COLLECTION_CHANGING:
+		//	eventHandler->HandleCurrentSceneCollectionChanging();
+		//	break;
 		case OBS_FRONTEND_EVENT_SCENE_COLLECTION_CHANGED:
-			{
-				obs_frontend_source_list transitions = {};
-				obs_frontend_get_transitions(&transitions);
-				for (size_t i = 0; i < transitions.sources.num; i++) {
-					obs_source_t* transition = transitions.sources.array[i];
-					eventHandler->ConnectSourceSignals(transition);
-				}
-				obs_frontend_source_list_free(&transitions);
-			}
 			eventHandler->HandleCurrentSceneCollectionChanged();
 			break;
 		case OBS_FRONTEND_EVENT_SCENE_COLLECTION_LIST_CHANGED:
 			eventHandler->HandleSceneCollectionListChanged();
 			break;
-		case OBS_FRONTEND_EVENT_PROFILE_CHANGING:
-			eventHandler->HandleCurrentProfileChanging();
-			break;
+		//case OBS_FRONTEND_EVENT_PROFILE_CHANGING:
+		//	eventHandler->HandleCurrentProfileChanging();
+		//	break;
 		case OBS_FRONTEND_EVENT_PROFILE_CHANGED:
 			eventHandler->HandleCurrentProfileChanged();
 			break;
@ -409,21 +296,10 @@ void EventHandler::OnFrontendEvent(enum obs_frontend_event event, void *private_

 		// Transitions
 		case OBS_FRONTEND_EVENT_TRANSITION_CHANGED:
-			eventHandler->HandleCurrentSceneTransitionChanged();
 			break;
 		case OBS_FRONTEND_EVENT_TRANSITION_LIST_CHANGED:
-			{
-				obs_frontend_source_list transitions = {};
-				obs_frontend_get_transitions(&transitions);
-				for (size_t i = 0; i < transitions.sources.num; i++) {
-					obs_source_t* transition = transitions.sources.array[i];
-					eventHandler->ConnectSourceSignals(transition);
-				}
-				obs_frontend_source_list_free(&transitions);
-			}
 			break;
 		case OBS_FRONTEND_EVENT_TRANSITION_DURATION_CHANGED:
-			eventHandler->HandleCurrentSceneTransitionDurationChanged();
 			break;

 		// Outputs
@ -487,7 +363,7 @@ void EventHandler::OnFrontendEvent(enum obs_frontend_event event, void *private_
 // Only called for creation of a public source
 void EventHandler::SourceCreatedMultiHandler(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	// Don't react to signals until OBS has finished loading
 	if (!eventHandler->_obsLoaded.load())
@ -514,7 +390,7 @@ void EventHandler::SourceCreatedMultiHandler(void *param, calldata_t *data)
 // Only called for destruction of a public source
 void EventHandler::SourceDestroyedMultiHandler(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	// We can't use any smart types here because releasing the source will cause infinite recursion
 	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
@ -542,7 +418,7 @@ void EventHandler::SourceDestroyedMultiHandler(void *param, calldata_t *data)

 void EventHandler::SourceRemovedMultiHandler(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	if (!eventHandler->_obsLoaded.load())
 		return;
@ -565,7 +441,7 @@ void EventHandler::SourceRemovedMultiHandler(void *param, calldata_t *data)

 void EventHandler::SourceRenamedMultiHandler(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	if (!eventHandler->_obsLoaded.load())
 		return;
@ -583,6 +459,8 @@ void EventHandler::SourceRenamedMultiHandler(void *param, calldata_t *data)
 		case OBS_SOURCE_TYPE_INPUT:
 			eventHandler->HandleInputNameChanged(source, oldSourceName, sourceName);
 			break;
+		case OBS_SOURCE_TYPE_FILTER:
+			break;
 		case OBS_SOURCE_TYPE_TRANSITION:
 			break;
 		case OBS_SOURCE_TYPE_SCENE:
--- a/src/eventhandler/EventHandler.h
+++ b/src/eventhandler/EventHandler.h
@ -107,27 +107,10 @@ class EventHandler
 		static void HandleInputShowStateChanged(void *param, calldata_t *data); // Direct callback
 		static void HandleInputMuteStateChanged(void *param, calldata_t *data); // Direct callback
 		static void HandleInputVolumeChanged(void *param, calldata_t *data); // Direct callback
-		static void HandleInputAudioBalanceChanged(void *param, calldata_t *data); // Direct callback
 		static void HandleInputAudioSyncOffsetChanged(void *param, calldata_t *data); // Direct callback
 		static void HandleInputAudioTracksChanged(void *param, calldata_t *data); // Direct callback
 		static void HandleInputAudioMonitorTypeChanged(void *param, calldata_t *data); // Direct callback

-		// Transitions
-		void HandleCurrentSceneTransitionChanged();
-		void HandleCurrentSceneTransitionDurationChanged();
-		static void HandleSceneTransitionStarted(void *param, calldata_t *data); // Direct callback
-		static void HandleSceneTransitionEnded(void *param, calldata_t *data); // Direct callback
-		static void HandleSceneTransitionVideoEnded(void *param, calldata_t *data); // Direct callback
-
-		// Filters
-		static void FilterAddMultiHandler(void *param, calldata_t *data); // Direct callback
-		static void FilterRemoveMultiHandler(void *param, calldata_t *data); // Direct callback
-		static void HandleSourceFilterListReindexed(void *param, calldata_t *data); // Direct callback
-		void HandleSourceFilterCreated(obs_source_t *source, obs_source_t *filter);
-		void HandleSourceFilterRemoved(obs_source_t *source, obs_source_t *filter);
-		static void HandleSourceFilterNameChanged(void *param, calldata_t *data); // Direct callback
-		static void HandleSourceFilterEnableStateChanged(void *param, calldata_t *data); // Direct callback
-
 		// Outputs
 		void HandleStreamStateChanged(ObsOutputState state);
 		void HandleRecordStateChanged(ObsOutputState state);
@ -141,7 +124,6 @@ class EventHandler
 		static void HandleSceneItemListReindexed(void *param, calldata_t *data); // Direct callback
 		static void HandleSceneItemEnableStateChanged(void *param, calldata_t *data); // Direct callback
 		static void HandleSceneItemLockStateChanged(void *param, calldata_t *data); // Direct callback
-		static void HandleSceneItemSelected(void *param, calldata_t *data); // Direct callback
 		static void HandleSceneItemTransformChanged(void *param, calldata_t *data); // Direct callback

 		// Media Inputs
--- a/src/eventhandler/EventHandler_Filters.cpp
+++ b/src/eventhandler/EventHandler_Filters.cpp
@ -18,184 +18,3 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 */

 #include "EventHandler.h"
-
-void EventHandler::FilterAddMultiHandler(void *param, calldata_t *data)
-{
-	auto eventHandler = static_cast<EventHandler*>(param);
-
-	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
-	obs_source_t *filter = GetCalldataPointer<obs_source_t>(data, "filter");
-
-	if (!(source && filter))
-		return;
-
-	eventHandler->ConnectSourceSignals(filter);
-
-	eventHandler->HandleSourceFilterCreated(source, filter);
-}
-
-void EventHandler::FilterRemoveMultiHandler(void *param, calldata_t *data)
-{
-	auto eventHandler = static_cast<EventHandler*>(param);
-
-	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
-	obs_source_t *filter = GetCalldataPointer<obs_source_t>(data, "filter");
-
-	if (!(source && filter))
-		return;
-
-	eventHandler->DisconnectSourceSignals(filter);
-
-	eventHandler->HandleSourceFilterRemoved(source, filter);
-}
-
-/**
- * A source's filter list has been reindexed.
- *
- * @dataField sourceName | String        | Name of the source
- * @dataField filters    | Array<Object> | Array of filter objects
- *
- * @eventType SourceFilterListReindexed
- * @eventSubscription Filters
- * @complexity 3
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api events
- * @category filters
- */
-void EventHandler::HandleSourceFilterListReindexed(void *param, calldata_t *data)
-{
-	auto eventHandler = static_cast<EventHandler*>(param);
-
-	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
-	if (!source)
-		return;
-
-	json eventData;
-	eventData["sourceName"] = obs_source_get_name(source);
-	eventData["filters"] = Utils::Obs::ArrayHelper::GetSourceFilterList(source);
-	eventHandler->BroadcastEvent(EventSubscription::Filters, "SourceFilterListReindexed", eventData);
-}
-
-/**
- * A filter has been added to a source.
- *
- * @dataField sourceName            | String | Name of the source the filter was added to
- * @dataField filterName            | String | Name of the filter
- * @dataField filterKind            | String | The kind of the filter
- * @dataField filterIndex           | Number | Index position of the filter
- * @dataField filterSettings        | Object | The settings configured to the filter when it was created
- * @dataField defaultFilterSettings | Object | The default settings for the filter
- *
- * @eventType SourceFilterCreated
- * @eventSubscription Filters
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api events
- * @category filters
- */
-void EventHandler::HandleSourceFilterCreated(obs_source_t *source, obs_source_t *filter)
-{
-	std::string filterKind = obs_source_get_id(filter);
-	OBSDataAutoRelease filterSettings = obs_source_get_settings(filter);
-	OBSDataAutoRelease defaultFilterSettings = obs_get_source_defaults(filterKind.c_str());
-
-	json eventData;
-	eventData["sourceName"] = obs_source_get_name(source);
-	eventData["filterName"] = obs_source_get_name(filter);
-	eventData["filterKind"] = filterKind;
-	eventData["filterIndex"] = Utils::Obs::NumberHelper::GetSourceFilterIndex(source, filter);
-	eventData["filterSettings"] = Utils::Json::ObsDataToJson(filterSettings);
-	eventData["defaultFilterSettings"] = Utils::Json::ObsDataToJson(defaultFilterSettings, true);
-	BroadcastEvent(EventSubscription::Filters, "SourceFilterCreated", eventData);
-}
-
-/**
- * A filter has been removed from a source.
- *
- * @dataField sourceName | String | Name of the source the filter was on
- * @dataField filterName | String | Name of the filter
- *
- * @eventType SourceFilterRemoved
- * @eventSubscription Filters
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api events
- * @category filters
- */
-void EventHandler::HandleSourceFilterRemoved(obs_source_t *source, obs_source_t *filter)
-{
-	json eventData;
-	eventData["sourceName"] = obs_source_get_name(source);
-	eventData["filterName"] = obs_source_get_name(filter);
-	BroadcastEvent(EventSubscription::Filters, "SourceFilterRemoved", eventData);
-}
-
-/**
- * The name of a source filter has changed.
- *
- * @dataField sourceName    | String | The source the filter is on
- * @dataField oldFilterName | String | Old name of the filter
- * @dataField filterName    | String | New name of the filter
- *
- * @eventType SourceFilterNameChanged
- * @eventSubscription Filters
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api events
- * @category filters
- */
-void EventHandler::HandleSourceFilterNameChanged(void *param, calldata_t *data)
-{
-	auto eventHandler = static_cast<EventHandler*>(param);
-
-	obs_source_t *filter = GetCalldataPointer<obs_source_t>(data, "source");
-	if (!filter)
-		return;
-
-	json eventData;
-	eventData["sourceName"] = obs_source_get_name(obs_filter_get_parent(filter));
-	eventData["oldFilterName"] = calldata_string(data, "prev_name");
-	eventData["filterName"] = calldata_string(data, "new_name");
-	eventHandler->BroadcastEvent(EventSubscription::Filters, "SourceFilterNameChanged", eventData);
-}
-
-/**
- * A source filter's enable state has changed.
- *
- * @dataField sourceName    | String  | Name of the source the filter is on
- * @dataField filterName    | String  | Name of the filter
- * @dataField filterEnabled | Boolean | Whether the filter is enabled
- *
- * @eventType SourceFilterEnableStateChanged
- * @eventSubscription Filters
- * @complexity 3
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api events
- * @category filters
- */
-void EventHandler::HandleSourceFilterEnableStateChanged(void *param, calldata_t *data)
-{
-	auto eventHandler = static_cast<EventHandler*>(param);
-
-	obs_source_t *filter = GetCalldataPointer<obs_source_t>(data, "source");
-	if (!filter)
-		return;
-
-	// Not OBSSourceAutoRelease as get_parent doesn't increment refcount
-	obs_source_t *source = obs_filter_get_parent(filter);
-	if (!source)
-		return;
-
-	bool filterEnabled = calldata_bool(data, "enabled");
-
-	json eventData;
-	eventData["sourceName"] = obs_source_get_name(source);
-	eventData["filterName"] = obs_source_get_name(filter);
-	eventData["filterEnabled"] = filterEnabled;
-	eventHandler->BroadcastEvent(EventSubscription::Filters, "SourceFilterEnableStateChanged", eventData);
-}
--- a/src/eventhandler/EventHandler_Inputs.cpp
+++ b/src/eventhandler/EventHandler_Inputs.cpp
@ -111,7 +111,7 @@ void EventHandler::HandleInputNameChanged(obs_source_t *, std::string oldInputNa
 */
 void EventHandler::HandleInputActiveStateChanged(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	if (!eventHandler->_inputActiveStateChangedRef.load())
 		return;
@ -147,7 +147,7 @@ void EventHandler::HandleInputActiveStateChanged(void *param, calldata_t *data)
 */
 void EventHandler::HandleInputShowStateChanged(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	if (!eventHandler->_inputShowStateChangedRef.load())
 		return;
@ -181,7 +181,7 @@ void EventHandler::HandleInputShowStateChanged(void *param, calldata_t *data)
 */
 void EventHandler::HandleInputMuteStateChanged(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
 	if (!source)
@ -213,7 +213,7 @@ void EventHandler::HandleInputMuteStateChanged(void *param, calldata_t *data)
 */
 void EventHandler::HandleInputVolumeChanged(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
 	if (!source)
@ -236,39 +236,6 @@ void EventHandler::HandleInputVolumeChanged(void *param, calldata_t *data)
 	eventHandler->BroadcastEvent(EventSubscription::Inputs, "InputVolumeChanged", eventData);
 }

-/**
- * The audio balance value of an input has changed.
- *
- * @dataField inputName         | String | Name of the affected input
- * @dataField inputAudioBalance | Number | New audio balance value of the input
- *
- * @eventType InputAudioBalanceChanged
- * @eventSubscription Inputs
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @category inputs
- * @api events
- */
-void EventHandler::HandleInputAudioBalanceChanged(void *param, calldata_t *data)
-{
-	auto eventHandler = static_cast<EventHandler*>(param);
-
-	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
-	if (!source)
-		return;
-
-	if (obs_source_get_type(source) != OBS_SOURCE_TYPE_INPUT)
-		return;
-
-	float inputAudioBalance = (float)calldata_float(data, "balance");
-
-	json eventData;
-	eventData["inputName"] = obs_source_get_name(source);
-	eventData["inputAudioBalance"] = inputAudioBalance;
-	eventHandler->BroadcastEvent(EventSubscription::Inputs, "InputAudioBalanceChanged", eventData);
-}
-
 /**
 * The sync offset of an input has changed.
 *
@ -285,7 +252,7 @@ void EventHandler::HandleInputAudioBalanceChanged(void *param, calldata_t *data)
 */
 void EventHandler::HandleInputAudioSyncOffsetChanged(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
 	if (!source)
@ -305,8 +272,8 @@ void EventHandler::HandleInputAudioSyncOffsetChanged(void *param, calldata_t *da
 /**
 * The audio tracks of an input have changed.
 *
- * @dataField inputName        | String | Name of the input
- * @dataField inputAudioTracks | Object | Object of audio tracks along with their associated enable states
+ * @dataField inputName        | String         | Name of the input
+ * @dataField inputAudioTracks | Array<Boolean> | Array of audio tracks along with their associated enable states
 *
 * @eventType InputAudioTracksChanged
 * @eventSubscription Inputs
@ -318,7 +285,7 @@ void EventHandler::HandleInputAudioSyncOffsetChanged(void *param, calldata_t *da
 */
 void EventHandler::HandleInputAudioTracksChanged(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
 	if (!source)
@ -361,7 +328,7 @@ void EventHandler::HandleInputAudioTracksChanged(void *param, calldata_t *data)
 */
 void EventHandler::HandleInputAudioMonitorTypeChanged(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
 	if (!source)
--- a/src/eventhandler/EventHandler_MediaInputs.cpp
+++ b/src/eventhandler/EventHandler_MediaInputs.cpp
@ -35,7 +35,7 @@ std::string GetMediaInputActionString(ObsMediaInputAction action) {

 void EventHandler::SourceMediaPauseMultiHandler(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
 	if (!source)
@ -49,7 +49,7 @@ void EventHandler::SourceMediaPauseMultiHandler(void *param, calldata_t *data)

 void EventHandler::SourceMediaPlayMultiHandler(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
 	if (!source)
@ -63,7 +63,7 @@ void EventHandler::SourceMediaPlayMultiHandler(void *param, calldata_t *data)

 void EventHandler::SourceMediaRestartMultiHandler(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
 	if (!source)
@ -77,7 +77,7 @@ void EventHandler::SourceMediaRestartMultiHandler(void *param, calldata_t *data)

 void EventHandler::SourceMediaStopMultiHandler(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
 	if (!source)
@ -91,7 +91,7 @@ void EventHandler::SourceMediaStopMultiHandler(void *param, calldata_t *data)

 void EventHandler::SourceMediaNextMultiHandler(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
 	if (!source)
@ -105,7 +105,7 @@ void EventHandler::SourceMediaNextMultiHandler(void *param, calldata_t *data)

 void EventHandler::SourceMediaPreviousMultiHandler(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
 	if (!source)
@ -132,7 +132,7 @@ void EventHandler::SourceMediaPreviousMultiHandler(void *param, calldata_t *data
 */
 void EventHandler::HandleMediaInputPlaybackStarted(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
 	if (!source)
@ -161,7 +161,7 @@ void EventHandler::HandleMediaInputPlaybackStarted(void *param, calldata_t *data
 */
 void EventHandler::HandleMediaInputPlaybackEnded(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
 	if (!source)
--- a/src/eventhandler/EventHandler_SceneItems.cpp
+++ b/src/eventhandler/EventHandler_SceneItems.cpp
@ -37,7 +37,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 */
 void EventHandler::HandleSceneItemCreated(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	obs_scene_t *scene = GetCalldataPointer<obs_scene_t>(data, "scene");
 	if (!scene)
@ -74,7 +74,7 @@ void EventHandler::HandleSceneItemCreated(void *param, calldata_t *data)
 */
 void EventHandler::HandleSceneItemRemoved(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	obs_scene_t *scene = GetCalldataPointer<obs_scene_t>(data, "scene");
 	if (!scene)
@ -107,7 +107,7 @@ void EventHandler::HandleSceneItemRemoved(void *param, calldata_t *data)
 */
 void EventHandler::HandleSceneItemListReindexed(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	obs_scene_t *scene = GetCalldataPointer<obs_scene_t>(data, "scene");
 	if (!scene)
@ -136,7 +136,7 @@ void EventHandler::HandleSceneItemListReindexed(void *param, calldata_t *data)
 */
 void EventHandler::HandleSceneItemEnableStateChanged(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	obs_scene_t *scene = GetCalldataPointer<obs_scene_t>(data, "scene");
 	if (!scene)
@ -158,9 +158,9 @@ void EventHandler::HandleSceneItemEnableStateChanged(void *param, calldata_t *da
 /**
 * A scene item's lock state has changed.
 *
- * @dataField sceneName       | String  | Name of the scene the item is in
- * @dataField sceneItemId     | Number  | Numeric ID of the scene item
- * @dataField sceneItemLocked | Boolean | Whether the scene item is locked
+ * @dataField sceneName        | String  | Name of the scene the item is in
+ * @dataField sceneItemId      | Number  | Numeric ID of the scene item
+ * @dataField sceneItemEnabled | Boolean | Whether the scene item is locked
 *
 * @eventType SceneItemLockStateChanged
 * @eventSubscription SceneItems
@ -172,7 +172,7 @@ void EventHandler::HandleSceneItemEnableStateChanged(void *param, calldata_t *da
 */
 void EventHandler::HandleSceneItemLockStateChanged(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	obs_scene_t *scene = GetCalldataPointer<obs_scene_t>(data, "scene");
 	if (!scene)
@ -191,38 +191,6 @@ void EventHandler::HandleSceneItemLockStateChanged(void *param, calldata_t *data
 	eventHandler->BroadcastEvent(EventSubscription::SceneItems, "SceneItemLockStateChanged", eventData);
 }

-/**
- * A scene item has been selected in the Ui.
- *
- * @dataField sceneName        | String  | Name of the scene the item is in
- * @dataField sceneItemId      | Number  | Numeric ID of the scene item
- *
- * @eventType SceneItemSelected
- * @eventSubscription SceneItems
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api events
- * @category scene items
- */
-void EventHandler::HandleSceneItemSelected(void *param, calldata_t *data)
-{
-	auto eventHandler = static_cast<EventHandler*>(param);
-
-	obs_scene_t *scene = GetCalldataPointer<obs_scene_t>(data, "scene");
-	if (!scene)
-		return;
-
-	obs_sceneitem_t *sceneItem = GetCalldataPointer<obs_sceneitem_t>(data, "item");
-	if (!sceneItem)
-		return;
-
-	json eventData;
-	eventData["sceneName"] = obs_source_get_name(obs_scene_get_source(scene));
-	eventData["sceneItemId"] = obs_sceneitem_get_id(sceneItem);
-	eventHandler->BroadcastEvent(EventSubscription::SceneItems, "SceneItemSelected", eventData);
-}
-
 /**
 * The transform/crop of a scene item has changed.
 *
@ -240,7 +208,7 @@ void EventHandler::HandleSceneItemSelected(void *param, calldata_t *data)
 */
 void EventHandler::HandleSceneItemTransformChanged(void *param, calldata_t *data)
 {
-	auto eventHandler = static_cast<EventHandler*>(param);
+	auto eventHandler = reinterpret_cast<EventHandler*>(param);

 	if (!eventHandler->_sceneItemTransformChangedRef.load())
 		return;
--- a/src/eventhandler/EventHandler_Transitions.cpp
+++ b/src/eventhandler/EventHandler_Transitions.cpp
@ -18,130 +18,3 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 */

 #include "EventHandler.h"
-
-/**
- * The current scene transition has changed.
- *
- * @dataField transitionName | String | Name of the new transition
- *
- * @eventType CurrentSceneTransitionChanged
- * @eventSubscription Transitions
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api events
- * @category transitions
- */
-void EventHandler::HandleCurrentSceneTransitionChanged()
-{
-	OBSSourceAutoRelease transition = obs_frontend_get_current_transition();
-
-	json eventData;
-	eventData["transitionName"] = obs_source_get_name(transition);
-	BroadcastEvent(EventSubscription::Transitions, "CurrentSceneTransitionChanged", eventData);
-}
-
-/**
- * The current scene transition duration has changed.
- *
- * @dataField transitionDuration | Number | Transition duration in milliseconds
- *
- * @eventType CurrentSceneTransitionDurationChanged
- * @eventSubscription Transitions
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api events
- * @category transitions
- */
-void EventHandler::HandleCurrentSceneTransitionDurationChanged()
-{
-	json eventData;
-	eventData["transitionDuration"] = obs_frontend_get_transition_duration();
-	BroadcastEvent(EventSubscription::Transitions, "CurrentSceneTransitionDurationChanged", eventData);
-}
-
-/**
- * A scene transition has started.
- *
- * @dataField transitionName | String | Scene transition name
- *
- * @eventType SceneTransitionStarted
- * @eventSubscription Transitions
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api events
- * @category transitions
- */
-void EventHandler::HandleSceneTransitionStarted(void *param, calldata_t *data)
-{
-	auto eventHandler = static_cast<EventHandler*>(param);
-
-	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
-	if (!source)
-		return;
-
-	json eventData;
-	eventData["transitionName"] = obs_source_get_name(source);
-	eventHandler->BroadcastEvent(EventSubscription::Transitions, "SceneTransitionStarted", eventData);
-}
-
-/**
- * A scene transition has completed fully.
- *
- * Note: Does not appear to trigger when the transition is interrupted by the user.
- *
- * @dataField transitionName | String | Scene transition name
- *
- * @eventType SceneTransitionEnded
- * @eventSubscription Transitions
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api events
- * @category transitions
- */
-void EventHandler::HandleSceneTransitionEnded(void *param, calldata_t *data)
-{
-	auto eventHandler = static_cast<EventHandler*>(param);
-
-	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
-	if (!source)
-		return;
-
-	json eventData;
-	eventData["transitionName"] = obs_source_get_name(source);
-	eventHandler->BroadcastEvent(EventSubscription::Transitions, "SceneTransitionEnded", eventData);
-}
-
-/**
- * A scene transition's video has completed fully.
- *
- * Useful for stinger transitions to tell when the video *actually* ends.
- * `SceneTransitionEnded` only signifies the cut point, not the completion of transition playback.
- *
- * Note: Appears to be called by every transition, regardless of relevance.
- *
- * @dataField transitionName | String | Scene transition name
- *
- * @eventType SceneTransitionVideoEnded
- * @eventSubscription Transitions
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api events
- * @category transitions
- */
-void EventHandler::HandleSceneTransitionVideoEnded(void *param, calldata_t *data)
-{
-	auto eventHandler = static_cast<EventHandler*>(param);
-
-	obs_source_t *source = GetCalldataPointer<obs_source_t>(data, "source");
-	if (!source)
-		return;
-
-	json eventData;
-	eventData["transitionName"] = obs_source_get_name(source);
-	eventHandler->BroadcastEvent(EventSubscription::Transitions, "SceneTransitionVideoEnded", eventData);
-}
--- a/src/forms/SettingsDialog.ui
+++ b/src/forms/SettingsDialog.ui
@ -151,7 +151,7 @@
         <number>65534</number>
        </property>
        <property name="value">
-         <number>4455</number>
+         <number>4444</number>
        </property>
       </widget>
      </item>
--- a/src/obs-websocket.cpp
+++ b/src/obs-websocket.cpp
@ -48,7 +48,6 @@ bool obs_module_load(void)
 {
 	blog(LOG_INFO, "[obs_module_load] you can haz websockets (Version: %s | RPC Version: %d)", OBS_WEBSOCKET_VERSION, OBS_WEBSOCKET_RPC_VERSION);
 	blog(LOG_INFO, "[obs_module_load] Qt version (compile-time): %s | Qt version (run-time): %s", QT_VERSION_STR, qVersion());
-	blog(LOG_INFO, "[obs_module_load] Linked ASIO Version: %d", ASIO_VERSION);

 	// Initialize the cpu stats
 	_cpuUsageInfo = os_cpu_usage_info_start();
@ -69,7 +68,7 @@ bool obs_module_load(void)

 	// Initialize the settings dialog
 	obs_frontend_push_ui_translation(obs_module_get_string);
-	QMainWindow* mainWindow = static_cast<QMainWindow*>(obs_frontend_get_main_window());
+	QMainWindow* mainWindow = reinterpret_cast<QMainWindow*>(obs_frontend_get_main_window());
 	_settingsDialog = new SettingsDialog(mainWindow);
 	obs_frontend_pop_ui_translation();

--- a/src/obs-websocket.h
+++ b/src/obs-websocket.h
@ -21,7 +21,13 @@ with this program. If not, see <https://www.gnu.org/licenses/>

 #include <memory>
 #include <obs.hpp>
+#ifdef _MSC_VER
+    #pragma push_macro("strtoll")
+#endif
 #include <util/platform.h>
+#ifdef _MSC_VER
+    #pragma pop_macro("strtoll")
+#endif

 #include "utils/Obs.h"
 #include "plugin-macros.generated.h"
--- a/src/requesthandler/RequestBatchHandler.cpp
+++ b/src/requesthandler/RequestBatchHandler.cpp
@ -109,7 +109,7 @@ static void ObsTickCallback(void *param, float)
 {
 	ScopeProfiler prof{"obs_websocket_request_batch_frame_tick"};

-	auto serialFrameBatch = static_cast<SerialFrameBatch*>(param);
+	auto serialFrameBatch = reinterpret_cast<SerialFrameBatch*>(param);

 	// Increment frame count
 	serialFrameBatch->frameCount++;
--- a/src/requesthandler/RequestHandler.cpp
+++ b/src/requesthandler/RequestHandler.cpp
@ -17,13 +17,9 @@ You should have received a copy of the GNU General Public License along
 with this program. If not, see <https://www.gnu.org/licenses/>
 */

-#ifdef PLUGIN_TESTS
-#include <util/profiler.hpp>
-#endif
-
 #include "RequestHandler.h"

-const std::unordered_map<std::string, RequestMethodHandler> RequestHandler::_handlerMap
+const std::map<std::string, RequestMethodHandler> RequestHandler::_handlerMap
 {
 	// General
 	{"GetVersion", &RequestHandler::GetVersion},
@ -51,18 +47,14 @@ const std::unordered_map<std::string, RequestMethodHandler> RequestHandler::_han
 	{"SetVideoSettings", &RequestHandler::SetVideoSettings},
 	{"GetStreamServiceSettings", &RequestHandler::GetStreamServiceSettings},
 	{"SetStreamServiceSettings", &RequestHandler::SetStreamServiceSettings},
-	{"GetRecordDirectory", &RequestHandler::GetRecordDirectory},

 	// Sources
 	{"GetSourceActive", &RequestHandler::GetSourceActive},
 	{"GetSourceScreenshot", &RequestHandler::GetSourceScreenshot},
 	{"SaveSourceScreenshot", &RequestHandler::SaveSourceScreenshot},
-	{"GetSourcePrivateSettings", &RequestHandler::GetSourcePrivateSettings},
-	{"SetSourcePrivateSettings", &RequestHandler::SetSourcePrivateSettings},

 	// Scenes
 	{"GetSceneList", &RequestHandler::GetSceneList},
-	{"GetGroupList", &RequestHandler::GetGroupList},
 	{"GetCurrentProgramScene", &RequestHandler::GetCurrentProgramScene},
 	{"SetCurrentProgramScene", &RequestHandler::SetCurrentProgramScene},
 	{"GetCurrentPreviewScene", &RequestHandler::GetCurrentPreviewScene},
@ -70,15 +62,12 @@ const std::unordered_map<std::string, RequestMethodHandler> RequestHandler::_han
 	{"CreateScene", &RequestHandler::CreateScene},
 	{"RemoveScene", &RequestHandler::RemoveScene},
 	{"SetSceneName", &RequestHandler::SetSceneName},
-	{"GetSceneSceneTransitionOverride", &RequestHandler::GetSceneSceneTransitionOverride},
-	{"SetSceneSceneTransitionOverride", &RequestHandler::SetSceneSceneTransitionOverride},

 	// Inputs
 	{"GetInputList", &RequestHandler::GetInputList},
 	{"GetInputKindList", &RequestHandler::GetInputKindList},
-	{"GetSpecialInputs", &RequestHandler::GetSpecialInputs},
 	{"CreateInput", &RequestHandler::CreateInput},
-	{"RemoveInput", &RequestHandler::RemoveInput},
+	//{"RemoveInput", &RequestHandler::RemoveInput}, // Disabled for now. Pending obs-studio#5276
 	{"SetInputName", &RequestHandler::SetInputName},
 	{"GetInputDefaultSettings", &RequestHandler::GetInputDefaultSettings},
 	{"GetInputSettings", &RequestHandler::GetInputSettings},
@ -88,14 +77,10 @@ const std::unordered_map<std::string, RequestMethodHandler> RequestHandler::_han
 	{"ToggleInputMute", &RequestHandler::ToggleInputMute},
 	{"GetInputVolume", &RequestHandler::GetInputVolume},
 	{"SetInputVolume", &RequestHandler::SetInputVolume},
-	{"GetInputAudioBalance", &RequestHandler::GetInputAudioBalance},
-	{"SetInputAudioBalance", &RequestHandler::SetInputAudioBalance},
 	{"GetInputAudioSyncOffset", &RequestHandler::GetInputAudioSyncOffset},
 	{"SetInputAudioSyncOffset", &RequestHandler::SetInputAudioSyncOffset},
 	{"GetInputAudioMonitorType", &RequestHandler::GetInputAudioMonitorType},
 	{"SetInputAudioMonitorType", &RequestHandler::SetInputAudioMonitorType},
-	{"GetInputAudioTracks", &RequestHandler::GetInputAudioTracks},
-	{"SetInputAudioTracks", &RequestHandler::SetInputAudioTracks},
 	{"GetInputPropertiesListPropertyItems", &RequestHandler::GetInputPropertiesListPropertyItems},
 	{"PressInputPropertiesButton", &RequestHandler::PressInputPropertiesButton},

@ -106,20 +91,7 @@ const std::unordered_map<std::string, RequestMethodHandler> RequestHandler::_han
 	{"SetCurrentSceneTransition", &RequestHandler::SetCurrentSceneTransition},
 	{"SetCurrentSceneTransitionDuration", &RequestHandler::SetCurrentSceneTransitionDuration},
 	{"SetCurrentSceneTransitionSettings", &RequestHandler::SetCurrentSceneTransitionSettings},
-	{"GetCurrentSceneTransitionCursor", &RequestHandler::GetCurrentSceneTransitionCursor},
 	{"TriggerStudioModeTransition", &RequestHandler::TriggerStudioModeTransition},
-	{"SetTBarPosition", &RequestHandler::SetTBarPosition},
-
-	// Filters
-	{"GetSourceFilterList", &RequestHandler::GetSourceFilterList},
-	{"GetSourceFilterDefaultSettings", &RequestHandler::GetSourceFilterDefaultSettings},
-	{"CreateSourceFilter", &RequestHandler::CreateSourceFilter},
-	{"RemoveSourceFilter", &RequestHandler::RemoveSourceFilter},
-	{"SetSourceFilterName", &RequestHandler::SetSourceFilterName},
-	{"GetSourceFilter", &RequestHandler::GetSourceFilter},
-	{"SetSourceFilterIndex", &RequestHandler::SetSourceFilterIndex},
-	{"SetSourceFilterSettings", &RequestHandler::SetSourceFilterSettings},
-	{"SetSourceFilterEnabled", &RequestHandler::SetSourceFilterEnabled},

 	// Scene Items
 	{"GetSceneItemList", &RequestHandler::GetSceneItemList},
@ -136,27 +108,12 @@ const std::unordered_map<std::string, RequestMethodHandler> RequestHandler::_han
 	{"SetSceneItemLocked", &RequestHandler::SetSceneItemLocked},
 	{"GetSceneItemIndex", &RequestHandler::GetSceneItemIndex},
 	{"SetSceneItemIndex", &RequestHandler::SetSceneItemIndex},
-	{"GetSceneItemBlendMode", &RequestHandler::GetSceneItemBlendMode},
-	{"SetSceneItemBlendMode", &RequestHandler::SetSceneItemBlendMode},
-
-	// Outputs
-	{"GetVirtualCamStatus", &RequestHandler::GetVirtualCamStatus},
-	{"ToggleVirtualCam", &RequestHandler::ToggleVirtualCam},
-	{"StartVirtualCam", &RequestHandler::StartVirtualCam},
-	{"StopVirtualCam", &RequestHandler::StopVirtualCam},
-	{"GetReplayBufferStatus", &RequestHandler::GetReplayBufferStatus},
-	{"ToggleReplayBuffer", &RequestHandler::ToggleReplayBuffer},
-	{"StartReplayBuffer", &RequestHandler::StartReplayBuffer},
-	{"StopReplayBuffer", &RequestHandler::StopReplayBuffer},
-	{"SaveReplayBuffer", &RequestHandler::SaveReplayBuffer},
-	{"GetLastReplayBufferReplay", &RequestHandler::GetLastReplayBufferReplay},

 	// Stream
 	{"GetStreamStatus", &RequestHandler::GetStreamStatus},
 	{"ToggleStream", &RequestHandler::ToggleStream},
 	{"StartStream", &RequestHandler::StartStream},
 	{"StopStream", &RequestHandler::StopStream},
-	{"SendStreamCaption", &RequestHandler::SendStreamCaption},

 	// Record
 	{"GetRecordStatus", &RequestHandler::GetRecordStatus},
@ -166,6 +123,7 @@ const std::unordered_map<std::string, RequestMethodHandler> RequestHandler::_han
 	{"ToggleRecordPause", &RequestHandler::ToggleRecordPause},
 	{"PauseRecord", &RequestHandler::PauseRecord},
 	{"ResumeRecord", &RequestHandler::ResumeRecord},
+	//{"GetRecordDirectory", &RequestHandler::GetRecordDirectory},

 	// Media Inputs
 	{"GetMediaInputStatus", &RequestHandler::GetMediaInputStatus},
@ -176,9 +134,6 @@ const std::unordered_map<std::string, RequestMethodHandler> RequestHandler::_han
 	// Ui
 	{"GetStudioModeEnabled", &RequestHandler::GetStudioModeEnabled},
 	{"SetStudioModeEnabled", &RequestHandler::SetStudioModeEnabled},
-	{"OpenInputPropertiesDialog", &RequestHandler::OpenInputPropertiesDialog},
-	{"OpenInputFiltersDialog", &RequestHandler::OpenInputFiltersDialog},
-	{"OpenInputInteractDialog", &RequestHandler::OpenInputInteractDialog},
 };

 RequestHandler::RequestHandler(SessionPtr session) :
@ -188,10 +143,6 @@ RequestHandler::RequestHandler(SessionPtr session) :

 RequestResult RequestHandler::ProcessRequest(const Request& request)
 {
-#ifdef PLUGIN_TESTS
-	ScopeProfiler prof{"obs_websocket_request_processing"};
-#endif
-
 	if (!request.RequestData.is_object() && !request.RequestData.is_null())
 		return RequestResult::Error(RequestStatus::InvalidRequestFieldType, "Your request data is not an object.");

--- a/src/requesthandler/RequestHandler.h
+++ b/src/requesthandler/RequestHandler.h
@ -19,7 +19,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>

 #pragma once

-#include <unordered_map>
+#include <map>
 #include <obs.hpp>
 #include <obs-frontend-api.h>

@ -69,18 +69,14 @@ class RequestHandler {
 		RequestResult SetVideoSettings(const Request&);
 		RequestResult GetStreamServiceSettings(const Request&);
 		RequestResult SetStreamServiceSettings(const Request&);
-		RequestResult GetRecordDirectory(const Request&);

 		// Sources
 		RequestResult GetSourceActive(const Request&);
 		RequestResult GetSourceScreenshot(const Request&);
 		RequestResult SaveSourceScreenshot(const Request&);
-		RequestResult GetSourcePrivateSettings(const Request&);
-		RequestResult SetSourcePrivateSettings(const Request&);

 		// Scenes
 		RequestResult GetSceneList(const Request&);
-		RequestResult GetGroupList(const Request&);
 		RequestResult GetCurrentProgramScene(const Request&);
 		RequestResult SetCurrentProgramScene(const Request&);
 		RequestResult GetCurrentPreviewScene(const Request&);
@ -88,13 +84,10 @@ class RequestHandler {
 		RequestResult CreateScene(const Request&);
 		RequestResult RemoveScene(const Request&);
 		RequestResult SetSceneName(const Request&);
-		RequestResult GetSceneSceneTransitionOverride(const Request&);
-		RequestResult SetSceneSceneTransitionOverride(const Request&);

 		// Inputs
 		RequestResult GetInputList(const Request&);
 		RequestResult GetInputKindList(const Request&);
-		RequestResult GetSpecialInputs(const Request&);
 		RequestResult CreateInput(const Request&);
 		RequestResult RemoveInput(const Request&);
 		RequestResult SetInputName(const Request&);
@ -106,14 +99,10 @@ class RequestHandler {
 		RequestResult ToggleInputMute(const Request&);
 		RequestResult GetInputVolume(const Request&);
 		RequestResult SetInputVolume(const Request&);
-		RequestResult GetInputAudioBalance(const Request&);
-		RequestResult SetInputAudioBalance(const Request&);
 		RequestResult GetInputAudioSyncOffset(const Request&);
 		RequestResult SetInputAudioSyncOffset(const Request&);
 		RequestResult GetInputAudioMonitorType(const Request&);
 		RequestResult SetInputAudioMonitorType(const Request&);
-		RequestResult GetInputAudioTracks(const Request&);
-		RequestResult SetInputAudioTracks(const Request&);
 		RequestResult GetInputPropertiesListPropertyItems(const Request&);
 		RequestResult PressInputPropertiesButton(const Request&);

@ -124,20 +113,7 @@ class RequestHandler {
 		RequestResult SetCurrentSceneTransition(const Request&);
 		RequestResult SetCurrentSceneTransitionDuration(const Request&);
 		RequestResult SetCurrentSceneTransitionSettings(const Request&);
-		RequestResult GetCurrentSceneTransitionCursor(const Request&);
 		RequestResult TriggerStudioModeTransition(const Request&);
-		RequestResult SetTBarPosition(const Request&);
-
-		// Filters
-		RequestResult GetSourceFilterList(const Request&);
-		RequestResult GetSourceFilterDefaultSettings(const Request&);
-		RequestResult CreateSourceFilter(const Request&);
-		RequestResult RemoveSourceFilter(const Request&);
-		RequestResult SetSourceFilterName(const Request&);
-		RequestResult GetSourceFilter(const Request&);
-		RequestResult SetSourceFilterIndex(const Request&);
-		RequestResult SetSourceFilterSettings(const Request&);
-		RequestResult SetSourceFilterEnabled(const Request&);

 		// Scene Items
 		RequestResult GetSceneItemList(const Request&);
@ -154,27 +130,12 @@ class RequestHandler {
 		RequestResult SetSceneItemLocked(const Request&);
 		RequestResult GetSceneItemIndex(const Request&);
 		RequestResult SetSceneItemIndex(const Request&);
-		RequestResult GetSceneItemBlendMode(const Request&);
-		RequestResult SetSceneItemBlendMode(const Request&);
-
-		// Outputs
-		RequestResult GetVirtualCamStatus(const Request&);
-		RequestResult ToggleVirtualCam(const Request&);
-		RequestResult StartVirtualCam(const Request&);
-		RequestResult StopVirtualCam(const Request&);
-		RequestResult GetReplayBufferStatus(const Request&);
-		RequestResult ToggleReplayBuffer(const Request&);
-		RequestResult StartReplayBuffer(const Request&);
-		RequestResult StopReplayBuffer(const Request&);
-		RequestResult SaveReplayBuffer(const Request&);
-		RequestResult GetLastReplayBufferReplay(const Request&);

 		// Stream
 		RequestResult GetStreamStatus(const Request&);
 		RequestResult ToggleStream(const Request&);
 		RequestResult StartStream(const Request&);
 		RequestResult StopStream(const Request&);
-		RequestResult SendStreamCaption(const Request&);

 		// Record
 		RequestResult GetRecordStatus(const Request&);
@ -184,6 +145,7 @@ class RequestHandler {
 		RequestResult ToggleRecordPause(const Request&);
 		RequestResult PauseRecord(const Request&);
 		RequestResult ResumeRecord(const Request&);
+		RequestResult GetRecordDirectory(const Request&);

 		// Media Inputs
 		RequestResult GetMediaInputStatus(const Request&);
@ -194,10 +156,7 @@ class RequestHandler {
 		// Ui
 		RequestResult GetStudioModeEnabled(const Request&);
 		RequestResult SetStudioModeEnabled(const Request&);
-		RequestResult OpenInputPropertiesDialog(const Request&);
-		RequestResult OpenInputFiltersDialog(const Request&);
-		RequestResult OpenInputInteractDialog(const Request&);

 		SessionPtr _session;
-		static const std::unordered_map<std::string, RequestMethodHandler> _handlerMap;
+		static const std::map<std::string, RequestMethodHandler> _handlerMap;
 };
--- a/src/requesthandler/RequestHandler_Config.cpp
+++ b/src/requesthandler/RequestHandler_Config.cpp
@ -159,7 +159,7 @@ RequestResult RequestHandler::SetCurrentSceneCollection(const Request& request)
 	// Avoid queueing tasks if nothing will change
 	if (currentSceneCollectionName != sceneCollectionName) {
 		obs_queue_task(OBS_TASK_UI, [](void* param) {
-			obs_frontend_set_current_scene_collection(static_cast<const char*>(param));
+			obs_frontend_set_current_scene_collection(reinterpret_cast<const char*>(param));
 		}, (void*)sceneCollectionName.c_str(), true);
 	}

@ -193,7 +193,7 @@ RequestResult RequestHandler::CreateSceneCollection(const Request& request)
 	if (std::find(sceneCollections.begin(), sceneCollections.end(), sceneCollectionName) != sceneCollections.end())
 		return RequestResult::Error(RequestStatus::ResourceAlreadyExists);

-	QMainWindow* mainWindow = static_cast<QMainWindow*>(obs_frontend_get_main_window());
+	QMainWindow* mainWindow = reinterpret_cast<QMainWindow*>(obs_frontend_get_main_window());
 	bool success = false;
 	QMetaObject::invokeMethod(mainWindow, "AddSceneCollection", Qt::BlockingQueuedConnection, Q_RETURN_ARG(bool, success), Q_ARG(bool, true), Q_ARG(QString, QString::fromStdString(sceneCollectionName)));
 	if (!success)
@ -252,7 +252,7 @@ RequestResult RequestHandler::SetCurrentProfile(const Request& request)
 	// Avoid queueing tasks if nothing will change
 	if (currentProfileName != profileName) {
 		obs_queue_task(OBS_TASK_UI, [](void* param) {
-			obs_frontend_set_current_profile(static_cast<const char*>(param));
+			obs_frontend_set_current_profile(reinterpret_cast<const char*>(param));
 		}, (void*)profileName.c_str(), true);
 	}

@ -284,7 +284,7 @@ RequestResult RequestHandler::CreateProfile(const Request& request)
 	if (std::find(profiles.begin(), profiles.end(), profileName) != profiles.end())
 		return RequestResult::Error(RequestStatus::ResourceAlreadyExists);

-	QMainWindow* mainWindow = static_cast<QMainWindow*>(obs_frontend_get_main_window());
+	QMainWindow* mainWindow = reinterpret_cast<QMainWindow*>(obs_frontend_get_main_window());
 	QMetaObject::invokeMethod(mainWindow, "NewProfile", Qt::BlockingQueuedConnection, Q_ARG(QString, QString::fromStdString(profileName)));

 	return RequestResult::Success();
@ -318,7 +318,7 @@ RequestResult RequestHandler::RemoveProfile(const Request& request)
 	if (profiles.size() < 2)
 		return RequestResult::Error(RequestStatus::NotEnoughResources);

-	QMainWindow* mainWindow = static_cast<QMainWindow*>(obs_frontend_get_main_window());
+	QMainWindow* mainWindow = reinterpret_cast<QMainWindow*>(obs_frontend_get_main_window());
 	QMetaObject::invokeMethod(mainWindow, "DeleteProfile", Qt::BlockingQueuedConnection, Q_ARG(QString, QString::fromStdString(profileName)));

 	return RequestResult::Success();
@ -408,8 +408,6 @@ RequestResult RequestHandler::SetProfileParameter(const Request& request)
 		return RequestResult::Error(RequestStatus::InvalidRequestFieldType, "The field `parameterValue` must be a string.");
 	}

-	config_save(profile);
-
 	return RequestResult::Success();
 }

@ -594,23 +592,3 @@ RequestResult RequestHandler::SetStreamServiceSettings(const Request& request)

 	return RequestResult::Success();
 }
-
-/**
- * Gets the current directory that the record output is set to.
- *
- * @responseField recordDirectory | String | Output directory
- *
- * @requestType GetRecordDirectory
- * @complexity 1
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category rconfig
- */
-RequestResult RequestHandler::GetRecordDirectory(const Request&)
-{
-	json responseData;
-	responseData["recordDirectory"] = Utils::Obs::StringHelper::GetCurrentRecordOutputPath();
-
-	return RequestResult::Success(responseData);
-}
--- a/src/requesthandler/RequestHandler_Filters.cpp
+++ b/src/requesthandler/RequestHandler_Filters.cpp
@ -18,317 +18,3 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 */

 #include "RequestHandler.h"
-
-/**
- * Gets an array of all of a source's filters.
- *
- * @requestField sourceName | String | Name of the source
- *
- * @responseField filters | Array<Object> | Array of filters
- *
- * @requestType GetSourceFilterList
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category filters
- */
-RequestResult RequestHandler::GetSourceFilterList(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSSourceAutoRelease source = request.ValidateSource("sourceName", statusCode, comment);
-	if(!source)
-		return RequestResult::Error(statusCode, comment);
-
-	json responseData;
-	responseData["filters"] = Utils::Obs::ArrayHelper::GetSourceFilterList(source);
-
-	return RequestResult::Success(responseData);
-}
-
-/**
- * Gets the default settings for a filter kind.
- *
- * @requestField filterKind | String | Filter kind to get the default settings for
- *
- * @responseField defaultFilterSettings | Object | Object of default settings for the filter kind
- *
- * @requestType GetSourceFilterDefaultSettings
- * @complexity 3
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category filters
- */
-RequestResult RequestHandler::GetSourceFilterDefaultSettings(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	if (!request.ValidateString("filterKind", statusCode, comment))
-		return RequestResult::Error(statusCode, comment);
-
-	std::string filterKind = request.RequestData["filterKind"];
-	auto kinds = Utils::Obs::ArrayHelper::GetFilterKindList();
-	if (std::find(kinds.begin(), kinds.end(), filterKind) == kinds.end())
-		return RequestResult::Error(RequestStatus::InvalidFilterKind);
-
-	OBSDataAutoRelease defaultSettings = obs_get_source_defaults(filterKind.c_str());
-	if (!defaultSettings)
-		return RequestResult::Error(RequestStatus::InvalidFilterKind);
-
-	json responseData;
-	responseData["defaultFilterSettings"] = Utils::Json::ObsDataToJson(defaultSettings, true);
-	return RequestResult::Success(responseData);
-}
-
-/**
- * Creates a new filter, adding it to the specified source.
- *
- * @requestField sourceName      | String | Name of the source to add the filter to
- * @requestField filterName      | String | Name of the new filter to be created
- * @requestField filterKind      | String | The kind of filter to be created
- * @requestField ?filterSettings | Object | Settings object to initialize the filter with | Default settings used
- *
- * @requestType CreateSourceFilter
- * @complexity 3
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category filters
- */
-RequestResult RequestHandler::CreateSourceFilter(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-
-	OBSSourceAutoRelease source = request.ValidateSource("sourceName", statusCode, comment);
-	if (!(source && request.ValidateString("filterName", statusCode, comment) && request.ValidateString("filterKind", statusCode, comment)))
-		return RequestResult::Error(statusCode, comment);
-
-	std::string filterName = request.RequestData["filterName"];
-	OBSSourceAutoRelease existingFilter = obs_source_get_filter_by_name(source, filterName.c_str());
-	if (existingFilter)
-		return RequestResult::Error(RequestStatus::ResourceAlreadyExists, "A filter already exists by that name.");
-
-	std::string filterKind = request.RequestData["filterKind"];
-	auto kinds = Utils::Obs::ArrayHelper::GetFilterKindList();
-	if (std::find(kinds.begin(), kinds.end(), filterKind) == kinds.end())
-		return RequestResult::Error(RequestStatus::InvalidFilterKind, "Your specified filter kind is not supported by OBS. Check that any necessary plugins are loaded.");
-
-	OBSDataAutoRelease filterSettings = nullptr;
-	if (request.Contains("filterSettings")) {
-		if (!request.ValidateOptionalObject("filterSettings", statusCode, comment, true))
-			return RequestResult::Error(statusCode, comment);
-
-		filterSettings = Utils::Json::JsonToObsData(request.RequestData["filterSettings"]);
-	}
-
-	OBSSourceAutoRelease filter = Utils::Obs::ActionHelper::CreateSourceFilter(source, filterName, filterKind, filterSettings);
-
-	if(!filter)
-		return RequestResult::Error(RequestStatus::ResourceCreationFailed, "Creation of the filter failed.");
-
-	return RequestResult::Success();
-}
-
-/**
- * Removes a filter from a source.
- *
- * @requestField sourceName | String | Name of the source the filter is on
- * @requestField filterName | String | Name of the filter to remove
- *
- * @requestType RemoveSourceFilter
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category filters
- */
-RequestResult RequestHandler::RemoveSourceFilter(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	FilterPair pair = request.ValidateFilter("sourceName", "filterName", statusCode, comment);
-	if (!pair.filter)
-		return RequestResult::Error(statusCode, comment);
-
-	obs_source_filter_remove(pair.source, pair.filter);
-
-	return RequestResult::Success();
-}
-
-/**
- * Sets the name of a source filter (rename).
- *
- * @requestField sourceName    | String | Name of the source the filter is on
- * @requestField filterName    | String | Current name of the filter
- * @requestField newFilterName | String | New name for the filter
- *
- * @requestType SetSourceFilterName
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category filters
- */
-RequestResult RequestHandler::SetSourceFilterName(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	FilterPair pair = request.ValidateFilter("sourceName", "filterName", statusCode, comment);
-	if (!pair.filter || !request.ValidateString("newFilterName", statusCode, comment))
-		return RequestResult::Error(statusCode, comment);
-
-	std::string newFilterName = request.RequestData["newFilterName"];
-
-	OBSSourceAutoRelease existingFilter = obs_source_get_filter_by_name(pair.source, newFilterName.c_str());
-	if (existingFilter)
-		return RequestResult::Error(RequestStatus::ResourceAlreadyExists, "A filter already exists by that new name.");
-
-	obs_source_set_name(pair.filter, newFilterName.c_str());
-
-	return RequestResult::Success();
-}
-
-/**
- * Gets the info for a specific source filter.
- *
- * @requestField sourceName | String | Name of the source
- * @requestField filterName | String | Name of the filter
- *
- * @responseField filterEnabled  | Boolean | Whether the filter is enabled
- * @responseField filterIndex    | Number  | Index of the filter in the list, beginning at 0
- * @responseField filterKind     | String  | The kind of filter
- * @responseField filterSettings | Object  | Settings object associated with the filter
- *
- * @requestType GetSourceFilter
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category filters
- */
-RequestResult RequestHandler::GetSourceFilter(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	FilterPair pair = request.ValidateFilter("sourceName", "filterName", statusCode, comment);
-	if (!pair.filter)
-		return RequestResult::Error(statusCode, comment);
-
-	json responseData;
-	responseData["filterEnabled"] = obs_source_enabled(pair.filter);
-	responseData["filterIndex"] = Utils::Obs::NumberHelper::GetSourceFilterIndex(pair.source, pair.filter); // Todo: Use `GetSourceFilterlist` to select this filter maybe
-	responseData["filterKind"] = obs_source_get_id(pair.filter);
-
-	OBSDataAutoRelease filterSettings = obs_source_get_settings(pair.filter);
-	responseData["filterSettings"] = Utils::Json::ObsDataToJson(filterSettings);
-
-	return RequestResult::Success(responseData);
-}
-
-/**
- * Sets the index position of a filter on a source.
- *
- * @requestField sourceName  | String | Name of the source the filter is on
- * @requestField filterName  | String | Name of the filter
- * @requestField filterIndex | Number | New index position of the filter | >= 0
- *
- * @requestType SetSourceFilterIndex
- * @complexity 3
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category filters
- */
-RequestResult RequestHandler::SetSourceFilterIndex(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	FilterPair pair = request.ValidateFilter("sourceName", "filterName", statusCode, comment);
-	if (!(pair.filter && request.ValidateNumber("filterIndex", statusCode, comment, 0, 8192)))
-		return RequestResult::Error(statusCode, comment);
-
-	int filterIndex = request.RequestData["filterIndex"];
-
-	Utils::Obs::ActionHelper::SetSourceFilterIndex(pair.source, pair.filter, filterIndex);
-
-	return RequestResult::Success();
-}
-
-/**
- * Sets the settings of a source filter.
- *
- * @requestField sourceName     | String  | Name of the source the filter is on
- * @requestField filterName     | String  | Name of the filter to set the settings of
- * @requestField filterSettings | Object  | Object of settings to apply
- * @requestField ?overlay       | Boolean | True == apply the settings on top of existing ones, False == reset the input to its defaults, then apply settings. | true
- *
- * @requestType SetSourceFilterSettings
- * @complexity 3
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category filters
- */
-RequestResult RequestHandler::SetSourceFilterSettings(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	FilterPair pair = request.ValidateFilter("sourceName", "filterName", statusCode, comment);
-	if (!(pair.filter && request.ValidateObject("filterSettings", statusCode, comment, true)))
-		return RequestResult::Error(statusCode, comment);
-
-	// Almost identical to SetInputSettings
-
-	bool overlay = true;
-	if (request.Contains("overlay")) {
-		if (!request.ValidateOptionalBoolean("overlay", statusCode, comment))
-			return RequestResult::Error(statusCode, comment);
-
-		overlay = request.RequestData["overlay"];
-	}
-
-	OBSDataAutoRelease newSettings = Utils::Json::JsonToObsData(request.RequestData["filterSettings"]);
-	if (!newSettings)
-		return RequestResult::Error(RequestStatus::RequestProcessingFailed, "An internal data conversion operation failed. Please report this!");
-
-	if (overlay)
-		obs_source_update(pair.filter, newSettings);
-	else
-		obs_source_reset_settings(pair.filter, newSettings);
-
-	obs_source_update_properties(pair.filter);
-
-	return RequestResult::Success();
-}
-
-/**
- * Sets the enable state of a source filter.
- *
- * @requestField sourceName    | String  | Name of the source the filter is on
- * @requestField filterName    | Number  | Name of the filter
- * @requestField filterEnabled | Boolean | New enable state of the filter
- *
- * @requestType SetSourceFilterEnabled
- * @complexity 3
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category filters
- */
-RequestResult RequestHandler::SetSourceFilterEnabled(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	FilterPair pair = request.ValidateFilter("sourceName", "filterName", statusCode, comment);
-	if (!(pair.filter && request.ValidateBoolean("filterEnabled", statusCode, comment)))
-		return RequestResult::Error(statusCode, comment);
-
-	bool filterEnabled = request.RequestData["filterEnabled"];
-
-	obs_source_set_enabled(pair.filter, filterEnabled);
-
-	return RequestResult::Success();
-}
--- a/src/requesthandler/RequestHandler_Inputs.cpp
+++ b/src/requesthandler/RequestHandler_Inputs.cpp
@ -83,43 +83,6 @@ RequestResult RequestHandler::GetInputKindList(const Request& request)
 	return RequestResult::Success(responseData);
 }

-/**
- * Gets the names of all special inputs.
- *
- * @responseField desktop1 | String | Name of the Desktop Audio input
- * @responseField desktop2 | String | Name of the Desktop Audio 2 input
- * @responseField mic1     | String | Name of the Mic/Auxiliary Audio input
- * @responseField mic2     | String | Name of the Mic/Auxiliary Audio 2 input
- * @responseField mic3     | String | Name of the Mic/Auxiliary Audio 3 input
- * @responseField mic4     | String | Name of the Mic/Auxiliary Audio 4 input
- *
- * @requestType GetSpecialInputs
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category inputs
- */
-RequestResult RequestHandler::GetSpecialInputs(const Request&)
-{
-	json responseData;
-
-	std::vector<std::string> channels = {"desktop1", "desktop2", "mic1", "mic2", "mic3", "mic4"};
-
-	size_t channelId = 1;
-	for (auto &channel : channels) {
-		OBSSourceAutoRelease input = obs_get_output_source(channelId);
-		if (!input)
-			responseData[channel] = nullptr;
-		else
-			responseData[channel] = obs_source_get_name(input);
-
-		channelId++;
-	}
-
-	return RequestResult::Success(responseData);
-}
-
 /**
 * Creates a new input, adding it as a scene item to the specified scene.
 *
@ -269,9 +232,6 @@ RequestResult RequestHandler::GetInputDefaultSettings(const Request& request)
 		return RequestResult::Error(statusCode, comment);

 	std::string inputKind = request.RequestData["inputKind"];
-	auto kinds = Utils::Obs::ArrayHelper::GetInputKindList();
-	if (std::find(kinds.begin(), kinds.end(), inputKind) == kinds.end())
-		return RequestResult::Error(RequestStatus::InvalidInputKind);

 	OBSDataAutoRelease defaultSettings = obs_get_source_defaults(inputKind.c_str());
 	if (!defaultSettings)
@ -386,9 +346,6 @@ RequestResult RequestHandler::GetInputMute(const Request& request)
 	if (!input)
 		return RequestResult::Error(statusCode, comment);

-	if (!(obs_source_get_output_flags(input) & OBS_SOURCE_AUDIO))
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "The specified input does not support audio.");
-
 	json responseData;
 	responseData["inputMuted"] = obs_source_muted(input);
 	return RequestResult::Success(responseData);
@ -415,9 +372,6 @@ RequestResult RequestHandler::SetInputMute(const Request& request)
 	if (!(input && request.ValidateBoolean("inputMuted", statusCode, comment)))
 		return RequestResult::Error(statusCode, comment);

-	if (!(obs_source_get_output_flags(input) & OBS_SOURCE_AUDIO))
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "The specified input does not support audio.");
-
 	obs_source_set_muted(input, request.RequestData["inputMuted"]);

 	return RequestResult::Success();
@ -445,9 +399,6 @@ RequestResult RequestHandler::ToggleInputMute(const Request& request)
 	if (!input)
 		return RequestResult::Error(statusCode, comment);

-	if (!(obs_source_get_output_flags(input) & OBS_SOURCE_AUDIO))
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "The specified input does not support audio.");
-
 	bool inputMuted = !obs_source_muted(input);
 	obs_source_set_muted(input, inputMuted);

@ -479,9 +430,6 @@ RequestResult RequestHandler::GetInputVolume(const Request& request)
 	if (!input)
 		return RequestResult::Error(statusCode, comment);

-	if (!(obs_source_get_output_flags(input) & OBS_SOURCE_AUDIO))
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "The specified input does not support audio.");
-
 	float inputVolumeMul = obs_source_get_volume(input);
 	float inputVolumeDb = obs_mul_to_db(inputVolumeMul);
 	if (inputVolumeDb == -INFINITY)
@ -498,7 +446,7 @@ RequestResult RequestHandler::GetInputVolume(const Request& request)
 *
 * @requestField inputName       | String | Name of the input to set the volume of
 * @requestField ?inputVolumeMul | Number | Volume setting in mul | >= 0, <= 20     | `inputVolumeDb` should be specified
- * @requestField ?inputVolumeDb  | Number | Volume setting in dB  | >= -100, <= 26 | `inputVolumeMul` should be specified
+ * @requestField ?inputVolumeDb  | Number | Volume setting in dB  | >= -100, <= -26 | `inputVolumeMul` should be specified
 *
 * @requestType SetInputVolume
 * @complexity 3
@ -515,9 +463,6 @@ RequestResult RequestHandler::SetInputVolume(const Request& request)
 	if (!input)
 		return RequestResult::Error(statusCode, comment);

-	if (!(obs_source_get_output_flags(input) & OBS_SOURCE_AUDIO))
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "The specified input does not support audio.");
-
 	bool hasMul = request.Contains("inputVolumeMul");
 	if (hasMul && !request.ValidateOptionalNumber("inputVolumeMul", statusCode, comment, 0, 20))
 		return RequestResult::Error(statusCode, comment);
@ -543,67 +488,6 @@ RequestResult RequestHandler::SetInputVolume(const Request& request)
 	return RequestResult::Success();
 }

-/**
- * Gets the audio balance of an input.
- *
- * @requestField inputName | String | Name of the input to get the audio balance of
- *
- * @responseField inputAudioBalance | Number | Audio balance value from 0.0-1.0
- *
- * @requestType GetInputAudioBalance
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category inputs
- */
-RequestResult RequestHandler::GetInputAudioBalance(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSSourceAutoRelease input = request.ValidateInput("inputName", statusCode, comment);
-	if (!input)
-		return RequestResult::Error(statusCode, comment);
-
-	if (!(obs_source_get_output_flags(input) & OBS_SOURCE_AUDIO))
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "The specified input does not support audio.");
-
-	json responseData;
-	responseData["inputAudioBalance"] = obs_source_get_balance_value(input);
-
-	return RequestResult::Success(responseData);
-}
-
-/**
- * Sets the audio balance of an input.
- *
- * @requestField inputName         | String | Name of the input to set the audio balance of
- * @requestField inputAudioBalance | Number | New audio balance value | >= 0.0, <= 1.0
- *
- * @requestType SetInputAudioBalance
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category inputs
- */
-RequestResult RequestHandler::SetInputAudioBalance(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSSourceAutoRelease input = request.ValidateInput("inputName", statusCode, comment);
-	if (!(input && request.ValidateNumber("inputAudioBalance", statusCode, comment, 0.0, 1.0)))
-		return RequestResult::Error(statusCode, comment);
-
-	if (!(obs_source_get_output_flags(input) & OBS_SOURCE_AUDIO))
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "The specified input does not support audio.");
-
-	float inputAudioBalance = request.RequestData["inputAudioBalance"];
-	obs_source_set_balance_value(input, inputAudioBalance);
-
-	return RequestResult::Success();
-}
-
 /**
 * Gets the audio sync offset of an input.
 *
@ -628,9 +512,6 @@ RequestResult RequestHandler::GetInputAudioSyncOffset(const Request& request)
 	if (!input)
 		return RequestResult::Error(statusCode, comment);

-	if (!(obs_source_get_output_flags(input) & OBS_SOURCE_AUDIO))
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "The specified input does not support audio.");
-
 	json responseData;
 	//									   Offset is stored in nanoseconds in OBS.
 	responseData["inputAudioSyncOffset"] = obs_source_get_sync_offset(input) / 1000000;
@ -659,9 +540,6 @@ RequestResult RequestHandler::SetInputAudioSyncOffset(const Request& request)
 	if (!(input && request.ValidateNumber("inputAudioSyncOffset", statusCode, comment, -950, 20000)))
 		return RequestResult::Error(statusCode, comment);

-	if (!(obs_source_get_output_flags(input) & OBS_SOURCE_AUDIO))
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "The specified input does not support audio.");
-
 	int64_t syncOffset = request.RequestData["inputAudioSyncOffset"];
 	obs_source_set_sync_offset(input, syncOffset * 1000000);

@ -695,9 +573,6 @@ RequestResult RequestHandler::GetInputAudioMonitorType(const Request& request)
 	if (!input)
 		return RequestResult::Error(statusCode, comment);

-	if (!(obs_source_get_output_flags(input) & OBS_SOURCE_AUDIO))
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "The specified input does not support audio.");
-
 	json responseData;
 	responseData["monitorType"] = Utils::Obs::StringHelper::GetInputMonitorType(input);

@ -725,12 +600,6 @@ RequestResult RequestHandler::SetInputAudioMonitorType(const Request& request)
 	if (!(input && request.ValidateString("monitorType", statusCode, comment)))
 		return RequestResult::Error(statusCode, comment);

-	if (!(obs_source_get_output_flags(input) & OBS_SOURCE_AUDIO))
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "The specified input does not support audio.");
-
-	if (!obs_audio_monitoring_available())
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "Audio monitoring is not available on this platform.");
-
 	enum obs_monitoring_type monitorType;
 	std::string monitorTypeString = request.RequestData["monitorType"];
 	if (monitorTypeString == "OBS_MONITORING_TYPE_NONE")
@ -747,95 +616,6 @@ RequestResult RequestHandler::SetInputAudioMonitorType(const Request& request)
 	return RequestResult::Success();
 }

-/**
- * Gets the enable state of all audio tracks of an input.
- *
- * @requestField inputName | String | Name of the input
- *
- * @responseField inputAudioTracks | Object | Object of audio tracks and associated enable states
- *
- * @requestType GetInputAudioTracks
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category inputs
- */
-RequestResult RequestHandler::GetInputAudioTracks(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSSourceAutoRelease input = request.ValidateInput("inputName", statusCode, comment);
-	if (!input)
-		return RequestResult::Error(statusCode, comment);
-
-	if (!(obs_source_get_output_flags(input) & OBS_SOURCE_AUDIO))
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "The specified input does not support audio.");
-
-	long long tracks = obs_source_get_audio_mixers(input);
-
-	json inputAudioTracks;
-	for (long long i = 0; i < MAX_AUDIO_MIXES; i++) {
-		inputAudioTracks[std::to_string(i + 1)] = (bool)((tracks >> i) & 1);
-	}
-
-	json responseData;
-	responseData["inputAudioTracks"] = inputAudioTracks;
-
-	return RequestResult::Success(responseData);
-}
-
-/**
- * Sets the enable state of audio tracks of an input.
- *
- * @requestField inputName        | String | Name of the input
- * @requestField inputAudioTracks | Object | Track settings to apply
- *
- * @requestType SetInputAudioTracks
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category inputs
- */
-RequestResult RequestHandler::SetInputAudioTracks(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSSourceAutoRelease input = request.ValidateInput("inputName", statusCode, comment);
-	if (!input || !request.ValidateObject("inputAudioTracks", statusCode, comment))
-		return RequestResult::Error(statusCode, comment);
-
-	if (!(obs_source_get_output_flags(input) & OBS_SOURCE_AUDIO))
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "The specified input does not support audio.");
-
-	json inputAudioTracks = request.RequestData["inputAudioTracks"];
-
-	long long mixers = obs_source_get_audio_mixers(input);
-
-	for (long long i = 0; i < MAX_AUDIO_MIXES; i++) {
-		std::string track = std::to_string(i + 1);
-
-		if (!Utils::Json::Contains(inputAudioTracks, track))
-			continue;
-
-		if (!inputAudioTracks[track].is_boolean())
-			return RequestResult::Error(RequestStatus::InvalidRequestFieldType, "The value of one of your tracks is not a boolean.");
-
-		bool enabled = inputAudioTracks[track];
-
-		if (enabled)
-			mixers |= (1 << i);
-		else
-			mixers &= ~(1 << i);
-	}
-
-	// Decided that checking if tracks have actually changed is unnecessary
-	obs_source_set_audio_mixers(input, mixers);
-
-	return RequestResult::Success();
-}
-
 /**
 * Gets the items of a list property from an input's properties.
 *
--- a/src/requesthandler/RequestHandler_Outputs.cpp
+++ b/src/requesthandler/RequestHandler_Outputs.cpp
@ -1,277 +0,0 @@
-/*
-obs-websocket
-Copyright (C) 2016-2021 Stephane Lepin <stephane.lepin@gmail.com>
-Copyright (C) 2020-2021 Kyle Manning <tt2468@gmail.com>
-
-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 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, see <https://www.gnu.org/licenses/>
-*/
-
-#include "RequestHandler.h"
-
-static bool VirtualCamAvailable()
-{
-	OBSDataAutoRelease privateData = obs_get_private_data();
-	if (!privateData)
-		return false;
-
-	return obs_data_get_bool(privateData, "vcamEnabled");
-}
-
-static bool ReplayBufferAvailable()
-{
-	OBSOutputAutoRelease output = obs_frontend_get_replay_buffer_output();
-	return output != nullptr;
-}
-
-/**
- * Gets the status of the virtualcam output.
- *
- * @responseField outputActive | Boolean | Whether the output is active
- *
- * @requestType GetVirtualCamStatus
- * @complexity 1
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @category outputs
- * @api requests
- */
-RequestResult RequestHandler::GetVirtualCamStatus(const Request&)
-{
-	if (!VirtualCamAvailable())
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "VirtualCam is not available.");
-
-	json responseData;
-	responseData["outputActive"] = obs_frontend_virtualcam_active();
-	return RequestResult::Success(responseData);
-}
-
-/**
- * Toggles the state of the virtualcam output.
- *
- * @responseField outputActive | Boolean | Whether the output is active
- *
- * @requestType ToggleVirtualCam
- * @complexity 1
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @category outputs
- * @api requests
- */
-RequestResult RequestHandler::ToggleVirtualCam(const Request&)
-{
-	if (!VirtualCamAvailable())
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "VirtualCam is not available.");
-
-	bool outputActive = obs_frontend_virtualcam_active();
-
-	if (outputActive)
-		obs_frontend_stop_virtualcam();
-	else
-		obs_frontend_start_virtualcam();
-
-	json responseData;
-	responseData["outputActive"] = !outputActive;
-	return RequestResult::Success(responseData);
-}
-
-/**
- * Starts the virtualcam output.
- *
- * @requestType StartVirtualCam
- * @complexity 1
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category outputs
- */
-RequestResult RequestHandler::StartVirtualCam(const Request&)
-{
-	if (!VirtualCamAvailable())
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "VirtualCam is not available.");
-
-	if (obs_frontend_virtualcam_active())
-		return RequestResult::Error(RequestStatus::OutputRunning);
-
-	obs_frontend_start_virtualcam();
-
-	return RequestResult::Success();
-}
-
-/**
- * Stops the virtualcam output.
- *
- * @requestType StopVirtualCam
- * @complexity 1
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category outputs
- */
-RequestResult RequestHandler::StopVirtualCam(const Request&)
-{
-	if (!VirtualCamAvailable())
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "VirtualCam is not available.");
-
-	if (!obs_frontend_virtualcam_active())
-		return RequestResult::Error(RequestStatus::OutputNotRunning);
-
-	obs_frontend_stop_virtualcam();
-
-	return RequestResult::Success();
-}
-
-/**
- * Gets the status of the replay buffer output.
- *
- * @responseField outputActive | Boolean | Whether the output is active
- *
- * @requestType GetReplayBufferStatus
- * @complexity 1
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @category outputs
- * @api requests
- */
-RequestResult RequestHandler::GetReplayBufferStatus(const Request&)
-{
-	if (!ReplayBufferAvailable())
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "Replay buffer is not available.");
-
-	json responseData;
-	responseData["outputActive"] = obs_frontend_replay_buffer_active();
-	return RequestResult::Success(responseData);
-}
-
-/**
- * Toggles the state of the replay buffer output.
- *
- * @responseField outputActive | Boolean | Whether the output is active
- *
- * @requestType ToggleReplayBuffer
- * @complexity 1
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @category outputs
- * @api requests
- */
-RequestResult RequestHandler::ToggleReplayBuffer(const Request&)
-{
-	if (!ReplayBufferAvailable())
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "Replay buffer is not available.");
-
-	bool outputActive = obs_frontend_replay_buffer_active();
-
-	if (outputActive)
-		obs_frontend_replay_buffer_stop();
-	else
-		obs_frontend_replay_buffer_start();
-
-	json responseData;
-	responseData["outputActive"] = !outputActive;
-	return RequestResult::Success(responseData);
-}
-
-/**
- * Starts the replay buffer output.
- *
- * @requestType StartReplayBuffer
- * @complexity 1
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category outputs
- */
-RequestResult RequestHandler::StartReplayBuffer(const Request&)
-{
-	if (!ReplayBufferAvailable())
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "Replay buffer is not available.");
-
-	if (obs_frontend_replay_buffer_active())
-		return RequestResult::Error(RequestStatus::OutputRunning);
-
-	obs_frontend_replay_buffer_start();
-
-	return RequestResult::Success();
-}
-
-/**
- * Stops the replay buffer output.
- *
- * @requestType StopReplayBuffer
- * @complexity 1
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category outputs
- */
-RequestResult RequestHandler::StopReplayBuffer(const Request&)
-{
-	if (!ReplayBufferAvailable())
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "Replay buffer is not available.");
-
-	if (!obs_frontend_replay_buffer_active())
-		return RequestResult::Error(RequestStatus::OutputNotRunning);
-
-	obs_frontend_replay_buffer_stop();
-
-	return RequestResult::Success();
-}
-
-/**
- * Saves the contents of the replay buffer output.
- *
- * @requestType SaveReplayBuffer
- * @complexity 1
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category outputs
- */
-RequestResult RequestHandler::SaveReplayBuffer(const Request&)
-{
-	if (!ReplayBufferAvailable())
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "Replay buffer is not available.");
-
-	if (!obs_frontend_replay_buffer_active())
-		return RequestResult::Error(RequestStatus::OutputNotRunning);
-
-	obs_frontend_replay_buffer_save();
-
-	return RequestResult::Success();
-}
-
-/**
- * Gets the filename of the last replay buffer save file.
- *
- * @responseField savedReplayPath | String | File path
- *
- * @requestType GetLastReplayBufferReplay
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category outputs
- */
-RequestResult RequestHandler::GetLastReplayBufferReplay(const Request&)
-{
-	if (!ReplayBufferAvailable())
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "Replay buffer is not available.");
-
-	if (!obs_frontend_replay_buffer_active())
-		return RequestResult::Error(RequestStatus::OutputNotRunning);
-
-	json responseData;
-	responseData["savedReplayPath"] = Utils::Obs::StringHelper::GetLastReplayBufferFilePath();
-	return RequestResult::Success(responseData);
-}
--- a/src/requesthandler/RequestHandler_Record.cpp
+++ b/src/requesthandler/RequestHandler_Record.cpp
@ -182,3 +182,23 @@ RequestResult RequestHandler::ResumeRecord(const Request&)

 	return RequestResult::Success();
 }
+
+/**
+ * Gets the current directory that the record output is set to.
+ *
+ * @responseField recordDirectory | String | Output directory
+ *
+ * @requestType GetRecordDirectory
+ * @complexity 1
+ * @rpcVersion -1
+ * @initialVersion 5.0.0
+ * @api requests
+ * @category record
+ */
+RequestResult RequestHandler::GetRecordDirectory(const Request&)
+{
+	json responseData;
+	responseData["recordDirectory"] = Utils::Obs::StringHelper::GetCurrentRecordOutputPath();
+
+	return RequestResult::Success(responseData);
+}
--- a/src/requesthandler/RequestHandler_SceneItems.cpp
+++ b/src/requesthandler/RequestHandler_SceneItems.cpp
@ -232,9 +232,8 @@ RequestResult RequestHandler::DuplicateSceneItem(const Request& request)
 		if (!destinationScene)
 			return RequestResult::Error(statusCode, comment);
 	} else {
-		destinationScene = obs_scene_get_ref(obs_sceneitem_get_scene(sceneItem));
-		if (!destinationScene)
-			return RequestResult::Error(RequestStatus::RequestProcessingFailed, "Internal error: Failed to get ref for scene of scene item.");
+		destinationScene = obs_sceneitem_get_scene(sceneItem);
+		obs_scene_addref(destinationScene);
 	}

 	if (obs_sceneitem_is_group(sceneItem) && obs_sceneitem_get_scene(sceneItem) == destinationScene) {
@ -632,81 +631,3 @@ RequestResult RequestHandler::SetSceneItemIndex(const Request& request)

 	return RequestResult::Success();
 }
-
-/**
- * Gets the blend mode of a scene item.
- *
- * Blend modes:
- *
- * - `OBS_BLEND_NORMAL`
- * - `OBS_BLEND_ADDITIVE`
- * - `OBS_BLEND_SUBTRACT`
- * - `OBS_BLEND_SCREEN`
- * - `OBS_BLEND_MULTIPLY`
- * - `OBS_BLEND_LIGHTEN`
- * - `OBS_BLEND_DARKEN`
- *
- * Scenes and Groups
- *
- * @requestField sceneName   | String | Name of the scene the item is in
- * @requestField sceneItemId | Number | Numeric ID of the scene item | >= 0
- *
- * @responseField sceneItemBlendMode | String | Current blend mode
- *
- * @requestType GetSceneItemBlendMode
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category scene items
- */
-RequestResult RequestHandler::GetSceneItemBlendMode(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSSceneItemAutoRelease sceneItem = request.ValidateSceneItem("sceneName", "sceneItemId", statusCode, comment, OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP);
-	if (!sceneItem)
-		return RequestResult::Error(statusCode, comment);
-
-	auto blendMode = obs_sceneitem_get_blending_mode(sceneItem);
-
-	json responseData;
-	responseData["sceneItemBlendMode"] = Utils::Obs::StringHelper::GetSceneItemBlendMode(blendMode);
-
-	return RequestResult::Success(responseData);
-}
-
-/**
- * Sets the blend mode of a scene item.
- *
- * Scenes and Groups
- *
- * @requestField sceneName          | String | Name of the scene the item is in
- * @requestField sceneItemId        | Number | Numeric ID of the scene item | >= 0
- * @requestField sceneItemBlendMode | String | New blend mode
- *
- * @requestType SetSceneItemBlendMode
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category scene items
- */
-RequestResult RequestHandler::SetSceneItemBlendMode(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSSceneItemAutoRelease sceneItem = request.ValidateSceneItem("sceneName", "sceneItemId", statusCode, comment, OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP);
-	if (!(sceneItem && request.ValidateString("sceneItemBlendMode", statusCode, comment)))
-		return RequestResult::Error(statusCode, comment);
-
-	std::string blendModeString = request.RequestData["sceneItemBlendMode"];
-
-	auto blendMode = Utils::Obs::EnumHelper::GetSceneItemBlendMode(blendModeString);
-	if (blendMode == OBS_BLEND_NORMAL && blendModeString != "OBS_BLEND_NORMAL")
-		return RequestResult::Error(RequestStatus::InvalidRequestField, "The field sceneItemBlendMode has an invalid value.");
-
-	obs_sceneitem_set_blending_mode(sceneItem, blendMode);
-
-	return RequestResult::Success();
-}
--- a/src/requesthandler/RequestHandler_Scenes.cpp
+++ b/src/requesthandler/RequestHandler_Scenes.cpp
@ -24,7 +24,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 *
 * @responseField currentProgramSceneName | String        | Current program scene
 * @responseField currentPreviewSceneName | String        | Current preview scene. `null` if not in studio mode
- * @responseField scenes                  | Array<Object> | Array of scenes
+ * @responseField scenes                  | Array<Object> | Array of scenes in OBS
 *
 * @requestType GetSceneList
 * @complexity 2
@ -54,29 +54,6 @@ RequestResult RequestHandler::GetSceneList(const Request&)
 	return RequestResult::Success(responseData);
 }

-/**
- * Gets an array of all groups in OBS.
- *
- * Groups in OBS are actually scenes, but renamed and modified. In obs-websocket, we treat them as scenes where we can.
- *
- * @responseField groups | Array<String> | Array of group names
- *
- * @requestType GetGroupList
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category scenes
- */
-RequestResult RequestHandler::GetGroupList(const Request&)
-{
-	json responseData;
-
-	responseData["groups"] = Utils::Obs::ArrayHelper::GetGroupList();
-
-	return RequestResult::Success(responseData);
-}
-
 /**
 * Gets the current program scene.
 *
@ -273,105 +250,3 @@ RequestResult RequestHandler::SetSceneName(const Request& request)

 	return RequestResult::Success();
 }
-
-/**
- * Gets the scene transition overridden for a scene.
- *
- * @requestField sceneName | String | Name of the scene
- *
- * @responseField transitionName     | String | Name of the overridden scene transition, else `null`
- * @responseField transitionDuration | Number | Duration of the overridden scene transition, else `null`
- *
- * @requestType GetSceneSceneTransitionOverride
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category scenes
- */
-RequestResult RequestHandler::GetSceneSceneTransitionOverride(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSSourceAutoRelease scene = request.ValidateScene("sceneName", statusCode, comment);
-	if (!scene)
-		return RequestResult::Error(statusCode, comment);
-
-	OBSDataAutoRelease privateSettings = obs_source_get_private_settings(scene);
-
-	json responseData;
-	const char *transitionName = obs_data_get_string(privateSettings, "transition");
-	if (transitionName && strlen(transitionName))
-		responseData["transitionName"] = transitionName;
-	else
-		responseData["transitionName"] = nullptr;
-
-	if (obs_data_has_user_value(privateSettings, "transition_duration"))
-		responseData["transitionDuration"] = obs_data_get_int(privateSettings, "transition_duration");
-	else
-		responseData["transitionDuration"] = nullptr;
-
-	return RequestResult::Success(responseData);
-}
-
-/**
- * Gets the scene transition overridden for a scene.
- *
- * @requestField sceneName           | String | Name of the scene
- * @requestField ?transitionName     | String | Name of the scene transition to use as override. Specify `null` to remove | Unchanged
- * @requestField ?transitionDuration | Number | Duration to use for any overridden transition. Specify `null` to remove | >= 50, <= 20000 | Unchanged
- *
- * @requestType SetSceneSceneTransitionOverride
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category scenes
- */
-RequestResult RequestHandler::SetSceneSceneTransitionOverride(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSSourceAutoRelease scene = request.ValidateScene("sceneName", statusCode, comment);
-	if (!scene)
-		return RequestResult::Error(statusCode, comment);
-
-	OBSDataAutoRelease privateSettings = obs_source_get_private_settings(scene);
-
-	bool hasName = request.RequestData.contains("transitionName");
-	if (hasName && !request.RequestData["transitionName"].is_null()) {
-		if (!request.ValidateOptionalString("transitionName", statusCode, comment))
-			return RequestResult::Error(statusCode, comment);
-		OBSSourceAutoRelease transition = Utils::Obs::SearchHelper::GetSceneTransitionByName(request.RequestData["transitionName"]);
-		if (!transition)
-			return RequestResult::Error(RequestStatus::ResourceNotFound, "No scene transition was found by that name.");
-	}
-
-	bool hasDuration = request.RequestData.contains("transitionDuration");
-	if (hasDuration && !request.RequestData["transitionDuration"].is_null()) {
-		if (!request.ValidateOptionalNumber("transitionDuration", statusCode, comment, 50, 20000))
-			return RequestResult::Error(statusCode, comment);
-	}
-
-	if (!hasName && !hasDuration)
-		return RequestResult::Error(RequestStatus::MissingRequestField, "Your request data must include either `transitionName` or `transitionDuration`.");
-
-	if (hasName) {
-		if (request.RequestData["transitionName"].is_null()) {
-			obs_data_erase(privateSettings, "transition");
-		} else {
-			std::string transitionName = request.RequestData["transitionName"];
-			obs_data_set_string(privateSettings, "transition", transitionName.c_str());
-		}
-	}
-
-	if (hasDuration) {
-		if (request.RequestData["transitionDuration"].is_null()) {
-			obs_data_erase(privateSettings, "transition_duration");
-		} else {
-			obs_data_set_int(privateSettings, "transition_duration", request.RequestData["transitionDuration"]);
-		}
-	}
-
-	return RequestResult::Success();
-}
--- a/src/requesthandler/RequestHandler_Sources.cpp
+++ b/src/requesthandler/RequestHandler_Sources.cpp
@ -312,39 +312,3 @@ RequestResult RequestHandler::SaveSourceScreenshot(const Request& request)

 	return RequestResult::Success();
 }
-
-// Intentionally undocumented
-RequestResult RequestHandler::GetSourcePrivateSettings(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSSourceAutoRelease source = request.ValidateSource("sourceName", statusCode, comment);
-	if (!source)
-		return RequestResult::Error(statusCode, comment);
-
-	OBSDataAutoRelease privateSettings = obs_source_get_private_settings(source);
-
-	json responseData;
-	responseData["sourceSettings"] = Utils::Json::ObsDataToJson(privateSettings);
-
-	return RequestResult::Success(responseData);
-}
-
-// Intentionally undocumented
-RequestResult RequestHandler::SetSourcePrivateSettings(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSSourceAutoRelease source = request.ValidateSource("sourceName", statusCode, comment);
-	if (!source || !request.ValidateObject("sourceSettings", statusCode, comment))
-		return RequestResult::Error(statusCode, comment);
-
-	OBSDataAutoRelease privateSettings = obs_source_get_private_settings(source);
-
-	OBSDataAutoRelease newSettings = Utils::Json::JsonToObsData(request.RequestData["sourceSettings"]);
-
-	// Always overlays to prevent destroying internal source data unintentionally
-	obs_data_apply(privateSettings, newSettings);
-
-	return RequestResult::Success();
-}
--- a/src/requesthandler/RequestHandler_Stream.cpp
+++ b/src/requesthandler/RequestHandler_Stream.cpp
@ -122,35 +122,3 @@ RequestResult RequestHandler::StopStream(const Request&)

 	return RequestResult::Success();
 }
-
-/**
- * Sends CEA-608 caption text over the stream output.
- *
- * @requestField captionText | String | Caption text
- *
- * @requestType SendStreamCaption
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @category stream
- * @api requests
- */
-RequestResult RequestHandler::SendStreamCaption(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	if (!request.ValidateString("captionText", statusCode, comment, true))
-		return RequestResult::Error(statusCode, comment);
-
-	if (!obs_frontend_streaming_active())
-		return RequestResult::Error(RequestStatus::OutputNotRunning);
-
-	std::string captionText = request.RequestData["captionText"];
-
-	OBSOutputAutoRelease output = obs_frontend_get_streaming_output();
-
-	// 0.0 means no delay until the next caption can be sent
-	obs_output_output_caption_text2(output, captionText.c_str(), 0.0);
-
-	return RequestResult::Success();
-}
--- a/src/requesthandler/RequestHandler_Transitions.cpp
+++ b/src/requesthandler/RequestHandler_Transitions.cpp
@ -17,8 +17,6 @@ You should have received a copy of the GNU General Public License along
 with this program. If not, see <https://www.gnu.org/licenses/>
 */

-#include <math.h>
-
 #include "RequestHandler.h"

 /**
@ -228,32 +226,6 @@ RequestResult RequestHandler::SetCurrentSceneTransitionSettings(const Request& r
 	return RequestResult::Success();
 }

-/**
- * Gets the cursor position of the current scene transition.
- *
- * Note: `transitionCursor` will return 1.0 when the transition is inactive.
- *
- * @responseField transitionCursor | Number | Cursor position, between 0.0 and 1.0
- *
- * @requestType GetCurrentSceneTransitionCursor
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category transitions
- */
-RequestResult RequestHandler::GetCurrentSceneTransitionCursor(const Request&)
-{
-	OBSSourceAutoRelease transition = obs_frontend_get_current_transition();
-	if (!transition)
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "OBS does not currently have a scene transition set."); // This should not happen!
-
-	json responseData;
-	responseData["transitionCursor"] = obs_transition_get_time(transition);
-
-	return RequestResult::Success(responseData);
-}
-
 /**
 * Triggers the current scene transition. Same functionality as the `Transition` button in studio mode.
 *
@ -275,48 +247,3 @@ RequestResult RequestHandler::TriggerStudioModeTransition(const Request&)

 	return RequestResult::Success();
 }
-
-/**
- * Sets the position of the TBar.
- *
- * **Very important note**: This will be deprecated and replaced in a future version of obs-websocket.
- *
- * @requestField position | Number  | New position | >= 0.0, <= 1.0
- * @requestField ?release | Boolean | Whether to release the TBar. Only set `false` if you know that you will be sending another position update | `true`
- *
- * @requestType SetTBarPosition
- * @complexity 3
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category transitions
- */
-RequestResult RequestHandler::SetTBarPosition(const Request& request)
-{
-	if (!obs_frontend_preview_program_mode_active())
-		return RequestResult::Error(RequestStatus::StudioModeNotActive);
-
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	if (!request.ValidateNumber("position", statusCode, comment, 0.0, 1.0))
-		return RequestResult::Error(statusCode, comment);
-
-	bool release = true;
-	if (request.Contains("release")) {
-		if (!request.ValidateOptionalBoolean("release", statusCode, comment))
-			return RequestResult::Error(statusCode, comment);
-	}
-
-	OBSSourceAutoRelease transition = obs_frontend_get_current_transition();
-	if (!transition)
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "OBS does not currently have a scene transition set."); // This should not happen!
-
-	float position = request.RequestData["position"];
-
-	obs_frontend_set_tbar_position((int)round(position * 1024.0));
-
-	if (release)
-		obs_frontend_release_tbar();
-
-	return RequestResult::Success();
-}
--- a/src/requesthandler/RequestHandler_Ui.cpp
+++ b/src/requesthandler/RequestHandler_Ui.cpp
@ -70,81 +70,3 @@ RequestResult RequestHandler::SetStudioModeEnabled(const Request& request)

 	return RequestResult::Success();
 }
-
-/**
- * Opens the properties dialog of an input.
- *
- * @requestField inputName | String | Name of the input to open the dialog of
- *
- * @requestType OpenInputPropertiesDialog
- * @complexity 1
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @category ui
- * @api requests
- */
-RequestResult RequestHandler::OpenInputPropertiesDialog(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSSourceAutoRelease input = request.ValidateInput("inputName", statusCode, comment);
-	if (!input)
-		return RequestResult::Error(statusCode, comment);
-
-	obs_frontend_open_source_properties(input);
-
-	return RequestResult::Success();
-}
-
-/**
- * Opens the filters dialog of an input.
- *
- * @requestField inputName | String | Name of the input to open the dialog of
- *
- * @requestType OpenInputFiltersDialog
- * @complexity 1
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @category ui
- * @api requests
- */
-RequestResult RequestHandler::OpenInputFiltersDialog(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSSourceAutoRelease input = request.ValidateInput("inputName", statusCode, comment);
-	if (!input)
-		return RequestResult::Error(statusCode, comment);
-
-	obs_frontend_open_source_filters(input);
-
-	return RequestResult::Success();
-}
-
-/**
- * Opens the interact dialog of an input.
- *
- * @requestField inputName | String | Name of the input to open the dialog of
- *
- * @requestType OpenInputInteractDialog
- * @complexity 1
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @category ui
- * @api requests
- */
-RequestResult RequestHandler::OpenInputInteractDialog(const Request& request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSSourceAutoRelease input = request.ValidateInput("inputName", statusCode, comment);
-	if (!input)
-		return RequestResult::Error(statusCode, comment);
-
-	if (!(obs_source_get_output_flags(input) & OBS_SOURCE_INTERACTION))
-		return RequestResult::Error(RequestStatus::InvalidResourceState, "The specified input does not support interaction.");
-
-	obs_frontend_open_source_interaction(input);
-
-	return RequestResult::Success();
-}
--- a/src/requesthandler/rpc/Request.cpp
+++ b/src/requesthandler/rpc/Request.cpp
@ -264,14 +264,18 @@ obs_scene_t *Request::ValidateScene2(const std::string &keyName, RequestStatus::
 			comment = "The specified source is not a scene. (Is group)";
 			return nullptr;
 		}
-		return obs_scene_get_ref(obs_group_from_source(sceneSource));
+		OBSScene ret = obs_group_from_source(sceneSource);
+		obs_scene_addref(ret);
+		return ret;
 	} else {
 		if (filter == OBS_WEBSOCKET_SCENE_FILTER_GROUP_ONLY) {
 			statusCode = RequestStatus::InvalidResourceType;
 			comment = "The specified source is not a group. (Is scene)";
 			return nullptr;
 		}
-		return obs_scene_get_ref(obs_scene_from_source(sceneSource));
+		OBSScene ret = obs_scene_from_source(sceneSource);
+		obs_scene_addref(ret);
+		return ret;
 	}
 }

@ -291,27 +295,6 @@ obs_source_t *Request::ValidateInput(const std::string &keyName, RequestStatus::
 	return ret;
 }

-FilterPair Request::ValidateFilter(const std::string &sourceKeyName, const std::string &filterKeyName, RequestStatus::RequestStatus &statusCode, std::string &comment) const
-{
-	obs_source_t *source = ValidateSource(sourceKeyName, statusCode, comment);
-	if (!source)
-		return FilterPair{source, nullptr};
-
-	if (!ValidateString(filterKeyName, statusCode, comment))
-		return FilterPair{source, nullptr};
-
-	std::string filterName = RequestData[filterKeyName];
-
-	obs_source_t *filter = obs_source_get_filter_by_name(source, filterName.c_str());
-	if (!filter) {
-		statusCode = RequestStatus::ResourceNotFound;
-		comment = std::string("No filter was found in the source `") + RequestData[sourceKeyName].get<std::string>() + "` with the name `" + filterName + "`.";
-		return FilterPair{source, nullptr};
-	}
-
-	return FilterPair{source, filter};
-}
-
 obs_sceneitem_t *Request::ValidateSceneItem(const std::string &sceneKeyName, const std::string &sceneItemIdKeyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const ObsWebSocketSceneFilter filter) const
 {
 	OBSSceneAutoRelease scene = ValidateScene2(sceneKeyName, statusCode, comment, filter);
--- a/src/requesthandler/rpc/Request.h
+++ b/src/requesthandler/rpc/Request.h
@ -29,12 +29,6 @@ enum ObsWebSocketSceneFilter {
 	OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP,
 };

-// We return filters as a pair because `obs_filter_get_parent()` is apparently volatile
-struct FilterPair {
-	OBSSourceAutoRelease source;
-	OBSSourceAutoRelease filter;
-};
-
 struct Request
 {
 	Request(const std::string &requestType, const json &requestData = nullptr, const RequestBatchExecutionType::RequestBatchExecutionType executionType = RequestBatchExecutionType::None);
@ -59,7 +53,6 @@ struct Request
 	obs_source_t *ValidateScene(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const ObsWebSocketSceneFilter filter = OBS_WEBSOCKET_SCENE_FILTER_SCENE_ONLY) const;
 	obs_scene_t *ValidateScene2(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const ObsWebSocketSceneFilter filter = OBS_WEBSOCKET_SCENE_FILTER_SCENE_ONLY) const;
 	obs_source_t *ValidateInput(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment) const;
-	FilterPair ValidateFilter(const std::string &sourceKeyName, const std::string &filterKeyName, RequestStatus::RequestStatus &statusCode, std::string &comment) const;
 	obs_sceneitem_t *ValidateSceneItem(const std::string &sceneKeyName, const std::string &sceneItemIdKeyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const ObsWebSocketSceneFilter filter = OBS_WEBSOCKET_SCENE_FILTER_SCENE_ONLY) const;

 	std::string RequestType;
--- a/src/requesthandler/types/RequestBatchExecutionType.h
+++ b/src/requesthandler/types/RequestBatchExecutionType.h
@ -22,7 +22,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #include <stdint.h>

 namespace RequestBatchExecutionType {
-	enum RequestBatchExecutionType: int8_t {
+	enum RequestBatchExecutionType {
 		/**
 		* Not a request batch.
 		*
@ -77,7 +77,7 @@ namespace RequestBatchExecutionType {
 		Parallel = 2,
 	};

-	inline bool IsValid(int8_t executionType)
+	inline bool IsValid(int executionType)
 	{
 		return executionType >= None && executionType <= Parallel;
 	}
--- a/src/requesthandler/types/RequestStatus.h
+++ b/src/requesthandler/types/RequestStatus.h
@ -345,17 +345,6 @@ namespace RequestStatus {
 		* @api enums
 		*/
 		ResourceNotConfigurable = 606,
-		/**
-		* The specified filter (obs_source_t-OBS_SOURCE_TYPE_FILTER) had the wrong kind.
-		*
-		* @enumIdentifier InvalidFilterKind
-		* @enumValue 607
-		* @enumType RequestStatus
-		* @rpcVersion -1
-		* @initialVersion 5.0.0
-		* @api enums
-		*/
-		InvalidFilterKind = 607,

 		/**
 		* Creating the resource failed.
--- a/src/utils/Json.cpp
+++ b/src/utils/Json.cpp
@ -21,7 +21,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #include "Platform.h"
 #include "../plugin-macros.generated.h"

-bool Utils::Json::JsonArrayIsValidObsArray(const json &j)
+bool Utils::Json::JsonArrayIsValidObsArray(json j)
 {
 	for (auto it : j) {
 		if (!it.is_object())
@ -191,7 +191,7 @@ bool Utils::Json::GetJsonFileContent(std::string fileName, json &content)
 	return true;
 }

-bool Utils::Json::SetJsonFileContent(std::string fileName, const json &content, bool createNew)
+bool Utils::Json::SetJsonFileContent(std::string fileName, json content, bool createNew)
 {
 	std::string textContent = content.dump(2);
 	return Utils::Platform::SetTextFileContent(fileName, textContent, createNew);
--- a/src/utils/Json.h
+++ b/src/utils/Json.h
@ -27,11 +27,10 @@ using json = nlohmann::json;

 namespace Utils {
 	namespace Json {
-		bool JsonArrayIsValidObsArray(const json &j);
+		bool JsonArrayIsValidObsArray(json j);
 		obs_data_t *JsonToObsData(json j);
 		json ObsDataToJson(obs_data_t *d, bool includeDefault = false);
 		bool GetJsonFileContent(std::string fileName, json &content);
-		bool SetJsonFileContent(std::string fileName, const json &content, bool createNew = true);
-		static inline bool Contains(const json &j, std::string key) { return j.contains(key) && !j[key].is_null(); }
+		bool SetJsonFileContent(std::string fileName, json content, bool createNew = true);
 	}
 }
--- a/src/utils/Obs.h
+++ b/src/utils/Obs.h
@ -62,7 +62,7 @@ using OBSWeakServiceAutoRelease = OBSRef<obs_weak_service_t *, ___weak_service_d
 template <typename T> T* GetCalldataPointer(const calldata_t *data, const char* name) {
 	void *ptr = nullptr;
 	calldata_get_ptr(data, name, &ptr);
-	return static_cast<T*>(ptr);
+	return reinterpret_cast<T*>(ptr);
 }

 enum ObsOutputState {
@ -163,7 +163,6 @@ namespace Utils {
 			std::string GetMediaInputState(obs_source_t *input);
 			std::string GetLastReplayBufferFilePath();
 			std::string GetSceneItemBoundsType(enum obs_bounds_type type);
-			std::string GetSceneItemBlendMode(enum obs_blending_type mode);
 			std::string DurationToTimecode(uint64_t);
 			std::string GetOutputState(ObsOutputState state);
 		}
@ -171,13 +170,11 @@ namespace Utils {
 		namespace EnumHelper {
 			enum obs_bounds_type GetSceneItemBoundsType(std::string boundsType);
 			enum ObsMediaInputAction GetMediaInputAction(std::string mediaAction);
-			enum obs_blending_type GetSceneItemBlendMode(std::string mode);
 		}

 		namespace NumberHelper {
 			uint64_t GetOutputDuration(obs_output_t *output);
 			size_t GetSceneCount();
-			size_t GetSourceFilterIndex(obs_source_t *source, obs_source_t *filter);
 		}

 		namespace ArrayHelper {
@ -186,15 +183,12 @@ namespace Utils {
 			std::vector<obs_hotkey_t *> GetHotkeyList();
 			std::vector<std::string> GetHotkeyNameList();
 			std::vector<json> GetSceneList();
-			std::vector<std::string> GetGroupList();
 			std::vector<json> GetSceneItemList(obs_scene_t *scene, bool basic = false);
 			std::vector<json> GetInputList(std::string inputKind = "");
 			std::vector<std::string> GetInputKindList(bool unversioned = false, bool includeDisabled = false);
 			std::vector<json> GetListPropertyItems(obs_property_t *property);
 			std::vector<std::string> GetTransitionKindList();
 			std::vector<json> GetSceneTransitionList();
-			std::vector<json> GetSourceFilterList(obs_source_t *source);
-			std::vector<std::string> GetFilterKindList();
 		}

 		namespace ObjectHelper {
@ -211,8 +205,6 @@ namespace Utils {
 		namespace ActionHelper {
 			obs_sceneitem_t *CreateSceneItem(obs_source_t *source, obs_scene_t *scene, bool sceneItemEnabled = true, obs_transform_info *sceneItemTransform = nullptr, obs_sceneitem_crop *sceneItemCrop = nullptr); // Increments ref. Use OBSSceneItemAutoRelease
 			obs_sceneitem_t *CreateInput(std::string inputName, std::string inputKind, obs_data_t *inputSettings, obs_scene_t *scene, bool sceneItemEnabled = true); // Increments ref. Use OBSSceneItemAutoRelease
-			obs_source_t *CreateSourceFilter(obs_source_t *source, std::string filterName, std::string filterKind, obs_data_t *filterSettings); // Increments source ref. Use OBSSourceAutoRelease
-			void SetSourceFilterIndex(obs_source_t *source, obs_source_t *filter, size_t index);
 		}
 	}
 }
--- a/src/utils/Obs_ActionHelper.cpp
+++ b/src/utils/Obs_ActionHelper.cpp
@ -29,7 +29,7 @@ struct CreateSceneItemData {

 void CreateSceneItemHelper(void *_data, obs_scene_t *scene)
 {
-	auto *data = static_cast<CreateSceneItemData*>(_data);
+	auto *data = reinterpret_cast<CreateSceneItemData*>(_data);
 	data->sceneItem = obs_scene_add(scene, data->source);

 	if (data->sceneItemTransform)
@ -87,30 +87,3 @@ obs_sceneitem_t *Utils::Obs::ActionHelper::CreateInput(std::string inputName, st

 	return ret;
 }
-
-obs_source_t *Utils::Obs::ActionHelper::CreateSourceFilter(obs_source_t *source, std::string filterName, std::string filterKind, obs_data_t *filterSettings)
-{
-	obs_source_t *filter = obs_source_create_private(filterKind.c_str(), filterName.c_str(), filterSettings);
-
-	if (!filter)
-		return nullptr;
-
-	obs_source_filter_add(source, filter);
-
-	return filter;
-}
-
-void Utils::Obs::ActionHelper::SetSourceFilterIndex(obs_source_t *source, obs_source_t *filter, size_t index)
-{
-	size_t currentIndex = Utils::Obs::NumberHelper::GetSourceFilterIndex(source, filter);
-	obs_order_movement direction = index > currentIndex ? OBS_ORDER_MOVE_DOWN : OBS_ORDER_MOVE_UP;
-
-	while(currentIndex != index) {
-		obs_source_filter_set_order(source, filter, direction);
-
-		if (direction == OBS_ORDER_MOVE_DOWN)
-			currentIndex++;
-		else
-			currentIndex--;
-	}
-}
--- a/src/utils/Obs_ArrayHelper.cpp
+++ b/src/utils/Obs_ArrayHelper.cpp
@ -61,7 +61,7 @@ std::vector<obs_hotkey_t *> Utils::Obs::ArrayHelper::GetHotkeyList()
 	std::vector<obs_hotkey_t *> ret;

 	obs_enum_hotkeys([](void* data, obs_hotkey_id, obs_hotkey_t* hotkey) {
-		auto ret = static_cast<std::vector<obs_hotkey_t *> *>(data);
+		auto ret = reinterpret_cast<std::vector<obs_hotkey_t *> *>(data);

 		ret->push_back(hotkey);

@ -88,10 +88,12 @@ std::vector<json> Utils::Obs::ArrayHelper::GetSceneList()
 	obs_frontend_get_scenes(&sceneList);

 	std::vector<json> ret;
-	ret.reserve(sceneList.sources.num);
 	for (size_t i = 0; i < sceneList.sources.num; i++) {
 		obs_source_t *scene = sceneList.sources.array[i];

+		if (obs_source_is_group(scene))
+			continue;
+
 		json sceneJson;
 		sceneJson["sceneName"] = obs_source_get_name(scene);
 		sceneJson["sceneIndex"] = sceneList.sources.num - i - 1;
@ -107,33 +109,13 @@ std::vector<json> Utils::Obs::ArrayHelper::GetSceneList()
 	return ret;
 }

-std::vector<std::string> Utils::Obs::ArrayHelper::GetGroupList()
-{
-	std::vector<std::string> ret;
-
-	auto cb = [](void *priv_data, obs_source_t *scene) {
-		auto ret = static_cast<std::vector<std::string>*>(priv_data);
-
-		if (!obs_source_is_group(scene))
-			return true;
-
-		ret->emplace_back(obs_source_get_name(scene));
-
-		return true;
-	};
-
-	obs_enum_scenes(cb, &ret);
-
-	return ret;
-}
-
 std::vector<json> Utils::Obs::ArrayHelper::GetSceneItemList(obs_scene_t *scene, bool basic)
 {
 	std::pair<std::vector<json>, bool> enumData;
 	enumData.second = basic;

 	obs_scene_enum_items(scene, [](obs_scene_t*, obs_sceneitem_t* sceneItem, void* param) {
-		auto enumData = static_cast<std::pair<std::vector<json>, bool>*>(param);
+		auto enumData = reinterpret_cast<std::pair<std::vector<json>, bool>*>(param);

 		json item;
 		item["sceneItemId"] = obs_sceneitem_get_id(sceneItem);
@ -176,7 +158,7 @@ std::vector<json> Utils::Obs::ArrayHelper::GetInputList(std::string inputKind)
 		if (obs_source_get_type(input) != OBS_SOURCE_TYPE_INPUT)
 			return true;

-		auto inputInfo = static_cast<EnumInputInfo*>(param);
+		auto inputInfo = reinterpret_cast<EnumInputInfo*>(param);

 		std::string inputKind = obs_source_get_id(input);

@ -226,8 +208,6 @@ std::vector<json> Utils::Obs::ArrayHelper::GetListPropertyItems(obs_property_t *
 	enum obs_combo_format itemFormat = obs_property_list_format(property);
 	size_t itemCount = obs_property_list_item_count(property);

-	ret.reserve(itemCount);
-
 	for (size_t i = 0; i < itemCount; i++) {
 		json itemData;
 		itemData["itemName"] = obs_property_list_item_name(property, i);
@ -265,7 +245,6 @@ std::vector<json> Utils::Obs::ArrayHelper::GetSceneTransitionList()
 	obs_frontend_get_transitions(&transitionList);

 	std::vector<json> ret;
-	ret.reserve(transitionList.sources.num);
 	for (size_t i = 0; i < transitionList.sources.num; i++) {
 		obs_source_t *transition = transitionList.sources.array[i];
 		json transitionJson;
@ -280,38 +259,3 @@ std::vector<json> Utils::Obs::ArrayHelper::GetSceneTransitionList()

 	return ret;
 }
-
-std::vector<std::string> Utils::Obs::ArrayHelper::GetFilterKindList()
-{
-	std::vector<std::string> ret;
-
-	size_t idx = 0;
-	const char *kind;
-	while(obs_enum_filter_types(idx++, &kind))
-		ret.push_back(kind);
-
-	return ret;
-}
-
-std::vector<json> Utils::Obs::ArrayHelper::GetSourceFilterList(obs_source_t *source)
-{
-	std::vector<json> filters;
-
-	auto enumFilters = [](obs_source_t *, obs_source_t *filter, void *param) {
-		auto filters = reinterpret_cast<std::vector<json>*>(param);
-
-		json filterJson;
-		filterJson["filterEnabled"] = obs_source_enabled(filter);
-		filterJson["filterIndex"] = filters->size();
-		filterJson["filterKind"] = obs_source_get_id(filter);
-		filterJson["filterName"] = obs_source_get_name(filter);
-
-		OBSDataAutoRelease filterSettings = obs_source_get_settings(filter);
-		filterJson["filterSettings"] = Utils::Json::ObsDataToJson(filterSettings);
-
-		filters->push_back(filterJson);
-	};
-	obs_source_enum_filters(source, enumFilters, &filters);
-
-	return filters;
-}
--- a/src/utils/Obs_EnumHelper.cpp
+++ b/src/utils/Obs_EnumHelper.cpp
@ -23,38 +23,25 @@ with this program. If not, see <https://www.gnu.org/licenses/>

 enum obs_bounds_type Utils::Obs::EnumHelper::GetSceneItemBoundsType(std::string boundsType)
 {
-	RET_COMPARE(boundsType, OBS_BOUNDS_NONE)
-	RET_COMPARE(boundsType, OBS_BOUNDS_STRETCH)
-	RET_COMPARE(boundsType, OBS_BOUNDS_SCALE_INNER)
-	RET_COMPARE(boundsType, OBS_BOUNDS_SCALE_OUTER)
-	RET_COMPARE(boundsType, OBS_BOUNDS_SCALE_TO_WIDTH)
-	RET_COMPARE(boundsType, OBS_BOUNDS_SCALE_TO_HEIGHT)
-	RET_COMPARE(boundsType, OBS_BOUNDS_MAX_ONLY)
+	RET_COMPARE(boundsType, OBS_BOUNDS_NONE);
+	RET_COMPARE(boundsType, OBS_BOUNDS_STRETCH);
+	RET_COMPARE(boundsType, OBS_BOUNDS_SCALE_INNER);
+	RET_COMPARE(boundsType, OBS_BOUNDS_SCALE_OUTER);
+	RET_COMPARE(boundsType, OBS_BOUNDS_SCALE_TO_WIDTH);
+	RET_COMPARE(boundsType, OBS_BOUNDS_SCALE_TO_HEIGHT);
+	RET_COMPARE(boundsType, OBS_BOUNDS_MAX_ONLY);

 	return OBS_BOUNDS_NONE;
 }

 enum ObsMediaInputAction Utils::Obs::EnumHelper::GetMediaInputAction(std::string mediaAction)
 {
-	RET_COMPARE(mediaAction, OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PLAY)
-	RET_COMPARE(mediaAction, OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PAUSE)
-	RET_COMPARE(mediaAction, OBS_WEBSOCKET_MEDIA_INPUT_ACTION_STOP)
-	RET_COMPARE(mediaAction, OBS_WEBSOCKET_MEDIA_INPUT_ACTION_RESTART)
-	RET_COMPARE(mediaAction, OBS_WEBSOCKET_MEDIA_INPUT_ACTION_NEXT)
-	RET_COMPARE(mediaAction, OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PREVIOUS)
+	RET_COMPARE(mediaAction, OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PLAY);
+	RET_COMPARE(mediaAction, OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PAUSE);
+	RET_COMPARE(mediaAction, OBS_WEBSOCKET_MEDIA_INPUT_ACTION_STOP);
+	RET_COMPARE(mediaAction, OBS_WEBSOCKET_MEDIA_INPUT_ACTION_RESTART);
+	RET_COMPARE(mediaAction, OBS_WEBSOCKET_MEDIA_INPUT_ACTION_NEXT);
+	RET_COMPARE(mediaAction, OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PREVIOUS);

 	return OBS_WEBSOCKET_MEDIA_INPUT_ACTION_NONE;
 }
-
-enum obs_blending_type Utils::Obs::EnumHelper::GetSceneItemBlendMode(std::string mode)
-{
-	RET_COMPARE(mode, OBS_BLEND_NORMAL)
-	RET_COMPARE(mode, OBS_BLEND_ADDITIVE)
-	RET_COMPARE(mode, OBS_BLEND_SUBTRACT)
-	RET_COMPARE(mode, OBS_BLEND_SCREEN)
-	RET_COMPARE(mode, OBS_BLEND_MULTIPLY)
-	RET_COMPARE(mode, OBS_BLEND_LIGHTEN)
-	RET_COMPARE(mode, OBS_BLEND_DARKEN)
-
-	return OBS_BLEND_NORMAL;
-}
--- a/src/utils/Obs_NumberHelper.cpp
+++ b/src/utils/Obs_NumberHelper.cpp
@ -39,7 +39,7 @@ size_t Utils::Obs::NumberHelper::GetSceneCount()
 {
 	size_t ret;
 	auto sceneEnumProc = [](void *param, obs_source_t *scene) {
-		auto ret = static_cast<size_t*>(param);
+		auto ret = reinterpret_cast<size_t*>(param);

 		if (obs_source_is_group(scene))
 			return true;
@ -52,28 +52,3 @@ size_t Utils::Obs::NumberHelper::GetSceneCount()

 	return ret;
 }
-
-size_t Utils::Obs::NumberHelper::GetSourceFilterIndex(obs_source_t *source, obs_source_t *filter)
-{
-	struct FilterSearch {
-		obs_source_t *filter;
-		bool found;
-		size_t index;
-	};
-
-	auto search = [](obs_source_t *, obs_source_t *filter, void *priv_data) {
-		auto filterSearch = static_cast<FilterSearch*>(priv_data);
-
-		if (filter == filterSearch->filter)
-			filterSearch->found = true;
-
-		if (!filterSearch->found)
-			filterSearch->index++;
-	};
-
-	FilterSearch filterSearch = {filter, 0, 0};
-
-	obs_source_enum_filters(source, search, &filterSearch);
-
-	return filterSearch.index;
-}
--- a/src/utils/Obs_StringHelper.cpp
+++ b/src/utils/Obs_StringHelper.cpp
@ -64,10 +64,12 @@ std::string Utils::Obs::StringHelper::GetCurrentProfilePath()

 std::string Utils::Obs::StringHelper::GetCurrentRecordOutputPath()
 {
-	char *recordOutputPath = obs_frontend_get_current_record_output_path();
-	std::string ret = recordOutputPath;
-	bfree(recordOutputPath);
-	return ret;
+	//char *recordOutputPath = obs_frontend_get_current_record_output_path();
+	//std::string ret = recordOutputPath;
+	//bfree(recordOutputPath);
+	//return ret;
+
+	return "";
 }

 std::string Utils::Obs::StringHelper::GetSourceType(obs_source_t *source)
@ -120,19 +122,12 @@ std::string Utils::Obs::StringHelper::GetMediaInputState(obs_source_t *input)
 std::string Utils::Obs::StringHelper::GetLastReplayBufferFilePath()
 {
 	OBSOutputAutoRelease output = obs_frontend_get_replay_buffer_output();
-	if (!output)
-		return "";
-
 	calldata_t cd = {0};
 	proc_handler_t *ph = obs_output_get_proc_handler(output);
 	proc_handler_call(ph, "get_last_replay", &cd);
-	const char *savedReplayPath = calldata_string(&cd, "path");
+	auto ret = calldata_string(&cd, "path");
 	calldata_free(&cd);
-
-	if (!savedReplayPath)
-		return "";
-
-	return savedReplayPath;
+	return ret;
 }

 std::string Utils::Obs::StringHelper::GetSceneItemBoundsType(enum obs_bounds_type type)
@ -149,20 +144,6 @@ std::string Utils::Obs::StringHelper::GetSceneItemBoundsType(enum obs_bounds_typ
 	}
 }

-std::string Utils::Obs::StringHelper::GetSceneItemBlendMode(enum obs_blending_type mode)
-{
-	switch (mode) {
-		default:
-		CASE(OBS_BLEND_NORMAL)
-		CASE(OBS_BLEND_ADDITIVE)
-		CASE(OBS_BLEND_SUBTRACT)
-		CASE(OBS_BLEND_SCREEN)
-		CASE(OBS_BLEND_MULTIPLY)
-		CASE(OBS_BLEND_LIGHTEN)
-		CASE(OBS_BLEND_DARKEN)
-	}
-}
-
 std::string Utils::Obs::StringHelper::DurationToTimecode(uint64_t ms)
 {
 	uint64_t secs = ms / 1000ULL;
--- a/src/utils/Obs_VolumeMeter.cpp
+++ b/src/utils/Obs_VolumeMeter.cpp
@ -59,7 +59,8 @@ Utils::Obs::VolumeMeter::Meter::~Meter()

 bool Utils::Obs::VolumeMeter::Meter::InputValid()
 {
-	return !obs_weak_source_expired(_input);
+	// return !obs_weak_source_expired(_input);
+	return true;
 }

 json Utils::Obs::VolumeMeter::Meter::GetMeterData()
--- a/src/utils/Obs_VolumeMeter_Helpers.h
+++ b/src/utils/Obs_VolumeMeter_Helpers.h
@ -56,7 +56,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 		r = fmaxf(r, x4_mem[3]);   \
 	} while (false)

-static float GetSamplePeak(__m128 previousSamples, const float *samples, size_t sampleCount)
+float GetSamplePeak(__m128 previousSamples, const float *samples, size_t sampleCount)
 {
 	__m128 peak = previousSamples;
 	for (size_t i = 0; (i + 3) < sampleCount; i += 4) {
@ -69,7 +69,7 @@ static float GetSamplePeak(__m128 previousSamples, const float *samples, size_t
 	return ret;
 }

-static float GetTruePeak(__m128 previousSamples, const float *samples, size_t sampleCount)
+float GetTruePeak(__m128 previousSamples, const float *samples, size_t sampleCount)
 {
 	const __m128 m3 = _mm_set_ps(-0.155915f, 0.935489f, 0.233872f, -0.103943f);
 	const __m128 m1 = _mm_set_ps(-0.216236f, 0.756827f, 0.504551f, -0.189207f);
--- a/src/utils/Platform.cpp
+++ b/src/utils/Platform.cpp
@ -111,9 +111,9 @@ void Utils::Platform::SendTrayNotification(QSystemTrayIcon::MessageIcon icon, QS

 	obs_queue_task(OBS_TASK_UI, [](void* param) {
 		void *systemTrayPtr = obs_frontend_get_system_tray();
-		auto systemTray = static_cast<QSystemTrayIcon*>(systemTrayPtr);
+		auto systemTray = reinterpret_cast<QSystemTrayIcon*>(systemTrayPtr);

-		auto notification = static_cast<SystemTrayNotification*>(param);
+		auto notification = reinterpret_cast<SystemTrayNotification*>(param);
 		systemTray->showMessage(notification->title, notification->body, notification->icon);
 		delete notification;
 	}, (void*)notification, false);
--- a/src/websocketserver/WebSocketServer.h
+++ b/src/websocketserver/WebSocketServer.h
@ -23,7 +23,6 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #include <QObject>
 #include <QThreadPool>
 #include <QString>
-#include <asio.hpp>
 #include <websocketpp/config/asio_no_tls.hpp>
 #include <websocketpp/server.hpp>

--- a/src/websocketserver/WebSocketServer_Protocol.cpp
+++ b/src/websocketserver/WebSocketServer_Protocol.cpp
@ -233,7 +233,7 @@ void WebSocketServer::ProcessMessage(SessionPtr session, WebSocketServer::Proces
 					return;
 				}

-				int8_t requestedExecutionType = payloadData["executionType"];
+				uint8_t requestedExecutionType = payloadData["executionType"];
 				if (!RequestBatchExecutionType::IsValid(requestedExecutionType) || requestedExecutionType == RequestBatchExecutionType::None) {
 					ret.closeCode = WebSocketCloseCode::InvalidDataFieldValue;
 					ret.closeReason = "Your `executionType` has an invalid value.";