Base: Update issue template

.clang-format

@@ -1,107 +0,0 @@
-# please use clang-format version 8 or later
-
-Standard: Cpp11
-AccessModifierOffset: -8
-AlignAfterOpenBracket: Align
-AlignConsecutiveAssignments: false
-AlignConsecutiveDeclarations: false
-AlignEscapedNewlines: Left
-AlignOperands: true
-AlignTrailingComments: true
-#AllowAllArgumentsOnNextLine: false  # requires clang-format 9
-#AllowAllConstructorInitializersOnNextLine: false  # requires clang-format 9
-AllowAllParametersOfDeclarationOnNextLine: false
-AllowShortBlocksOnASingleLine: false
-AllowShortCaseLabelsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: Inline
-AllowShortIfStatementsOnASingleLine: false
-#AllowShortLambdasOnASingleLine: Inline  # requires clang-format 9
-AllowShortLoopsOnASingleLine: false
-AlwaysBreakAfterDefinitionReturnType: None
-AlwaysBreakAfterReturnType: None
-AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: false
-BinPackArguments: true
-BinPackParameters: true
-BraceWrapping:
-  AfterClass: false
-  AfterControlStatement: false
-  AfterEnum: false
-  AfterFunction: true
-  AfterNamespace: false
-  AfterObjCDeclaration: false
-  AfterStruct: false
-  AfterUnion: false
-  AfterExternBlock: false
-  BeforeCatch: false
-  BeforeElse: false
-  IndentBraces: false
-  SplitEmptyFunction: true
-  SplitEmptyRecord: true
-  SplitEmptyNamespace: true
-BreakBeforeBinaryOperators: None
-BreakBeforeBraces: Custom
-BreakBeforeTernaryOperators: true
-BreakConstructorInitializers: BeforeColon
-BreakStringLiterals: false  # apparently unpredictable
-ColumnLimit: 132
-CompactNamespaces: false
-ConstructorInitializerAllOnOneLineOrOnePerLine: true
-ConstructorInitializerIndentWidth: 8
-ContinuationIndentWidth: 8
-Cpp11BracedListStyle: true
-DerivePointerAlignment: false
-DisableFormat: false
-FixNamespaceComments: false
-ForEachMacros: 
-  - 'json_object_foreach'
-  - 'json_object_foreach_safe'
-  - 'json_array_foreach'
-IncludeBlocks: Preserve
-IndentCaseLabels: false
-IndentPPDirectives: None
-IndentWidth: 8
-IndentWrappedFunctionNames: false
-KeepEmptyLinesAtTheStartOfBlocks: true
-MaxEmptyLinesToKeep: 1
-NamespaceIndentation: All
-#ObjCBinPackProtocolList: Auto  # requires clang-format 7
-ObjCBlockIndentWidth: 8
-ObjCSpaceAfterProperty: true
-ObjCSpaceBeforeProtocolList: true
-
-PenaltyBreakAssignment: 10
-PenaltyBreakBeforeFirstCallParameter: 30
-PenaltyBreakComment: 10
-PenaltyBreakFirstLessLess: 0
-PenaltyBreakString: 10
-PenaltyExcessCharacter: 100
-PenaltyReturnTypeOnItsOwnLine: 60
-
-PointerAlignment: Right
-ReflowComments: false
-SortIncludes: false
-SortUsingDeclarations: false
-SpaceAfterCStyleCast: false
-#SpaceAfterLogicalNot: false  # requires clang-format 9
-SpaceAfterTemplateKeyword: false
-SpaceBeforeAssignmentOperators: true
-#SpaceBeforeCtorInitializerColon: true  # requires clang-format 7
-#SpaceBeforeInheritanceColon: true  # requires clang-format 7
-SpaceBeforeParens: ControlStatements
-#SpaceBeforeRangeBasedForLoopColon: true  # requires clang-format 7
-SpaceInEmptyParentheses: false
-SpacesBeforeTrailingComments: 1
-SpacesInAngles: false
-SpacesInCStyleCastParentheses: false
-SpacesInContainerLiterals: false
-SpacesInParentheses: false
-SpacesInSquareBrackets: false
-#StatementMacros:  # requires clang-format 8
-#  - 'Q_OBJECT'
-TabWidth: 8
-#TypenameMacros:  # requires clang-format 9
-#  - 'DARRAY'
-UseTab: ForContinuationAndIndentation
----
-Language: ObjC

.github/ISSUE_TEMPLATE/bug_report.yaml

@@ -27,11 +27,10 @@ body:
     - macOS 10.15
     - macOS 10.14
     - macOS 10.13
-    - Ubuntu 22.04 LTS
     - Ubuntu 21.04
     - Ubuntu 20.10
-    - Ubuntu 20.04 LTS
+    - Ubuntu 20.04
-    - Ubuntu 18.04 LTS
+    - Ubuntu 18.04
     - Other
   validations:
     required: true
@@ -49,12 +48,6 @@ body:
     label: OBS Studio Version
     description: What version of OBS Studio are you using?
     options:
-    - 28.0.0
-    - 27.2.4
-    - 27.2.3
-    - 27.2.2
-    - 27.2.1
-    - 27.2.0
     - 27.1.3
     - 27.1.1
     - 27.1.0
@@ -76,9 +69,10 @@ body:
     label: obs-websocket Version
     description: What version of obs-websocket are you using?
     options:
-    - 5.0.1
+    - 5.0.0-alpha3
-    - 5.0.0
+    - 5.0.0-alpha2
-    - 5.0.0-beta1
+    - 4.9.1
+    - 4.9.0
     - Git
   validations:
     required: true

.github/pull_request_template.md

@@ -29,6 +29,6 @@ Tested OS(s):
 <!--- If you're unsure about any of these, don't hesitate to ask. We're here to help! -->
 -  [ ] I have read the [Contributing Guidelines](https://github.com/obsproject/obs-websocket/wiki/Contributing-Guidelines).
 -  [ ] All commit messages are properly formatted and commits squashed where appropriate.
--  [ ] My code is not on `master` or a `release/*` branch.
+-  [ ] My code is not on the `master` branch.
 -  [ ] The code has been tested.
 -  [ ] I have included updates to all appropriate documentation.

.github/workflows/generate_docs.yml

@@ -1,27 +1,27 @@
-name: 'Generate docs'
+name: 'Generate docs'
-
+
-on:
+on:
-  push:
+  push:
-    paths-ignore:
+    paths-ignore:
-      - 'docs/generated/**'
+      - 'docs/generated/**'
-    branches:
+    branches:
-      - release/5.0.0
+      - master
-
+
-jobs:
+jobs:
-  docs-build:
+  docs-build:
-    name: 'Generate docs [Ubuntu]'
+    name: 'Generate docs [Ubuntu]'
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-latest
-    if: ${{ github.ref == 'refs/heads/master' }}
+    if: ${{ github.ref == 'refs/heads/master' }}
-    env: 
+    env: 
-      CHECKOUT_REF: ${{ github.ref }}
+      CHECKOUT_REF: ${{ github.ref }}
-      GH_TOKEN: ${{ github.token }}
+      GH_TOKEN: ${{ github.token }}
-      IS_CI: "true"
+      IS_CI: "true"
-    steps:
+    steps:
-      - name: 'Checkout'
+      - name: 'Checkout'
-        uses: actions/checkout@v2
+        uses: actions/checkout@v2
-        with:
+        with:
-          path: ${{ github.workspace }}/obs-websocket
+          path: ${{ github.workspace }}/obs-websocket
-      - name: 'Generate docs'
+      - name: 'Generate docs'
-        working-directory: ${{ github.workspace }}/obs-websocket
+        working-directory: ${{ github.workspace }}/obs-websocket
-        run: |
+        run: |
-          ./CI/generate-docs.sh
+          ./CI/generate-docs.sh

.github/workflows/lint.yml

@@ -1,24 +0,0 @@
-name: Code Quality
-
-on:
-  push:
-    branches:
-      - release/5.0.0
-  pull_request:
-    branches:
-      - release/5.0.0
-
-jobs:
-  markdown:
-    name: Lint Markdown
-    runs-on: ubuntu-latest
-    if: contains(github.event.head_commit.message, '[skip ci]') != true
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v2
-      - name: Generate docs
-        run: cd docs && ./build_docs.sh
-      - name: Run markdownlint-cli
-        uses: nosborn/github-action-markdown-cli@v3.0.1
-        with:
-          files: .

.github/workflows/main.yml

@@ -1,11 +1,11 @@
-name: 'CI Multiplatform Build'
+name: "CI Multiplatform Build"
 
 on:
   push:
     paths-ignore:
       - 'docs/**'
     branches:
-      - release/5.0.0
+      - master
     tags:
       - '[45].[0-9]+.[0-9]+*'
   pull_request:
@@ -13,20 +13,20 @@ on:
       - 'docs/**'
       - '**.md'
     branches:
-      - release/5.0.0
+      - master
 
 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_GENERATOR: "Visual Studio 16 2019"
-      CMAKE_SYSTEM_VERSION: '10.0'
+      CMAKE_SYSTEM_VERSION: "10.0"
     steps:
       - name: 'Add msbuild to PATH'
         uses: microsoft/setup-msbuild@v1.0.2
@@ -35,21 +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=27.2.4" >> $GITHUB_ENV
+          echo "OBS_GIT_TAG=$(git describe --tags --abbrev=0)" >> $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: |
@@ -79,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: |
@@ -86,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:
@@ -105,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 -DBUILD_VST=OFF ..
+          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:
@@ -126,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 -DBUILD_VST=OFF ..
+          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: |
@@ -181,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:
@@ -190,21 +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=27.2.4" >> $GITHUB_ENV
+          echo "OBS_GIT_TAG=$(git describe --tags --abbrev=0)" >> $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: |
@@ -278,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: |
@@ -310,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
@@ -336,9 +342,9 @@ jobs:
           cd ./build
           sudo checkinstall -y --type=debian --fstrans=no -nodoc \
               --backup=no --deldoc=yes --install=no --pkgname=obs-websocket --pkgversion="$CHECKINSTALL_VERSION" \
-              --pkglicense="GPLv2.0" --maintainer="tt2468@irltoolkit.com" --pkggroup="video" \
+              --pkglicense="GPLv2.0" --maintainer="${{ github.event.pusher.email }}" --pkggroup="video" \
               --pkgsource="${{ github.event.repository.html_url }}" \
-              --requires="obs-studio,libqt5network5,qt5-image-formats-plugins" \
+              --requires="obs-studio,libqt5network5,libqt5concurrent5,qt5-image-formats-plugins" \
               --pakdir="../package"
           sudo chmod ao+r ../package/*
           sudo mv ../package/* ../package/${{ env.LINUX_FILENAME }}
@@ -349,215 +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=27.2.4" >> $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'

.gitignore

@@ -11,4 +11,3 @@
 /docs/node_modules/
 /src/plugin-macros.generated.h
 /installer/installer-windows.generated.iss
-/cmake-build-debug/

.markdownlintignore

@@ -1,2 +0,0 @@
-/deps
-/docs/comments/node_modules

.markdownlintrc

@@ -1,3 +0,0 @@
-{
-    "line-length": false
-}

CI/check-format.sh

@@ -1,57 +0,0 @@
-#!/usr/bin/env bash
-# Original source https://github.com/Project-OSRM/osrm-backend/blob/master/scripts/format.sh
-
-set -o errexit
-set -o pipefail
-set -o nounset
-
-if [ ${#} -eq 1 ]; then
-    VERBOSITY="--verbose"
-else
-    VERBOSITY=""
-fi
-
-# Runs the Clang Formatter in parallel on the code base.
-# Return codes:
-#  - 1 there are files to be formatted
-#  - 0 everything looks fine
-
-# Get CPU count
-OS=$(uname)
-NPROC=1
-if [[ ${OS} = "Linux" ]] ; then
-    NPROC=$(nproc)
-elif [[ ${OS} = "Darwin" ]] ; then
-    NPROC=$(sysctl -n hw.physicalcpu)
-fi
-
-# Discover clang-format
-if type clang-format-12 2> /dev/null ; then
-    CLANG_FORMAT=clang-format-12
-elif type clang-format 2> /dev/null ; then
-    # Clang format found, but need to check version
-    CLANG_FORMAT=clang-format
-    V=$(clang-format --version)
-    if [[ $V != *"version 12.0"* ]]; then
-        echo "clang-format is not 12.0 (returned ${V})"
-        exit 1
-    fi
-else
-    echo "No appropriate clang-format found (expected clang-format-12.0.0, or clang-format)"
-    exit 1
-fi
-
-find . -type d \( \
-    -path ./\*build\* -o \
-    -path ./deps/websocketpp -o \
-    -path ./deps/asio -o \
-    -path ./deps/json -o \
-    -path ./deps/qr \
-\) -prune -false -type f -o \
-    -name '*.h' -or \
-    -name '*.hpp' -or \
-    -name '*.m' -or \
-    -name '*.m,' -or \
-    -name '*.c' -or \
-    -name '*.cpp' \
- | xargs -L100 -P ${NPROC} ${CLANG_FORMAT} ${VERBOSITY} -i -style=file -fallback-style=none

CI/macos/Brewfile

@@ -0,0 +1,5 @@
+brew "jack"
+brew "speexdsp"
+brew "cmake"
+brew "freetype"
+brew "fdk-aac"

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

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

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

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>

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

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.16...3.20)
 
 # Version variables
-project(obs-websocket VERSION 5.0.1)
+project(obs-websocket VERSION 5.0.0)
 set(OBS_WEBSOCKET_RPC_VERSION 1)
 
 
@@ -85,7 +85,7 @@ configure_file(
 )
 
 
-# Include sources
+# Inlude sources
 set(obs-websocket_SOURCES
 	src/obs-websocket.cpp
 	src/Config.cpp
@@ -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
@@ -129,6 +128,7 @@ set(obs-websocket_SOURCES
 	src/utils/Json.cpp
 	src/utils/Obs.cpp
 	src/utils/Obs_StringHelper.cpp
+	src/utils/Obs_EnumHelper.cpp
 	src/utils/Obs_NumberHelper.cpp
 	src/utils/Obs_ArrayHelper.cpp
 	src/utils/Obs_ObjectHelper.cpp

README.md

@@ -1,5 +1,3 @@
-<!-- markdownlint-disable no-inline-html -->
-
 # obs-websocket
 
 <p align="center">
@@ -8,6 +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/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)
 
@@ -19,7 +18,7 @@ Binaries for Windows, MacOS, and Linux are available in the [Releases](https://g
 
 It is **highly recommended** to protect obs-websocket with a password against unauthorized control. To do this, open the "Websocket server settings" dialog under OBS' "Tools" menu. In the settings dialogs, you can enable or disable authentication and set a password for it.
 
-(Psst. You can use `--websocket_port`(value), `--websocket_password`(value), `--websocket_debug`(flag) and `--websocket_ipv4_only`(flag) on the command line to override the configured values.)
+(Psst. You can use `--websocket_port`(value), `--websocket_password`(value), and `--websocket_debug`(flag) on the command line to override the configured values.)
 
 ### Possible use cases
 
@@ -28,22 +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. Send a message in Discord if you have one!)
-- (No known clients supporting 5.0.0 at the moment. Ping us in the 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
-- Javascript (Node and web): [obs-websocket-js](https://github.com/obs-websocket-community-projects/obs-websocket-js) by OBS Websocket Community
 
-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
 

docs/README.md

@@ -1,138 +1,127 @@
-# obs-websocket documentation
+# obs-websocket documentation
-
+
-This is the documentation for obs-websocket. Run `build_docs.sh` to auto generate the latest docs from the `src` directory. There are 3 components to the docs generation:
+This is the documentation for obs-websocket. Run build_docs.sh to auto generate the latest docs from the `src` directory. There are 3 components to the docs generation:
-
+- `comments/comments.js`: Generates the `work/comments.json` file from the code comments in the src directory.
-- `comments/comments.js`: Generates the `work/comments.json` file from the code comments in the src directory.
+- `docs/process_comments.py`: Processes `work/comments.json` to create `generated/protocol.json`, which is a machine-readable documentation format that can be used to create obs-websocket client libraries.
-- `docs/process_comments.py`: Processes `work/comments.json` to create `generated/protocol.json`, which is a machine-readable documentation format that can be used to create obs-websocket client libraries.
+- `docs/generate_md.py`: Processes `generated/protocol.json` to create `generated/protocol.md`, which is the actual human-readable documentation.
-- `docs/generate_md.py`: Processes `generated/protocol.json` to create `generated/protocol.md`, which is the actual human-readable documentation.
+
-
+Some notes about documenting:
-Some notes about documenting:
+- The `complexity` comment line is a suggestion to the user about how much knowledge about OBS's inner workings is required to safely use the associated feature. `1` for easy, `5` for megadeath-expert.
-
+- The `rpcVersion` comment line is used to specify the latest available version that the feature is available in. If a feature is deprecated, then the placeholder value of `-1` should be replaced with the last RPC version that the feature will be available in. Manually specifying an RPC version automatically adds the `Deprecated` line to the entry in `generated/protocol.md`.
-- The `complexity` comment line is a suggestion to the user about how much knowledge about OBS's inner workings is required to safely use the associated feature. `1` for easy, `5` for megadeath-expert.
+- The description can be multiple lines, but must be contained above the first documentation property (the lines starting with `@`).
-- The `rpcVersion` comment line is used to specify the latest available version that the feature is available in. If a feature is deprecated, then the placeholder value of `-1` should be replaced with the last RPC version that the feature will be available in. Manually specifying an RPC version automatically adds the `Deprecated` line to the entry in `generated/protocol.md`.
+- Value types are in reference to JSON values. The only ones you should use are `Any`, `String`, `Boolean`, `Number`, `Array`, `Object`.
-- The description can be multiple lines, but must be contained above the first documentation property (the lines starting with `@`).
+  - `Array` types follow this format: `Array<subtype>`, for example `Array<String>` to specify an array of strings.
-- Value types are in reference to JSON values. The only ones you should use are `Any`, `String`, `Boolean`, `Number`, `Array`, `Object`.
+
-  - `Array` types follow this format: `Array<subtype>`, for example `Array<String>` to specify an array of strings.
+Formatting notes:
-
+- Fields should have their columns aligned. So in a request, the columns of all `@requestField`s should be aligned.
-Formatting notes:
+- We suggest looking at how other enums/events/requests have been documented before documenting one of your own, to get a general feel of how things have been formatted.
-
+
-- Fields should have their columns aligned. So in a request, the columns of all `@requestField`s should be aligned.
+## Creating enum documentation
-- We suggest looking at how other enums/events/requests have been documented before documenting one of your own, to get a general feel of how things have been formatted.
+
-
+Enums follow this code comment format:
-## Creating enum documentation
+```
-
+/**
-Enums follow this code comment format:
+* [description]
-
+*
-```js
+* @enumIdentifier [identifier]
-/**
+* @enumValue [value]
-* [description]
+* @enumType [type]
-*
+* @rpcVersion [latest available RPC version, use `-1` unless deprecated.]
-* @enumIdentifier [identifier]
+* @initialVersion [first obs-websocket version this is found in]
-* @enumValue [value]
+* @api enums
-* @enumType [type]
+*/
-* @rpcVersion [latest available RPC version, use `-1` unless deprecated.]
+```
-* @initialVersion [first obs-websocket version this is found in]
+
-* @api enums
+Example code comment:
-*/
+```
-```
+/**
-
+* The initial message sent by obs-websocket to newly connected clients.
-Example code comment:
+*
-
+* @enumIdentifier Hello
-```js
+* @enumValue 0
-/**
+* @enumType WebSocketOpCode
-* The initial message sent by obs-websocket to newly connected clients.
+* @rpcVersion -1
-*
+* @initialVersion 5.0.0
-* @enumIdentifier Hello
+* @api enums
-* @enumValue 0
+*/
-* @enumType WebSocketOpCode
+```
-* @rpcVersion -1
+- This is the documentation for the `WebSocketOpCode::Hello` enum identifier.
-* @initialVersion 5.0.0
+
-* @api enums
+## Creating event documentation
-*/
+
-```
+Events follow this code comment format:
-
+```
-- This is the documentation for the `WebSocketOpCode::Hello` enum identifier.
+/**
-
+ * [description]
-## Creating event documentation
+ *
-
+ * @dataField [field name] | [value type] | [field description]
-Events follow this code comment format:
+ * [... more @dataField entries ...]
-
+ *
-```js
+ * @eventType [type]
-/**
+ * @eventSubscription [EventSubscription requirement]
- * [description]
+ * @complexity [complexity rating, 1-5]
- *
+ * @rpcVersion [latest available RPC version, use `-1` unless deprecated.]
- * @dataField [field name] | [value type] | [field description]
+ * @initialVersion [first obs-websocket version this is found in]
- * [... more @dataField entries ...]
+ * @category [event category]
- *
+ * @api events
- * @eventType [type]
+ */
- * @eventSubscription [EventSubscription requirement]
+```
- * @complexity [complexity rating, 1-5]
+
- * @rpcVersion [latest available RPC version, use `-1` unless deprecated.]
+Example code comment:
- * @initialVersion [first obs-websocket version this is found in]
+```
- * @category [event category]
+/**
- * @api events
+ * Studio mode has been enabled or disabled.
- */
+ *
-```
+ * @dataField studioModeEnabled | Boolean | True == Enabled, False == Disabled
-
+ *
-Example code comment:
+ * @eventType StudioModeStateChanged
-
+ * @eventSubscription General
-```js
+ * @complexity 1
-/**
+ * @rpcVersion -1
- * Studio mode has been enabled or disabled.
+ * @initialVersion 5.0.0
- *
+ * @category general
- * @dataField studioModeEnabled | Boolean | True == Enabled, False == Disabled
+ * @api events
- *
+ */
- * @eventType StudioModeStateChanged
+```
- * @eventSubscription General
+
- * @complexity 1
+## Creating request documentation
- * @rpcVersion -1
+
- * @initialVersion 5.0.0
+Requests follow this code comment format:
- * @category general
+```
- * @api events
+/**
- */
+ * [description]
-```
+ *
-
+ * @requestField [optional flag][field name] | [value type] | [field description] | [value restrictions (only include if the value type is `Number`)] | [default behavior (only include if optional flag is set)]
-## Creating request documentation
+ * [... more @requestField entries ...]
-
+ *
-Requests follow this code comment format:
+ * @responseField [field name] | [value type] | [field description]
-
+ * [... more @responseField entries ...]
-```js
+ *
-/**
+ * @requestType [type]
- * [description]
+ * @complexity [complexity rating, 1-5]
- *
+ * @rpcVersion [latest available RPC version, use `-1` unless deprecated.]
- * @requestField [optional flag][field name] | [value type] | [field description] | [value restrictions (only include if the value type is `Number`)] | [default behavior (only include if optional flag is set)]
+ * @initialVersion [first obs-websocket version this is found in]
- * [... more @requestField entries ...]
+ * @category [request category]
- *
+ * @api requests
- * @responseField [field name] | [value type] | [field description]
+ */
- * [... more @responseField entries ...]
+```
- *
+- The optional flag is a `?` that prefixes the field name, telling the docs processor that the field is optionally specified.
- * @requestType [type]
+
- * @complexity [complexity rating, 1-5]
+Example code comment:
- * @rpcVersion [latest available RPC version, use `-1` unless deprecated.]
+```
- * @initialVersion [first obs-websocket version this is found in]
+/**
- * @category [request category]
+ * Gets the value of a "slot" from the selected persistent data realm.
- * @api requests
+ *
- */
+ * @requestField realm    | String | The data realm to select. `OBS_WEBSOCKET_DATA_REALM_GLOBAL` or `OBS_WEBSOCKET_DATA_REALM_PROFILE`
-```
+ * @requestField slotName | String | The name of the slot to retrieve data from
-
+ *
-- The optional flag is a `?` that prefixes the field name, telling the docs processor that the field is optionally specified.
+ * @responseField slotValue | String | Value associated with the slot. `null` if not set
-
+ *
-Example code comment:
+ * @requestType GetPersistentData
-
+ * @complexity 2
-```js
+ * @rpcVersion -1
-/**
+ * @initialVersion 5.0.0
- * Gets the value of a "slot" from the selected persistent data realm.
+ * @category config
- *
+ * @api requests
- * @requestField realm    | String | The data realm to select. `OBS_WEBSOCKET_DATA_REALM_GLOBAL` or `OBS_WEBSOCKET_DATA_REALM_PROFILE`
+ */
- * @requestField slotName | String | The name of the slot to retrieve data from
+```
- *
- * @responseField slotValue | String | Value associated with the slot. `null` if not set
- *
- * @requestType GetPersistentData
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @category config
- * @api requests
- */
-```

docs/docs/generate_md.py

@@ -30,6 +30,7 @@ categoryOrder = [
 ]
 
 requestFieldHeader = """
+
 **Request Fields:**
 
 | Name | Type  | Description | Value Restrictions | ?Default Behavior |
@@ -37,6 +38,7 @@ requestFieldHeader = """
 """
 
 responseFieldHeader = """
+
 **Response Fields:**
 
 | Name | Type  | Description |
@@ -44,6 +46,7 @@ responseFieldHeader = """
 """
 
 dataFieldHeader = """
+
 **Data Fields:**
 
 | Name | Type  | Description |
@@ -127,8 +130,6 @@ def get_enums(enums):
                 ret += '- Added in v{}\n'.format(enumIdentifier['initialVersion'])
             if enumIdentifier != enum['enumIdentifiers'][-1]:
                 ret += '\n---\n\n'
-            else:
-                ret += '\n'
     return ret
 
 def get_requests_toc(requests):
@@ -142,7 +143,7 @@ def get_requests_toc(requests):
         if not len(requestsOut):
             continue
         categoryFragment = get_fragment(category, False)
-        ret += '- [{} Requests](#{}-requests)\n'.format(category, categoryFragment)
+        ret += '- [{}](#{})\n'.format(category, categoryFragment)
         for request in requestsOut:
             requestType = request['requestType']
             requestTypeFragment = get_fragment(requestType, False)
@@ -160,7 +161,7 @@ def get_requests(requests):
         if not len(requestsOut):
             continue
         categoryFragment = get_fragment(category)
-        ret += '## {} Requests\n\n'.format(category)
+        ret += '\n\n## {}\n\n'.format(category)
         for request in requestsOut:
             requestType = request['requestType']
             requestTypeFragment = get_fragment(requestType)
@@ -192,8 +193,6 @@ def get_requests(requests):
 
             if request != requestsOut[-1]:
                 ret += '\n---\n\n'
-            else:
-                ret += '\n'
     return ret
 
 def get_events_toc(events):
@@ -207,7 +206,7 @@ def get_events_toc(events):
         if not len(eventsOut):
             continue
         categoryFragment = get_fragment(category, False)
-        ret += '- [{} Events](#{}-events)\n'.format(category, categoryFragment)
+        ret += '- [{}](#{})\n'.format(category, categoryFragment)
         for event in eventsOut:
             eventType = event['eventType']
             eventTypeFragment = get_fragment(eventType, False)
@@ -225,7 +224,7 @@ def get_events(events):
         if not len(eventsOut):
             continue
         categoryFragment = get_fragment(category)
-        ret += '## {} Events\n\n'.format(category)
+        ret += '## {}\n\n'.format(category)
         for event in eventsOut:
             eventType = event['eventType']
             eventTypeFragment = get_fragment(eventType)
@@ -248,8 +247,6 @@ def get_events(events):
 
             if event != eventsOut[-1]:
                 ret += '\n---\n\n'
-            else:
-                ret += '\n'
     return ret
 
 # Actual code
@@ -267,41 +264,40 @@ except IOError:
 with open('../generated/protocol.json', 'r') as f:
     protocol = json.load(f)
 
-output = "<!-- This file was automatically generated. Do not edit directly! -->\n"
+output = "<!-- This file was automatically generated. Do not edit directly! -->\n\n"
-output += "<!-- markdownlint-disable no-bare-urls -->\n"
 
 # Insert introduction partial
 output += read_file('partials/introduction.md')
 logging.info('Inserted introduction section.')
 
-output += '\n'
+output += '\n\n'
 
 # Generate enums MD
 output += read_file('partials/enumsHeader.md')
-output += '\n'
 output += get_enums_toc(protocol['enums'])
-output += '\n'
+output += '\n\n'
 output += get_enums(protocol['enums'])
 logging.info('Inserted enums section.')
 
+output += '\n\n'
+
 # Generate events MD
 output += read_file('partials/eventsHeader.md')
-output += '\n'
 output += get_events_toc(protocol['events'])
-output += '\n'
+output += '\n\n'
 output += get_events(protocol['events'])
 logging.info('Inserted events section.')
 
+output += '\n\n'
+
 # Generate requests MD
 output += read_file('partials/requestsHeader.md')
-output += '\n'
 output += get_requests_toc(protocol['requests'])
-output += '\n'
+output += '\n\n'
 output += get_requests(protocol['requests'])
 logging.info('Inserted requests section.')
 
-if output.endswith('\n\n'):
+output += '\n\n'
-    output = output[:-1]
 
 # Write new protocol MD
 with open('../generated/protocol.md', 'w') as f:

docs/docs/partials/enumsHeader.md

@@ -1,5 +1,4 @@
 # Enums
-
 These are enumeration declarations, which are referenced throughout obs-websocket's protocol.
 
-## Enumerations Table of Contents
+### Enumerations Table of Contents

docs/docs/partials/eventsHeader.md

@@ -1,3 +1,3 @@
 # Events
 
-## Events Table of Contents
+### Events Table of Contents

docs/docs/partials/introduction.md

@@ -1,31 +1,28 @@
+# Main Table of Contents
+- [obs-websocket 5.0.0 Protocol](#obs-websocket-500-protocol)
+  - [Connecting to obs-websocket](#connecting-to-obs-websocket)
+    - [Connection steps](#connection-steps)
+    - [Creating an authentication string](#creating-an-authentication-string)
+  - [Base message types](#message-types)
+    - [OpCode 0 Hello](#hello-opcode-0)
+    - [OpCode 1 Identify](#identify-opcode-1)
+    - [OpCode 2 Identified](#identified-opcode-2)
+    - [OpCode 3 Reidentify](#reidentify-opcode-3)
+    - [OpCode 5 Event](#event-opcode-5)
+    - [OpCode 6 Request](#request-opcode-6)
+    - [OpCode 7 RequestResponse](#requestresponse-opcode-7)
+    - [OpCode 8 RequestBatch](#requestbatch-opcode-8)
+    - [OpCode 9 RequestBatchResponse](#requestbatchresponse-opcode-9)
+- [Enums](#enums)
+- [Events](#events)
+- [Requests](#requests)
 
-# obs-websocket 5.0.1 Protocol
+# obs-websocket 5.0.0 Protocol
-
-## Main Table of Contents
-
-- [General Intro](#general-intro)
-  - [Design Goals](#design-goals)
-- [Connecting to obs-websocket](#connecting-to-obs-websocket)
-  - [Connection steps](#connection-steps)
-    - [Connection Notes](#connection-notes)
-  - [Creating an authentication string](#creating-an-authentication-string)
-- [Message Types (OpCodes)](#message-types-opcodes)
-  - [Hello (OpCode 0)](#hello-opcode-0)
-  - [Identify (OpCode 1)](#identify-opcode-1)
-  - [Identified (OpCode 2)](#identified-opcode-2)
-  - [Reidentify (OpCode 3)](#reidentify-opcode-3)
-  - [Event (OpCode 5)](#event-opcode-5)
-  - [Request (OpCode 6)](#request-opcode-6)
-  - [RequestResponse (OpCode 7)](#requestresponse-opcode-7)
-  - [RequestBatch (OpCode 8)](#requestbatch-opcode-8)
-  - [RequestBatchResponse (OpCode 9)](#requestbatchresponse-opcode-9)
 
 ## General Intro
-
 obs-websocket provides a feature-rich RPC communication protocol, giving access to much of OBS's feature set. This document contains everything you should know in order to make a connection and use obs-websocket's functionality to the fullest.
 
 ### Design Goals
-
 - Abstraction of identification, events, requests, and batch requests into dedicated message types
 - Conformity of request naming using similar terms like `Get`, `Set`, `Get[x]List`, `Start[x]`, `Toggle[x]`
 - Conformity of OBS data field names like `sourceName`, `sourceKind`, `sourceType`, `sceneName`, `sceneItemName`
@@ -34,14 +31,13 @@ obs-websocket provides a feature-rich RPC communication protocol, giving access
 - PubSub system - Allow clients to specify which events they do or don't want to receive from OBS
 - RPC versioning - Client and server negotiate the latest version of the obs-websocket protocol to communicate with.
 
-## Connecting to obs-websocket
 
+## Connecting to obs-websocket
 Here's info on how to connect to obs-websocket
 
 ---
 
 ### Connection steps
-
 These steps should be followed precisely. Failure to connect to the server as instructed will likely result in your client being treated in an undefined way.
 
 - Initial HTTP request made to the obs-websocket server.
@@ -68,7 +64,6 @@ These steps should be followed precisely. Failure to connect to the server as in
 - At any time after a client has been identified, it may send an [OpCode 3 `Reidentify`](#reidentify-opcode-3) message to update certain allowed session parameters. The server will respond in the same way it does during initial identification.
 
 #### Connection Notes
-
 - If a binary frame is received when using the `obswebsocket.json` (default) subprotocol, or a text frame is received while using the `obswebsocket.msgpack` subprotocol, the connection is closed with `WebSocketCloseCode::MessageDecodeError`.
 - The obs-websocket server listens for any messages containing a `request-type` field in the first level JSON from unidentified clients. If a message matches, the connection is closed with `WebSocketCloseCode::UnsupportedRpcVersion` and a warning is logged.
 - If a message with a `messageType` is not recognized to the obs-websocket server, the connection is closed with `WebSocketCloseCode::UnknownOpCode`.
@@ -77,13 +72,11 @@ These steps should be followed precisely. Failure to connect to the server as in
 ---
 
 ### Creating an authentication string
-
 obs-websocket uses SHA256 to transmit authentication credentials. The server starts by sending an object in the `authentication` field of its `Hello` message data. The client processes the authentication challenge and responds via the `authentication` string in the `Identify` message data.
 
 For this guide, we'll be using `supersecretpassword` as the password.
 
 The `authentication` object in `Hello` looks like this (example):
-
 ```json
 {
     "challenge": "+IxH4CnCiqpX1rM9scsNynZzbOe4KhDeYcTNS3PDaeY=",
@@ -92,7 +85,6 @@ The `authentication` object in `Hello` looks like this (example):
 ```
 
 To generate the authentication string, follow these steps:
-
 - Concatenate the websocket password with the `salt` provided by the server (`password + salt`)
 - Generate an SHA256 binary hash of the result and base64 encode it, known as a base64 secret.
 - Concatenate the base64 secret with the `challenge` sent by the server (`base64_secret + challenge`)
@@ -100,50 +92,44 @@ To generate the authentication string, follow these steps:
 
 For real-world examples of the `authentication` string creation, refer to the obs-websocket client libraries listed on the [README](README.md).
 
-## Message Types (OpCodes)
 
-The following message types are the low-level message types which may be sent to and from obs-websocket.
+## Message Types (OpCodes)
+The following message types are the low-level message types which may be sent to and from obs-websocket. 
 
 Messages sent from the obs-websocket server or client may contain these first-level fields, known as the base object:
-
+```
-```txt
 {
   "op": number,
   "d": object
 }
 ```
-
 - `op` is a `WebSocketOpCode` OpCode.
 - `d` is an object of the data fields associated with the operation.
 
 ---
 
 ### Hello (OpCode 0)
-
 - Sent from: obs-websocket
 - Sent to: Freshly connected websocket client
 - Description: First message sent from the server immediately on client connection. Contains authentication information if auth is required. Also contains RPC version for version negotiation.
 
 **Data Keys:**
-
+```
-```txt
 {
   "obsWebSocketVersion": string,
   "rpcVersion": number,
   "authentication": object(optional)
 }
 ```
-
 - `rpcVersion` is a version number which gets incremented on each **breaking change** to the obs-websocket protocol. Its usage in this context is to provide the current rpc version that the server would like to use.
 
 **Example Messages:**
 Authentication is required
-
 ```json
 {
   "op": 0,
   "d": {
-    "obsWebSocketVersion": "5.0.1",
+    "obsWebSocketVersion": "5.0.0",
     "rpcVersion": 1,
     "authentication": {
       "challenge": "+IxH4CnCiqpX1rM9scsNynZzbOe4KhDeYcTNS3PDaeY=",
@@ -154,12 +140,11 @@ Authentication is required
 ```
 
 Authentication is not required
-
 ```json
 {
   "op": 0,
   "d": {
-    "obsWebSocketVersion": "5.0.1",
+    "obsWebSocketVersion": "5.0.0",
     "rpcVersion": 1
   }
 }
@@ -168,26 +153,22 @@ Authentication is not required
 ---
 
 ### Identify (OpCode 1)
-
 - Sent from: Freshly connected websocket client
 - Sent to: obs-websocket
 - Description: Response to `Hello` message, should contain authentication string if authentication is required, along with PubSub subscriptions and other session parameters.
 
 **Data Keys:**
-
+```
-```txt
 {
   "rpcVersion": number,
   "authentication": string(optional),
   "eventSubscriptions": number(optional) = (EventSubscription::All)
 }
 ```
-
 - `rpcVersion` is the version number that the client would like the obs-websocket server to use.
 - `eventSubscriptions` is a bitmask of `EventSubscriptions` items to subscribe to events and event categories at will. By default, all event categories are subscribed, except for events marked as high volume. High volume events must be explicitly subscribed to.
 
 **Example Message:**
-
 ```json
 {
   "op": 1,
@@ -202,23 +183,19 @@ Authentication is not required
 ---
 
 ### Identified (OpCode 2)
-
 - Sent from: obs-websocket
 - Sent to: Freshly identified client
 - Description: The identify request was received and validated, and the connection is now ready for normal operation.
 
 **Data Keys:**
-
+```
-```txt
 {
   "negotiatedRpcVersion": number
 }
 ```
-
 - If rpc version negotiation succeeds, the server determines the RPC version to be used and gives it to the client as `negotiatedRpcVersion`
 
 **Example Message:**
-
 ```json
 {
   "op": 2,
@@ -231,43 +208,36 @@ Authentication is not required
 ---
 
 ### Reidentify (OpCode 3)
-
 - Sent from: Identified client
 - Sent to: obs-websocket
 - Description: Sent at any time after initial identification to update the provided session parameters.
 
 **Data Keys:**
-
+```
-```txt
 {
   "eventSubscriptions": number(optional) = (EventSubscription::All)
 }
 ```
-
 - Only the listed parameters may be changed after initial identification. To change a parameter not listed, you must reconnect to the obs-websocket server.
 
 ---
 
 ### Event (OpCode 5)
-
 - Sent from: obs-websocket
 - Sent to: All subscribed and identified clients
 - Description: An event coming from OBS has occured. Eg scene switched, source muted.
 
 **Data Keys:**
-
+```
-```txt
 {
   "eventType": string,
   "eventIntent": number,
   "eventData": object(optional)
 }
 ```
-
 - `eventIntent` is the original intent required to be subscribed to in order to receive the event.
 
 **Example Message:**
-
 ```json
 {
   "op": 5,
@@ -284,24 +254,21 @@ Authentication is not required
 ---
 
 ### Request (OpCode 6)
-
 - Sent from: Identified client
 - Sent to: obs-websocket
 - Description: Client is making a request to obs-websocket. Eg get current scene, create source.
 
 **Data Keys:**
-
+```
-```txt
 {
   "requestType": string,
   "requestId": string,
   "requestData": object(optional),
-
+  
 }
 ```
 
 **Example Message:**
-
 ```json
 {
   "op": 6,
@@ -318,14 +285,12 @@ Authentication is not required
 ---
 
 ### RequestResponse (OpCode 7)
-
 - Sent from: obs-websocket
 - Sent to: Identified client which made the request
 - Description: obs-websocket is responding to a request coming from a client.
 
 **Data Keys:**
-
+```
-```txt
 {
   "requestType": string,
   "requestId": string,
@@ -333,26 +298,22 @@ Authentication is not required
   "responseData": object(optional)
 }
 ```
-
 - The `requestType` and `requestId` are simply mirrors of what was sent by the client.
 
 `requestStatus` object:
-
+```
-```txt
 {
   "result": bool,
   "code": number,
   "comment": string(optional)
 }
 ```
-
 - `result` is `true` if the request resulted in `RequestStatus::Success`. False if otherwise.
 - `code` is a `RequestStatus` code.
 - `comment` may be provided by the server on errors to offer further details on why a request failed.
 
 **Example Messages:**
 Successful Response
-
 ```json
 {
   "op": 7,
@@ -368,7 +329,6 @@ Successful Response
 ```
 
 Failure Response
-
 ```json
 {
   "op": 7,
@@ -387,14 +347,12 @@ Failure Response
 ---
 
 ### RequestBatch (OpCode 8)
-
 - Sent from: Identified client
 - Sent to: obs-websocket
 - Description: Client is making a batch of requests for obs-websocket. Requests are processed serially (in order) by the server.
 
 **Data Keys:**
-
+```
-```txt
 {
   "requestId": string,
   "haltOnFailure": bool(optional) = false,
@@ -402,21 +360,18 @@ Failure Response
   "requests": array<object>
 }
 ```
-
 - When `haltOnFailure` is `true`, the processing of requests will be halted on first failure. Returns only the processed requests in [`RequestBatchResponse`](#requestbatchresponse-opcode-9).
 - Requests in the `requests` array follow the same structure as the `Request` payload data format, however `requestId` is an optional field.
 
 ---
 
 ### RequestBatchResponse (OpCode 9)
-
 - Sent from: obs-websocket
 - Sent to: Identified client which made the request
 - Description: obs-websocket is responding to a request batch coming from the client.
 
 **Data Keys:**
-
+```
-```txt
 {
   "requestId": string,
   "results": array<object>

docs/docs/partials/requestsHeader.md

@@ -1,3 +1,3 @@
 # Requests
 
-## Requests Table of Contents
+### Requests Table of Contents

installer/installer-windows.iss.in

@@ -1,74 +1,74 @@
-#define MyAppName "obs-websocket"
+#define MyAppName "obs-websocket"
-#define MyAppVersion "@OBS_WEBSOCKET_VERSION@"
+#define MyAppVersion "@OBS_WEBSOCKET_VERSION@"
-#define MyAppPublisher "OBS Project"
+#define MyAppPublisher "obs-websocket"
-#define MyAppURL "http://github.com/obsproject/obs-websocket"
+#define MyAppURL "http://github.com/obsproject/obs-websocket"
-
+
-[Setup]
+[Setup]
-; NOTE: The value of AppId uniquely identifies this application.
+; NOTE: The value of AppId uniquely identifies this application.
-; Do not use the same AppId value in installers for other applications.
+; Do not use the same AppId value in installers for other applications.
-; (To generate a new GUID, click Tools | Generate GUID inside the IDE.)
+; (To generate a new GUID, click Tools | Generate GUID inside the IDE.)
-AppId={{117EE44F-48E1-49E5-A381-CC8D9195CF35}
+AppId={{117EE44F-48E1-49E5-A381-CC8D9195CF35}
-AppName={#MyAppName}
+AppName={#MyAppName}
-AppVersion={#MyAppVersion}
+AppVersion={#MyAppVersion}
-AppPublisher={#MyAppPublisher}
+AppPublisher={#MyAppPublisher}
-AppPublisherURL={#MyAppURL}
+AppPublisherURL={#MyAppURL}
-AppSupportURL={#MyAppURL}
+AppSupportURL={#MyAppURL}
-AppUpdatesURL={#MyAppURL}
+AppUpdatesURL={#MyAppURL}
-DefaultDirName={code:GetDirName}
+DefaultDirName={code:GetDirName}
-DefaultGroupName={#MyAppName}
+DefaultGroupName={#MyAppName}
-OutputBaseFilename=obs-websocket-{#MyAppVersion}-Windows-Installer
+OutputBaseFilename=obs-websocket-{#MyAppVersion}-Windows-Installer
-Compression=lzma
+Compression=lzma
-SolidCompression=yes
+SolidCompression=yes
-DirExistsWarning=no
+DirExistsWarning=no
-
+
-[Languages]
+[Languages]
-Name: "english"; MessagesFile: "compiler:Default.isl"
+Name: "english"; MessagesFile: "compiler:Default.isl"
-
+
-[Files]
+[Files]
-Source: "..\release\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs
+Source: "..\release\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs
-Source: "..\LICENSE"; Flags: dontcopy
+Source: "..\LICENSE"; Flags: dontcopy
-; NOTE: Don't use "Flags: ignoreversion" on any shared system files
+; NOTE: Don't use "Flags: ignoreversion" on any shared system files
-
+
-[Icons]
+[Icons]
-Name: "{group}\{cm:ProgramOnTheWeb,{#MyAppName}}"; Filename: "{#MyAppURL}"
+Name: "{group}\{cm:ProgramOnTheWeb,{#MyAppName}}"; Filename: "{#MyAppURL}"
-Name: "{group}\{cm:UninstallProgram,{#MyAppName}}"; Filename: "{uninstallexe}"
+Name: "{group}\{cm:UninstallProgram,{#MyAppName}}"; Filename: "{uninstallexe}"
-
+
-[Code]
+[Code]
-procedure InitializeWizard();
+procedure InitializeWizard();
-var
+var
-  GPLText: AnsiString;
+  GPLText: AnsiString;
-  Page: TOutputMsgMemoWizardPage;
+  Page: TOutputMsgMemoWizardPage;
-begin
+begin
-  ExtractTemporaryFile('LICENSE');
+  ExtractTemporaryFile('LICENSE');
-  LoadStringFromFile(ExpandConstant('{tmp}\LICENSE'), GPLText);
+  LoadStringFromFile(ExpandConstant('{tmp}\LICENSE'), GPLText);
-  Page := CreateOutputMsgMemoPage(wpWelcome,
+  Page := CreateOutputMsgMemoPage(wpWelcome,
-    'License Information', 'Please review the license terms before installing obs-websocket',
+    'License Information', 'Please review the license terms before installing obs-websocket',
-    'Press Page Down to see the rest of the agreement. Once you are aware of your rights, click Next to continue.',
+    'Press Page Down to see the rest of the agreement. Once you are aware of your rights, click Next to continue.',
-    String(GPLText)
+    String(GPLText)
-  );
+  );
-end;
+end;
-
+
-// Validate that obs-studio is installed before installing the plugin
+// Validate that obs-studio is installed before installing the plugin
-function PrepareToInstall(var NeedsRestart: Boolean): String;
+function PrepareToInstall(var NeedsRestart: Boolean): String;
-begin
+begin
-  Result := '';
+  Result := '';
-
+
-  if not DirExists(ExpandConstant('{app}\obs-plugins')) then
+  if not DirExists(ExpandConstant('{app}\obs-plugins')) then
-  begin
+  begin
-    Result := 'The selected install directory does not appear to be valid. Please install OBS Studio before installing {#MyAppName} or correct your install path.';
+    Result := 'The selected install directory does not appear to be valid. Please install OBS Studio before installing {#MyAppName} or correct your install path.';
-  end;
+  end;
-end;
+end;
-
+
-// credit where it's due :
+// credit where it's due :
-// following function come from https://github.com/Xaymar/obs-studio_amf-encoder-plugin/blob/master/%23Resources/Installer.in.iss#L45
+// following function come from https://github.com/Xaymar/obs-studio_amf-encoder-plugin/blob/master/%23Resources/Installer.in.iss#L45
-function GetDirName(Value: string): string;
+function GetDirName(Value: string): string;
-var
+var
-  InstallPath: string;
+  InstallPath: string;
-begin
+begin
-  // initialize default path, which will be returned when the following registry
+  // initialize default path, which will be returned when the following registry
-  // key queries fail due to missing keys or for some different reason
+  // key queries fail due to missing keys or for some different reason
-  Result := '{commonpf}\obs-studio';
+  Result := '{commonpf}\obs-studio';
-  // query the first registry value; if this succeeds, return the obtained value
+  // query the first registry value; if this succeeds, return the obtained value
-  if RegQueryStringValue(HKLM32, 'SOFTWARE\OBS Studio', '', InstallPath) then
+  if RegQueryStringValue(HKLM32, 'SOFTWARE\OBS Studio', '', InstallPath) then
-    Result := InstallPath
+    Result := InstallPath
-end;
+end;

lib/example/simplest-plugin.c

@@ -1,79 +1,40 @@
-/*
+#include <obs-module.h>
-obs-websocket
+
-Copyright (C) 2020-2021 Kyle Manning <tt2468@gmail.com>
+#include "../obs-websocket-api.h"
-
+
-This program is free software; you can redistribute it and/or modify
+OBS_DECLARE_MODULE()
-it under the terms of the GNU General Public License as published by
+OBS_MODULE_USE_DEFAULT_LOCALE(PLUGIN_NAME, "en-US")
-the Free Software Foundation; either version 2 of the License, or
+
-(at your option) any later version.
+obs_websocket_vendor vendor;
-
+
-This program is distributed in the hope that it will be useful,
+bool obs_module_load(void)
-but WITHOUT ANY WARRANTY; without even the implied warranty of
+{
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    blog(LOG_INFO, "Example obs-websocket-api plugin loaded!");
-GNU General Public License for more details.
+    return true;
-
+}
-You should have received a copy of the GNU General Public License along
+
-with this program. If not, see <https://www.gnu.org/licenses/>
+void example_request_cb(obs_data_t *request_data, obs_data_t *response_data, void *priv_data);
-*/
+void obs_module_post_load(void)
-
+{
-// Similar example code can be found in ../../src/obs-websocket.cpp
+	vendor = obs_websocket_register_vendor("api_example_plugin");
-// You can test that sample code by specifying -DPLUGIN_TESTS=TRUE
+	if (!vendor) {
-
+		blog(LOG_ERROR, "Vendor registration failed! (obs-websocket should have logged something if installed properly.)");
-#include <obs-module.h>
+		return;
-
+	}
-#include "../obs-websocket-api.h"
+
-
+	if (!obs_websocket_vendor_register_request(vendor, "example_request", example_request_cb, NULL))
-OBS_DECLARE_MODULE()
+		blog(LOG_ERROR, "Failed to register `example_request` request with obs-websocket.");
-OBS_MODULE_USE_DEFAULT_LOCALE(PLUGIN_NAME, "en-US")
+}
-
+
-obs_websocket_vendor vendor;
+void obs_module_unload(void)
-
+{
-bool obs_module_load(void)
+	blog(LOG_INFO, "Example obs-websocket-api plugin unloaded!");
-{
+}
-	blog(LOG_INFO, "Example obs-websocket-api plugin loaded!");
+
-	return true;
+void example_request_cb(obs_data_t *request_data, obs_data_t *response_data, void *priv_data)
-}
+{
-
+	if (obs_data_has_user_value(request_data, "ping"))
-void example_request_cb(obs_data_t *request_data, obs_data_t *response_data, void *priv_data);
+		obs_data_set_bool(response_data, "pong", true);
-void obs_module_post_load(void)
+
-{
+	UNUSED_PARAMETER(priv_data);
-	vendor = obs_websocket_register_vendor("api_example_plugin");
+}
-	if (!vendor) {
-		blog(LOG_ERROR, "Vendor registration failed! (obs-websocket should have logged something if installed properly.)");
-		return;
-	}
-
-	if (!obs_websocket_vendor_register_request(vendor, "example_request", example_request_cb, NULL))
-		blog(LOG_ERROR, "Failed to register `example_request` request with obs-websocket.");
-
-	uint api_version = obs_websocket_get_api_version();
-	if (api_version == 0) {
-		blog(LOG_ERROR, "Unable to fetch obs-websocket plugin API version.");
-		return;
-	} else if (api_version == 1) {
-		blog(LOG_WARNING, "Unsupported obs-websocket plugin API version for calling requests.");
-		return;
-	}
-
-	struct obs_websocket_request_response *response = obs_websocket_call_request("GetVersion");
-	if (!response) {
-		blog(LOG_ERROR, "Failed to call GetVersion due to obs-websocket not being installed.");
-		return;
-	}
-	blog(LOG_INFO, "[obs_module_post_load] Called GetVersion. Status Code: %u | Comment: %s | Response Data: %s",
-	     response->status_code, response->comment, response->response_data);
-	obs_websocket_request_response_free(response);
-}
-
-void obs_module_unload(void)
-{
-	blog(LOG_INFO, "Example obs-websocket-api plugin unloaded!");
-}
-
-void example_request_cb(obs_data_t *request_data, obs_data_t *response_data, void *priv_data)
-{
-	if (obs_data_has_user_value(request_data, "ping"))
-		obs_data_set_bool(response_data, "pong", true);
-
-	UNUSED_PARAMETER(priv_data);
-}

lib/obs-websocket-api.h

@@ -1,216 +1,133 @@
-/*
+/*
-obs-websocket
+obs-websocket
-Copyright (C) 2016-2021 Stephane Lepin <stephane.lepin@gmail.com>
+Copyright (C) 2016-2021 Stephane Lepin <stephane.lepin@gmail.com>
-Copyright (C) 2020-2022 Kyle Manning <tt2468@gmail.com>
+Copyright (C) 2020-2021 Kyle Manning <tt2468@gmail.com>
-
+
-This program is free software; you can redistribute it and/or modify
+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
+it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
+the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+(at your option) any later version.
-
+
-This program is distributed in the hope that it will be useful,
+This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
+but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+GNU General Public License for more details.
-
+
-You should have received a copy of the GNU General Public License along
+You should have received a copy of the GNU General Public License along
-with this program. If not, see <https://www.gnu.org/licenses/>
+with this program. If not, see <https://www.gnu.org/licenses/>
-*/
+*/
-
+
-#ifndef _OBS_WEBSOCKET_API_H
+#ifndef _OBS_WEBSOCKET_API_H
-#define _OBS_WEBSOCKET_API_H
+#define _OBS_WEBSOCKET_API_H
-
+
-#include <obs.h>
+#include <obs.h>
-
+
-#define OBS_WEBSOCKET_API_VERSION 2
+#ifdef __cplusplus
-
+extern "C" {
-#ifdef __cplusplus
+#endif
-extern "C" {
+
-#endif
+typedef void* obs_websocket_vendor;
-
+typedef void (*obs_websocket_request_callback_function)(obs_data_t*, obs_data_t*, void*);
-typedef void *obs_websocket_vendor;
+
-typedef void (*obs_websocket_request_callback_function)(obs_data_t *, obs_data_t *, void *);
+struct obs_websocket_request_callback {
-
+	obs_websocket_request_callback_function callback;
-struct obs_websocket_request_response {
+	void *priv_data;
-	unsigned int status_code;
+};
-	char *comment;
+
-	char *response_data; // JSON string, because obs_data_t* only supports array<object>, so conversions would break API.
+inline proc_handler_t *ph;
-};
+
-
+static inline proc_handler_t *obs_websocket_get_ph(void)
-/* ==================== INTERNAL DEFINITIONS ==================== */
+{
-
+	proc_handler_t *global_ph = obs_get_proc_handler();
-struct obs_websocket_request_callback {
+	assert(global_ph != NULL);
-	obs_websocket_request_callback_function callback;
+
-	void *priv_data;
+	calldata_t cd = {0};
-};
+	if (!proc_handler_call(global_ph, "obs_websocket_api_get_ph", &cd))
-
+		blog(LOG_DEBUG, "Unable to fetch obs-websocket proc handler object. obs-websocket not installed?");
-inline proc_handler_t *_ph;
+	proc_handler_t *ret = (proc_handler_t*)calldata_ptr(&cd, "ph");
-
+	calldata_free(&cd);
-/* ==================== INTERNAL API FUNCTIONS ==================== */
+
-
+	return ret;
-static inline proc_handler_t *obs_websocket_get_ph(void)
+}
-{
+
-	proc_handler_t *global_ph = obs_get_proc_handler();
+static inline bool obs_websocket_run_simple_proc(obs_websocket_vendor vendor, const char *proc_name, calldata_t *cd)
-	assert(global_ph != NULL);
+{
-
+	if (!ph || !vendor || !proc_name || !strlen(proc_name) || !cd)
-	calldata_t cd = {0};
+		return false;
-	if (!proc_handler_call(global_ph, "obs_websocket_api_get_ph", &cd))
+
-		blog(LOG_DEBUG, "Unable to fetch obs-websocket proc handler object. obs-websocket not installed?");
+	calldata_set_ptr(cd, "vendor", vendor);
-	proc_handler_t *ret = (proc_handler_t *)calldata_ptr(&cd, "ph");
+
-	calldata_free(&cd);
+	proc_handler_call(ph, proc_name, cd);
-
+	return calldata_bool(cd, "success");
-	return ret;
+}
-}
+
-
+// ALWAYS CALL VIA `obs_module_post_load()` CALLBACK!
-static inline bool obs_websocket_ensure_ph(void)
+// Registers a new "vendor" (Example: obs-ndi)
-{
+static inline obs_websocket_vendor obs_websocket_register_vendor(const char *vendor_name)
-	if (!_ph)
+{
-		_ph = obs_websocket_get_ph();
+	ph = obs_websocket_get_ph();
-	return _ph != NULL;
+	if (!ph)
-}
+		return NULL;
-
+
-static inline bool obs_websocket_vendor_run_simple_proc(obs_websocket_vendor vendor, const char *proc_name, calldata_t *cd)
+	calldata_t cd = {0};
-{
+
-	if (!obs_websocket_ensure_ph())
+	calldata_set_string(&cd, "name", vendor_name);
-		return false;
+
-
+	proc_handler_call(ph, "vendor_register", &cd);
-	if (!vendor || !proc_name || !strlen(proc_name) || !cd)
+	obs_websocket_vendor ret = calldata_ptr(&cd, "vendor");
-		return false;
+	calldata_free(&cd);
-
+
-	calldata_set_ptr(cd, "vendor", vendor);
+	return ret;
-
+}
-	proc_handler_call(_ph, proc_name, cd);
+
-	return calldata_bool(cd, "success");
+// Registers a new request for a vendor
-}
+static inline bool obs_websocket_vendor_register_request(obs_websocket_vendor vendor, const char *request_type, obs_websocket_request_callback_function request_callback, void* priv_data)
-
+{
-/* ==================== GENERAL API FUNCTIONS ==================== */
+	calldata_t cd = {0};
-
+
-// Gets the API version built with the obs-websocket plugin
+	struct obs_websocket_request_callback cb = {};
-static inline unsigned int obs_websocket_get_api_version(void)
+	cb.callback = request_callback;
-{
+	cb.priv_data = priv_data;
-	if (!obs_websocket_ensure_ph())
+
-		return 0;
+	calldata_set_string(&cd, "type", request_type);
-
+	calldata_set_ptr(&cd, "callback", &cb);
-	calldata_t cd = {0};
+
-
+	bool success = obs_websocket_run_simple_proc(vendor, "vendor_request_register", &cd);
-	if (!proc_handler_call(_ph, "get_api_version", &cd))
+	calldata_free(&cd);
-		return 1; // API v1 does not include get_api_version
+
-
+	return success;
-	unsigned int ret = calldata_int(&cd, "version");
+}
-
+
-	calldata_free(&cd);
+// Unregisters an existing vendor request
-
+static inline bool obs_websocket_vendor_unregister_request(obs_websocket_vendor vendor, const char *request_type)
-	return ret;
+{
-}
+	calldata_t cd = {0};
-
+
-// Calls an obs-websocket request. Free response with `obs_websocket_request_response_free()`
+	calldata_set_string(&cd, "type", request_type);
-static inline obs_websocket_request_response *obs_websocket_call_request(const char *request_type, obs_data_t *request_data = NULL)
+
-{
+	bool success = obs_websocket_run_simple_proc(vendor, "vendor_request_unregister", &cd);
-	if (!obs_websocket_ensure_ph())
+	calldata_free(&cd);
-		return NULL;
+
-
+	return success;
-	const char *request_data_string = NULL;
+}
-	if (request_data)
+
-		request_data_string = obs_data_get_json(request_data);
+// Does not affect event_data refcount.
-
+// Emits an event under the vendor's name
-	calldata_t cd = {0};
+static inline bool obs_websocket_vendor_emit_event(obs_websocket_vendor vendor, const char *event_name, obs_data_t *event_data)
-
+{
-	calldata_set_string(&cd, "request_type", request_type);
+	calldata_t cd = {0};
-	calldata_set_string(&cd, "request_data", request_data_string);
+
-
+	calldata_set_string(&cd, "type", event_name);
-	proc_handler_call(_ph, "call_request", &cd);
+	calldata_set_ptr(&cd, "data", (void*)event_data);
-
+
-	auto ret = (struct obs_websocket_request_response *)calldata_ptr(&cd, "response");
+	bool success = obs_websocket_run_simple_proc(vendor, "vendor_event_emit", &cd);
-
+	calldata_free(&cd);
-	calldata_free(&cd);
+
-
+	return success;
-	return ret;
+}
-}
+
-
+#ifdef __cplusplus
-// Free a request response object returned by `obs_websocket_call_request()`
+}
-static inline void obs_websocket_request_response_free(struct obs_websocket_request_response *response)
+#endif
-{
+
-	if (!response)
+#endif
-		return;
-
-	if (response->comment)
-		bfree(response->comment);
-	if (response->response_data)
-		bfree(response->response_data);
-	bfree(response);
-}
-
-/* ==================== VENDOR API FUNCTIONS ==================== */
-
-// ALWAYS CALL ONLY VIA `obs_module_post_load()` CALLBACK!
-// Registers a new "vendor" (Example: obs-ndi)
-static inline obs_websocket_vendor obs_websocket_register_vendor(const char *vendor_name)
-{
-	if (!obs_websocket_ensure_ph())
-		return NULL;
-
-	calldata_t cd = {0};
-
-	calldata_set_string(&cd, "name", vendor_name);
-
-	proc_handler_call(_ph, "vendor_register", &cd);
-	obs_websocket_vendor ret = calldata_ptr(&cd, "vendor");
-	calldata_free(&cd);
-
-	return ret;
-}
-
-// Registers a new request for a vendor
-static inline bool obs_websocket_vendor_register_request(obs_websocket_vendor vendor, const char *request_type,
-							 obs_websocket_request_callback_function request_callback, void *priv_data)
-{
-	calldata_t cd = {0};
-
-	struct obs_websocket_request_callback cb = {};
-	cb.callback = request_callback;
-	cb.priv_data = priv_data;
-
-	calldata_set_string(&cd, "type", request_type);
-	calldata_set_ptr(&cd, "callback", &cb);
-
-	bool success = obs_websocket_vendor_run_simple_proc(vendor, "vendor_request_register", &cd);
-	calldata_free(&cd);
-
-	return success;
-}
-
-// Unregisters an existing vendor request
-static inline bool obs_websocket_vendor_unregister_request(obs_websocket_vendor vendor, const char *request_type)
-{
-	calldata_t cd = {0};
-
-	calldata_set_string(&cd, "type", request_type);
-
-	bool success = obs_websocket_vendor_run_simple_proc(vendor, "vendor_request_unregister", &cd);
-	calldata_free(&cd);
-
-	return success;
-}
-
-// Does not affect event_data refcount.
-// Emits an event under the vendor's name
-static inline bool obs_websocket_vendor_emit_event(obs_websocket_vendor vendor, const char *event_name, obs_data_t *event_data)
-{
-	calldata_t cd = {0};
-
-	calldata_set_string(&cd, "type", event_name);
-	calldata_set_ptr(&cd, "data", (void *)event_data);
-
-	bool success = obs_websocket_vendor_run_simple_proc(vendor, "vendor_event_emit", &cd);
-	calldata_free(&cd);
-
-	return success;
-}
-
-/* ==================== END API FUNCTIONS ==================== */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/Config.cpp

@@ -33,28 +33,26 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #define PARAM_PASSWORD "ServerPassword"
 
 #define CMDLINE_WEBSOCKET_PORT "websocket_port"
-#define CMDLINE_WEBSOCKET_IPV4_ONLY "websocket_ipv4_only"
 #define CMDLINE_WEBSOCKET_PASSWORD "websocket_password"
 #define CMDLINE_WEBSOCKET_DEBUG "websocket_debug"
 
-Config::Config()
+Config::Config() :
-	: PortOverridden(false),
+	PortOverridden(false),
-	  PasswordOverridden(false),
+	PasswordOverridden(false),
-	  FirstLoad(true),
+	FirstLoad(true),
-	  ServerEnabled(true),
+	ServerEnabled(true),
-	  ServerPort(4455),
+	ServerPort(4444),
-	  Ipv4Only(false),
+	DebugEnabled(false),
-	  DebugEnabled(false),
+	AlertsEnabled(false),
-	  AlertsEnabled(false),
+	AuthRequired(true),
-	  AuthRequired(true),
+	ServerPassword("")
-	  ServerPassword("")
 {
 	SetDefaultsToGlobalStore();
 }
 
 void Config::Load()
 {
-	config_t *obsConfig = GetConfigStore();
+	config_t* obsConfig = GetConfigStore();
 	if (!obsConfig) {
 		blog(LOG_ERROR, "[Config::Load] Unable to fetch OBS config!");
 		return;
@@ -95,12 +93,6 @@ void Config::Load()
 		}
 	}
 
-	// Process `--websocket_ipv4_only` override
-	if (Utils::Platform::GetCommandLineFlagSet(CMDLINE_WEBSOCKET_IPV4_ONLY)) {
-		blog(LOG_INFO, "[Config::Load] --websocket_ipv4_only passed. Binding only to IPv4 interfaces.");
-		Ipv4Only = true;
-	}
-
 	// Process `--websocket_password` override
 	QString passwordArgument = Utils::Platform::GetCommandLineArgument(CMDLINE_WEBSOCKET_PASSWORD);
 	if (passwordArgument != "") {
@@ -120,7 +112,7 @@ void Config::Load()
 
 void Config::Save()
 {
-	config_t *obsConfig = GetConfigStore();
+	config_t* obsConfig = GetConfigStore();
 	if (!obsConfig) {
 		blog(LOG_ERROR, "[Config::Save] Unable to fetch OBS config!");
 		return;
@@ -142,7 +134,7 @@ void Config::Save()
 
 void Config::SetDefaultsToGlobalStore()
 {
-	config_t *obsConfig = GetConfigStore();
+	config_t* obsConfig = GetConfigStore();
 	if (!obsConfig) {
 		blog(LOG_ERROR, "[Config::SetDefaultsToGlobalStore] Unable to fetch OBS config!");
 		return;
@@ -156,7 +148,7 @@ void Config::SetDefaultsToGlobalStore()
 	config_set_default_string(obsConfig, CONFIG_SECTION_NAME, PARAM_PASSWORD, QT_TO_UTF8(ServerPassword));
 }
 
-config_t *Config::GetConfigStore()
+config_t* Config::GetConfigStore()
 {
 	return obs_frontend_get_global_config();
 }

src/Config.h

@@ -30,7 +30,7 @@ struct Config {
 	void Load();
 	void Save();
 	void SetDefaultsToGlobalStore();
-	config_t *GetConfigStore();
+	config_t* GetConfigStore();
 
 	std::atomic<bool> PortOverridden;
 	std::atomic<bool> PasswordOverridden;
@@ -38,7 +38,6 @@ struct Config {
 	std::atomic<bool> FirstLoad;
 	std::atomic<bool> ServerEnabled;
 	std::atomic<uint16_t> ServerPort;
-	std::atomic<bool> Ipv4Only;
 	std::atomic<bool> DebugEnabled;
 	std::atomic<bool> AlertsEnabled;
 	std::atomic<bool> AuthRequired;

src/WebSocketApi.cpp

@@ -1,13 +1,7 @@
 #include "WebSocketApi.h"
-#include "requesthandler/RequestHandler.h"
 #include "obs-websocket.h"
-#include "utils/Json.h"
 
-#define RETURN_STATUS(status)                             \
+#define RETURN_STATUS(status) { calldata_set_bool(cd, "success", status); return; }
-	{                                                 \
-		calldata_set_bool(cd, "success", status); \
-		return;                                   \
-	}
 #define RETURN_SUCCESS() RETURN_STATUS(true);
 #define RETURN_FAILURE() RETURN_STATUS(false);
 
@@ -19,7 +13,7 @@ WebSocketApi::Vendor *get_vendor(calldata_t *cd)
 		return nullptr;
 	}
 
-	return static_cast<WebSocketApi::Vendor *>(voidVendor);
+	return static_cast<WebSocketApi::Vendor*>(voidVendor);
 }
 
 WebSocketApi::WebSocketApi()
@@ -28,16 +22,10 @@ WebSocketApi::WebSocketApi()
 
 	_procHandler = proc_handler_create();
 
-	proc_handler_add(_procHandler, "bool get_api_version(out int version)", &get_api_version, nullptr);
-	proc_handler_add(_procHandler, "bool call_request(in string request_type, in string request_data, out ptr response)",
-			 &call_request, nullptr);
 	proc_handler_add(_procHandler, "bool vendor_register(in string name, out ptr vendor)", &vendor_register_cb, this);
-	proc_handler_add(_procHandler, "bool vendor_request_register(in ptr vendor, in string type, in ptr callback)",
+	proc_handler_add(_procHandler, "bool vendor_request_register(in ptr vendor, in string type, in ptr callback)", &vendor_request_register_cb, this);
-			 &vendor_request_register_cb, this);
+	proc_handler_add(_procHandler, "bool vendor_request_unregister(in ptr vendor, in string type)", &vendor_request_unregister_cb, this);
-	proc_handler_add(_procHandler, "bool vendor_request_unregister(in ptr vendor, in string type)",
+	proc_handler_add(_procHandler, "bool vendor_event_emit(in ptr vendor, in string type, in ptr data)", &vendor_event_emit_cb, this);
-			 &vendor_request_unregister_cb, this);
-	proc_handler_add(_procHandler, "bool vendor_event_emit(in ptr vendor, in string type, in ptr data)", &vendor_event_emit_cb,
-			 this);
 
 	proc_handler_t *ph = obs_get_proc_handler();
 	assert(ph != NULL);
@@ -66,8 +54,7 @@ void WebSocketApi::SetEventCallback(EventCallback cb)
 	_eventCallback = cb;
 }
 
-enum WebSocketApi::RequestReturnCode WebSocketApi::PerformVendorRequest(std::string vendorName, std::string requestType,
+enum WebSocketApi::RequestReturnCode WebSocketApi::PerformVendorRequest(std::string vendorName, std::string requestType, obs_data_t *requestData, obs_data_t *responseData)
-									obs_data_t *requestData, obs_data_t *responseData)
 {
 	std::shared_lock l(_mutex);
 
@@ -94,59 +81,16 @@ enum WebSocketApi::RequestReturnCode WebSocketApi::PerformVendorRequest(std::str
 
 void WebSocketApi::get_ph_cb(void *priv_data, calldata_t *cd)
 {
-	auto c = static_cast<WebSocketApi *>(priv_data);
+	auto c = static_cast<WebSocketApi*>(priv_data);
 
-	calldata_set_ptr(cd, "ph", (void *)c->_procHandler);
+	calldata_set_ptr(cd, "ph", (void*)c->_procHandler);
-
-	RETURN_SUCCESS();
-}
-
-void WebSocketApi::get_api_version(void *, calldata_t *cd)
-{
-	calldata_set_int(cd, "version", OBS_WEBSOCKET_API_VERSION);
-
-	RETURN_SUCCESS();
-}
-
-void WebSocketApi::call_request(void *, calldata_t *cd)
-{
-	const char *request_type = calldata_string(cd, "request_type");
-	const char *request_data = calldata_string(cd, "request_data");
-
-	if (!request_type)
-		RETURN_FAILURE();
-
-	auto response = static_cast<obs_websocket_request_response *>(bzalloc(sizeof(struct obs_websocket_request_response)));
-	if (!response)
-		RETURN_FAILURE();
-
-	json requestData;
-	if (request_data)
-		requestData = json::parse(request_data);
-
-	RequestHandler requestHandler;
-	Request request(request_type, requestData);
-	RequestResult requestResult = requestHandler.ProcessRequest(request);
-
-	response->status_code = (unsigned int)requestResult.StatusCode;
-	if (!requestResult.Comment.empty())
-		response->comment = bstrdup(requestResult.Comment.c_str());
-	if (requestResult.ResponseData.is_object()) {
-		std::string responseData = requestResult.ResponseData.dump();
-		response->response_data = bstrdup(responseData.c_str());
-	}
-
-	calldata_set_ptr(cd, "response", response);
-
-	blog_debug("[WebSocketApi::call_request] Request %s called, response status code is %u", request_type,
-		   response->status_code);
 
 	RETURN_SUCCESS();
 }
 
 void WebSocketApi::vendor_register_cb(void *priv_data, calldata_t *cd)
 {
-	auto c = static_cast<WebSocketApi *>(priv_data);
+	auto c = static_cast<WebSocketApi*>(priv_data);
 
 	const char *vendorName;
 	if (!calldata_get_string(cd, "name", &vendorName) || strlen(vendorName) == 0) {
@@ -158,19 +102,18 @@ void WebSocketApi::vendor_register_cb(void *priv_data, calldata_t *cd)
 	std::unique_lock l(c->_mutex);
 
 	if (c->_vendors.count(vendorName)) {
-		blog(LOG_WARNING, "[WebSocketApi::vendor_register_cb] Failed because `%s` is already a registered vendor.",
+		blog(LOG_WARNING, "[WebSocketApi::vendor_register_cb] Failed because `%s` is already a registered vendor.", vendorName);
-		     vendorName);
 		RETURN_FAILURE();
 	}
 
-	Vendor *v = new Vendor();
+	Vendor* v = new Vendor();
 	v->_name = vendorName;
 
 	c->_vendors[vendorName] = v;
 
 	blog_debug("[WebSocketApi::vendor_register_cb] [vendorName: %s] Registered new vendor.", v->_name.c_str());
 
-	calldata_set_ptr(cd, "vendor", static_cast<void *>(v));
+	calldata_set_ptr(cd, "vendor", static_cast<void*>(v));
 
 	RETURN_SUCCESS();
 }
@@ -183,35 +126,28 @@ void WebSocketApi::vendor_request_register_cb(void *, calldata_t *cd)
 
 	const char *requestType;
 	if (!calldata_get_string(cd, "type", &requestType) || strlen(requestType) == 0) {
-		blog(LOG_WARNING,
+		blog(LOG_WARNING, "[WebSocketApi::vendor_request_register_cb] [vendorName: %s] Failed due to missing or empty `type` string.", v->_name.c_str());
-		     "[WebSocketApi::vendor_request_register_cb] [vendorName: %s] Failed due to missing or empty `type` string.",
-		     v->_name.c_str());
 		RETURN_FAILURE();
 	}
 
 	void *voidCallback;
 	if (!calldata_get_ptr(cd, "callback", &voidCallback) || !voidCallback) {
-		blog(LOG_WARNING,
+		blog(LOG_WARNING, "[WebSocketApi::vendor_request_register_cb] [vendorName: %s] Failed due to missing `callback` pointer.", v->_name.c_str());
-		     "[WebSocketApi::vendor_request_register_cb] [vendorName: %s] Failed due to missing `callback` pointer.",
-		     v->_name.c_str());
 		RETURN_FAILURE();
 	}
 
-	auto cb = static_cast<obs_websocket_request_callback *>(voidCallback);
+	auto cb = static_cast<obs_websocket_request_callback*>(voidCallback);
 
 	std::unique_lock l(v->_mutex);
 
 	if (v->_requests.count(requestType)) {
-		blog(LOG_WARNING,
+		blog(LOG_WARNING, "[WebSocketApi::vendor_request_register_cb] [vendorName: %s] Failed because `%s` is already a registered request.", v->_name.c_str(), requestType);
-		     "[WebSocketApi::vendor_request_register_cb] [vendorName: %s] Failed because `%s` is already a registered request.",
-		     v->_name.c_str(), requestType);
 		RETURN_FAILURE();
 	}
 
 	v->_requests[requestType] = *cb;
 
-	blog_debug("[WebSocketApi::vendor_request_register_cb] [vendorName: %s] Registered new vendor request: %s",
+	blog_debug("[WebSocketApi::vendor_request_register_cb] [vendorName: %s] Registered new vendor request: %s", v->_name.c_str(), requestType);
-		   v->_name.c_str(), requestType);
 
 	RETURN_SUCCESS();
 }
@@ -224,32 +160,27 @@ void WebSocketApi::vendor_request_unregister_cb(void *, calldata_t *cd)
 
 	const char *requestType;
 	if (!calldata_get_string(cd, "type", &requestType) || strlen(requestType) == 0) {
-		blog(LOG_WARNING,
+		blog(LOG_WARNING, "[WebSocketApi::vendor_request_unregister_cb] [vendorName: %s] Failed due to missing `type` string.", v->_name.c_str());
-		     "[WebSocketApi::vendor_request_unregister_cb] [vendorName: %s] Failed due to missing `type` string.",
-		     v->_name.c_str());
 		RETURN_FAILURE();
 	}
 
 	std::unique_lock l(v->_mutex);
 
 	if (!v->_requests.count(requestType)) {
-		blog(LOG_WARNING,
+		blog(LOG_WARNING, "[WebSocketApi::vendor_request_register_cb] [vendorName: %s] Failed because `%s` is not a registered request.", v->_name.c_str(), requestType);
-		     "[WebSocketApi::vendor_request_register_cb] [vendorName: %s] Failed because `%s` is not a registered request.",
-		     v->_name.c_str(), requestType);
 		RETURN_FAILURE();
 	}
 
 	v->_requests.erase(requestType);
 
-	blog_debug("[WebSocketApi::vendor_request_unregister_cb] [vendorName: %s] Unregistered vendor request: %s",
+	blog_debug("[WebSocketApi::vendor_request_unregister_cb] [vendorName: %s] Unregistered vendor request: %s", v->_name.c_str(), requestType);
-		   v->_name.c_str(), requestType);
 
 	RETURN_SUCCESS();
 }
 
 void WebSocketApi::vendor_event_emit_cb(void *priv_data, calldata_t *cd)
 {
-	auto c = static_cast<WebSocketApi *>(priv_data);
+	auto c = static_cast<WebSocketApi*>(priv_data);
 
 	Vendor *v = get_vendor(cd);
 	if (!v)
@@ -257,19 +188,17 @@ void WebSocketApi::vendor_event_emit_cb(void *priv_data, calldata_t *cd)
 
 	const char *eventType;
 	if (!calldata_get_string(cd, "type", &eventType) || strlen(eventType) == 0) {
-		blog(LOG_WARNING, "[WebSocketApi::vendor_event_emit_cb] [vendorName: %s] Failed due to missing `type` string.",
+		blog(LOG_WARNING, "[WebSocketApi::vendor_event_emit_cb] [vendorName: %s] Failed due to missing `type` string.", v->_name.c_str());
-		     v->_name.c_str());
 		RETURN_FAILURE();
 	}
 
 	void *voidEventData;
 	if (!calldata_get_ptr(cd, "data", &voidEventData)) {
-		blog(LOG_WARNING, "[WebSocketApi::vendor_event_emit_cb] [vendorName: %s] Failed due to missing `data` pointer.",
+		blog(LOG_WARNING, "[WebSocketApi::vendor_event_emit_cb] [vendorName: %s] Failed due to missing `data` pointer.", v->_name.c_str());
-		     v->_name.c_str());
 		RETURN_FAILURE();
 	}
 
-	auto eventData = static_cast<obs_data_t *>(voidEventData);
+	auto eventData = static_cast<obs_data_t*>(voidEventData);
 
 	if (!c->_eventCallback)
 		RETURN_FAILURE();

src/WebSocketApi.h

@@ -10,40 +10,37 @@
 #include "../lib/obs-websocket-api.h"
 
 class WebSocketApi {
-public:
+	public:
-	enum RequestReturnCode {
+		enum RequestReturnCode {
-		Normal,
+			Normal,
-		NoVendor,
+			NoVendor,
-		NoVendorRequest,
+			NoVendorRequest,
-	};
+		};
 
-	typedef std::function<void(std::string, std::string, obs_data_t *)> EventCallback;
+		typedef std::function<void(std::string, std::string, obs_data_t*)> EventCallback;
 
-	struct Vendor {
+		struct Vendor {
+			std::shared_mutex _mutex;
+			std::string _name;
+			std::map<std::string, obs_websocket_request_callback> _requests;
+		};
+	
+		WebSocketApi();
+		~WebSocketApi();
+
+		void SetEventCallback(EventCallback cb);
+
+		enum RequestReturnCode PerformVendorRequest(std::string vendorName, std::string requestName, obs_data_t *requestData, obs_data_t *responseData);
+
+		static void get_ph_cb(void *priv_data, calldata_t *cd);
+		static void vendor_register_cb(void *priv_data, calldata_t *cd);
+		static void vendor_request_register_cb(void *priv_data, calldata_t *cd);
+		static void vendor_request_unregister_cb(void *priv_data, calldata_t *cd);
+		static void vendor_event_emit_cb(void *priv_data, calldata_t *cd);
+
+	private:
 		std::shared_mutex _mutex;
-		std::string _name;
+		EventCallback _eventCallback;
-		std::map<std::string, obs_websocket_request_callback> _requests;
+		proc_handler_t *_procHandler;
-	};
+		std::map<std::string, Vendor*> _vendors;
-
-	WebSocketApi();
-	~WebSocketApi();
-
-	void SetEventCallback(EventCallback cb);
-
-	enum RequestReturnCode PerformVendorRequest(std::string vendorName, std::string requestName, obs_data_t *requestData,
-						    obs_data_t *responseData);
-
-	static void get_ph_cb(void *priv_data, calldata_t *cd);
-	static void get_api_version(void *, calldata_t *cd);
-	static void call_request(void *, calldata_t *cd);
-	static void vendor_register_cb(void *priv_data, calldata_t *cd);
-	static void vendor_request_register_cb(void *priv_data, calldata_t *cd);
-	static void vendor_request_unregister_cb(void *priv_data, calldata_t *cd);
-	static void vendor_event_emit_cb(void *priv_data, calldata_t *cd);
-
-private:
-	std::shared_mutex _mutex;
-	EventCallback _eventCallback;
-	proc_handler_t *_procHandler;
-	std::map<std::string, Vendor *> _vendors;
 };

src/eventhandler/EventHandler.cpp

@@ -19,18 +19,18 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 
 #include "EventHandler.h"
 
-EventHandler::EventHandler()
+EventHandler::EventHandler() :
-	: _obsLoaded(false),
+	_obsLoaded(false),
-	  _inputVolumeMetersRef(0),
+	_inputVolumeMetersRef(0),
-	  _inputActiveStateChangedRef(0),
+	_inputActiveStateChangedRef(0),
-	  _inputShowStateChangedRef(0),
+	_inputShowStateChangedRef(0),
-	  _sceneItemTransformChangedRef(0)
+	_sceneItemTransformChangedRef(0)
 {
 	blog_debug("[EventHandler::EventHandler] Setting up...");
 
 	obs_frontend_add_event_callback(OnFrontendEvent, this);
 
-	signal_handler_t *coreSignalHandler = obs_get_signal_handler();
+	signal_handler_t* coreSignalHandler = obs_get_signal_handler();
 	if (coreSignalHandler) {
 		signal_handler_connect(coreSignalHandler, "source_create", SourceCreatedMultiHandler, this);
 		signal_handler_connect(coreSignalHandler, "source_destroy", SourceDestroyedMultiHandler, this);
@@ -49,7 +49,7 @@ EventHandler::~EventHandler()
 
 	obs_frontend_remove_event_callback(OnFrontendEvent, this);
 
-	signal_handler_t *coreSignalHandler = obs_get_signal_handler();
+	signal_handler_t* coreSignalHandler = obs_get_signal_handler();
 	if (coreSignalHandler) {
 		signal_handler_disconnect(coreSignalHandler, "source_create", SourceCreatedMultiHandler, this);
 		signal_handler_disconnect(coreSignalHandler, "source_destroy", SourceDestroyedMultiHandler, this);
@@ -80,8 +80,7 @@ void EventHandler::ProcessSubscription(uint64_t eventSubscriptions)
 			if (_inputVolumeMetersHandler)
 				blog(LOG_WARNING, "[EventHandler::ProcessSubscription] Input volume meter handler already exists!");
 			else
-				_inputVolumeMetersHandler = std::make_unique<Utils::Obs::VolumeMeter::Handler>(
+				_inputVolumeMetersHandler = std::make_unique<Utils::Obs::VolumeMeter::Handler>(std::bind(&EventHandler::HandleInputVolumeMeters, this, std::placeholders::_1));
-					std::bind(&EventHandler::HandleInputVolumeMeters, this, std::placeholders::_1));
 		}
 	}
 	if ((eventSubscriptions & EventSubscription::InputActiveStateChanged) != 0)
@@ -116,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))
@@ -125,22 +123,22 @@ void EventHandler::ConnectSourceSignals(obs_source_t *source) // Applies to inpu
 	// Disconnect all existing signals from the source to prevent multiple connections
 	DisconnectSourceSignals(source);
 
-	signal_handler_t *sh = obs_source_get_signal_handler(source);
+	signal_handler_t* sh = obs_source_get_signal_handler(source);
 
 	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);
@@ -158,334 +156,214 @@ 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)
 		return;
 
-	signal_handler_t *sh = obs_source_get_signal_handler(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, "activate", HandleInputActiveStateChanged, this);
+	signal_handler_disconnect(sh, "deactivate", HandleInputActiveStateChanged, this);
-		signal_handler_disconnect(sh, "deactivate", HandleInputActiveStateChanged, this);
+	signal_handler_disconnect(sh, "show", HandleInputShowStateChanged, this);
-		signal_handler_disconnect(sh, "show", HandleInputShowStateChanged, this);
+	signal_handler_disconnect(sh, "hide", HandleInputShowStateChanged, this);
-		signal_handler_disconnect(sh, "hide", HandleInputShowStateChanged, this);
+	signal_handler_disconnect(sh, "mute", HandleInputMuteStateChanged, this);
-		signal_handler_disconnect(sh, "mute", HandleInputMuteStateChanged, this);
+	signal_handler_disconnect(sh, "volume", HandleInputVolumeChanged, this);
-		signal_handler_disconnect(sh, "volume", HandleInputVolumeChanged, this);
+	signal_handler_disconnect(sh, "audio_sync", HandleInputAudioSyncOffsetChanged, this);
-		signal_handler_disconnect(sh, "audio_balance", HandleInputAudioBalanceChanged, this);
+	signal_handler_disconnect(sh, "audio_mixers", HandleInputAudioTracksChanged, this);
-		signal_handler_disconnect(sh, "audio_sync", HandleInputAudioSyncOffsetChanged, this);
+	//signal_handler_disconnect(sh, "audio_monitoring", HandleInputAudioMonitorTypeChanged, this);
-		signal_handler_disconnect(sh, "audio_mixers", HandleInputAudioTracksChanged, this);
+	signal_handler_disconnect(sh, "media_started", HandleMediaInputPlaybackStarted, this);
-		signal_handler_disconnect(sh, "audio_monitoring", HandleInputAudioMonitorTypeChanged, this);
+	signal_handler_disconnect(sh, "media_ended", HandleMediaInputPlaybackEnded, this);
-		signal_handler_disconnect(sh, "media_started", HandleMediaInputPlaybackStarted, this);
+	signal_handler_disconnect(sh, "media_pause", SourceMediaPauseMultiHandler, this);
-		signal_handler_disconnect(sh, "media_ended", HandleMediaInputPlaybackEnded, this);
+	signal_handler_disconnect(sh, "media_play", SourceMediaPlayMultiHandler, this);
-		signal_handler_disconnect(sh, "media_pause", SourceMediaPauseMultiHandler, this);
+	signal_handler_disconnect(sh, "media_restart", SourceMediaRestartMultiHandler, this);
-		signal_handler_disconnect(sh, "media_play", SourceMediaPlayMultiHandler, this);
+	signal_handler_disconnect(sh, "media_stopped", SourceMediaStopMultiHandler, this);
-		signal_handler_disconnect(sh, "media_restart", SourceMediaRestartMultiHandler, this);
+	signal_handler_disconnect(sh, "media_next", SourceMediaNextMultiHandler, this);
-		signal_handler_disconnect(sh, "media_stopped", SourceMediaStopMultiHandler, this);
+	signal_handler_disconnect(sh, "media_previous", SourceMediaPreviousMultiHandler, 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_add", HandleSceneItemCreated, this);
+	signal_handler_disconnect(sh, "item_remove", HandleSceneItemRemoved, this);
-		signal_handler_disconnect(sh, "item_remove", HandleSceneItemRemoved, this);
+	signal_handler_disconnect(sh, "reorder", HandleSceneItemListReindexed, this);
-		signal_handler_disconnect(sh, "reorder", HandleSceneItemListReindexed, this);
+	signal_handler_disconnect(sh, "item_visible", HandleSceneItemEnableStateChanged, this);
-		signal_handler_disconnect(sh, "item_visible", HandleSceneItemEnableStateChanged, this);
+	signal_handler_disconnect(sh, "item_locked", HandleSceneItemLockStateChanged, this);
-		signal_handler_disconnect(sh, "item_locked", HandleSceneItemLockStateChanged, this);
+	signal_handler_disconnect(sh, "item_transform", HandleSceneItemTransformChanged, 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);
-	}
 }
 
 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)
+	if (!eventHandler->_obsLoaded.load()) {
-		return;
+		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
+			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
+			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;
+		}
+	}
 
 	switch (event) {
-	// General
+		// General
-	case OBS_FRONTEND_EVENT_FINISHED_LOADING:
+		case OBS_FRONTEND_EVENT_EXIT:
-		blog_debug(
+			eventHandler->HandleExitStarted();
-			"[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).
+			blog_debug("[EventHandler::OnFrontendEvent] OBS is unloading. Disabling events...");
-		eventHandler->_obsLoaded.store(true);
+			// Disconnect source signals and disable events when OBS starts unloading (to reduce extra logging).
+			eventHandler->_obsLoaded.store(false);
 
-		// In the case that plugins become hotloadable, this will have to go back into `EventHandler::EventHandler()`
+			// In the case that plugins become hotloadable, this will have to go back into `EventHandler::~EventHandler()`
-		// Enumerate inputs and connect each one
+			// Enumerate inputs and disconnect each one
-		{
+			obs_enum_sources([](void* param, obs_source_t* source) {
-			auto enumInputs = [](void *param, obs_source_t *source) {
+				auto eventHandler = reinterpret_cast<EventHandler*>(param);
-				auto eventHandler = static_cast<EventHandler *>(param);
-				eventHandler->ConnectSourceSignals(source);
-				return true;
-			};
-			obs_enum_sources(enumInputs, 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);
-		}
-
-		blog_debug("[EventHandler::OnFrontendEvent] Finished.");
-
-		if (eventHandler->_obsLoadedCallback)
-			eventHandler->_obsLoadedCallback();
-
-		break;
-	case OBS_FRONTEND_EVENT_EXIT:
-		eventHandler->HandleExitStarted();
-
-		blog_debug("[EventHandler::OnFrontendEvent] OBS is unloading. Disabling events...");
-		// Disconnect source signals and disable events when OBS starts unloading (to reduce extra logging).
-		eventHandler->_obsLoaded.store(false);
-
-		// 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;
-			};
+			}, private_data);
-			obs_enum_sources(enumInputs, private_data);
-		}
 
-		// Enumerate scenes and disconnect each one
+			// Enumerate scenes and disconnect each one
-		{
+			obs_enum_scenes([](void* param, obs_source_t* source) {
-			auto enumScenes = [](void *param, obs_source_t *source) {
+				auto eventHandler = reinterpret_cast<EventHandler*>(param);
-				auto eventHandler = static_cast<EventHandler *>(param);
 				eventHandler->DisconnectSourceSignals(source);
 				return true;
-			};
+			}, private_data);
-			obs_enum_scenes(enumScenes, private_data);
-		}
 
-		// Enumerate all scene transitions and disconnect each one
+			blog_debug("[EventHandler::OnFrontendEvent] Finished.");
-		{
-			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);
-		}
 
-		blog_debug("[EventHandler::OnFrontendEvent] Finished.");
+			break;
+		case OBS_FRONTEND_EVENT_STUDIO_MODE_ENABLED:
+			eventHandler->HandleStudioModeStateChanged(true);
+			break;
+		case OBS_FRONTEND_EVENT_STUDIO_MODE_DISABLED:
+			eventHandler->HandleStudioModeStateChanged(false);
+			break;
 
-		break;
+		// Config
-	case OBS_FRONTEND_EVENT_STUDIO_MODE_ENABLED:
+		//case OBS_FRONTEND_EVENT_SCENE_COLLECTION_CHANGING:
-		eventHandler->HandleStudioModeStateChanged(true);
+		//	eventHandler->HandleCurrentSceneCollectionChanging();
-		break;
+		//	break;
-	case OBS_FRONTEND_EVENT_STUDIO_MODE_DISABLED:
+		case OBS_FRONTEND_EVENT_SCENE_COLLECTION_CHANGED:
-		eventHandler->HandleStudioModeStateChanged(false);
+			eventHandler->HandleCurrentSceneCollectionChanged();
-		break;
+			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_CHANGED:
+			eventHandler->HandleCurrentProfileChanged();
+			break;
+		case OBS_FRONTEND_EVENT_PROFILE_LIST_CHANGED:
+			eventHandler->HandleProfileListChanged();
+			break;
 
-	// Config
+		// Scenes
-	case OBS_FRONTEND_EVENT_SCENE_COLLECTION_CHANGING: {
+		case OBS_FRONTEND_EVENT_SCENE_CHANGED:
-		obs_frontend_source_list transitions = {};
+			eventHandler->HandleCurrentProgramSceneChanged();
-		obs_frontend_get_transitions(&transitions);
+			break;
-		for (size_t i = 0; i < transitions.sources.num; i++) {
+		case OBS_FRONTEND_EVENT_PREVIEW_SCENE_CHANGED:
-			obs_source_t *transition = transitions.sources.array[i];
+			eventHandler->HandleCurrentPreviewSceneChanged();
-			eventHandler->DisconnectSourceSignals(transition);
+			break;
-		}
+		case OBS_FRONTEND_EVENT_SCENE_LIST_CHANGED:
-		obs_frontend_source_list_free(&transitions);
+			eventHandler->HandleSceneListChanged();
-	}
+			break;
-		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_CHANGED:
-		eventHandler->HandleCurrentProfileChanged();
-		break;
-	case OBS_FRONTEND_EVENT_PROFILE_LIST_CHANGED:
-		eventHandler->HandleProfileListChanged();
-		break;
 
-	// Scenes
+		// Transitions
-	case OBS_FRONTEND_EVENT_SCENE_CHANGED:
+		case OBS_FRONTEND_EVENT_TRANSITION_CHANGED:
-		eventHandler->HandleCurrentProgramSceneChanged();
+			break;
-		break;
+		case OBS_FRONTEND_EVENT_TRANSITION_LIST_CHANGED:
-	case OBS_FRONTEND_EVENT_PREVIEW_SCENE_CHANGED:
+			break;
-		eventHandler->HandleCurrentPreviewSceneChanged();
+		case OBS_FRONTEND_EVENT_TRANSITION_DURATION_CHANGED:
-		break;
+			break;
-	case OBS_FRONTEND_EVENT_SCENE_LIST_CHANGED:
-		eventHandler->HandleSceneListChanged();
-		break;
 
-	// Transitions
+		// Outputs
-	case OBS_FRONTEND_EVENT_TRANSITION_CHANGED:
+		case OBS_FRONTEND_EVENT_STREAMING_STARTING:
-		eventHandler->HandleCurrentSceneTransitionChanged();
+			eventHandler->HandleStreamStateChanged(OBS_WEBSOCKET_OUTPUT_STARTING);
-		break;
+			break;
-	case OBS_FRONTEND_EVENT_TRANSITION_LIST_CHANGED: {
+		case OBS_FRONTEND_EVENT_STREAMING_STARTED:
-		obs_frontend_source_list transitions = {};
+			eventHandler->HandleStreamStateChanged(OBS_WEBSOCKET_OUTPUT_STARTED);
-		obs_frontend_get_transitions(&transitions);
+			break;
-		for (size_t i = 0; i < transitions.sources.num; i++) {
+		case OBS_FRONTEND_EVENT_STREAMING_STOPPING:
-			obs_source_t *transition = transitions.sources.array[i];
+			eventHandler->HandleStreamStateChanged(OBS_WEBSOCKET_OUTPUT_STOPPING);
-			eventHandler->ConnectSourceSignals(transition);
+			break;
-		}
+		case OBS_FRONTEND_EVENT_STREAMING_STOPPED:
-		obs_frontend_source_list_free(&transitions);
+			eventHandler->HandleStreamStateChanged(OBS_WEBSOCKET_OUTPUT_STOPPED);
-	} break;
+			break;
-	case OBS_FRONTEND_EVENT_TRANSITION_DURATION_CHANGED:
+		case OBS_FRONTEND_EVENT_RECORDING_STARTING:
-		eventHandler->HandleCurrentSceneTransitionDurationChanged();
+			eventHandler->HandleRecordStateChanged(OBS_WEBSOCKET_OUTPUT_STARTING);
-		break;
+			break;
+		case OBS_FRONTEND_EVENT_RECORDING_STARTED:
+			eventHandler->HandleRecordStateChanged(OBS_WEBSOCKET_OUTPUT_STARTED);
+			break;
+		case OBS_FRONTEND_EVENT_RECORDING_STOPPING:
+			eventHandler->HandleRecordStateChanged(OBS_WEBSOCKET_OUTPUT_STOPPING);
+			break;
+		case OBS_FRONTEND_EVENT_RECORDING_STOPPED:
+			eventHandler->HandleRecordStateChanged(OBS_WEBSOCKET_OUTPUT_STOPPED);
+			break;
+		case OBS_FRONTEND_EVENT_RECORDING_PAUSED:
+			eventHandler->HandleRecordStateChanged(OBS_WEBSOCKET_OUTPUT_PAUSED);
+			break;
+		case OBS_FRONTEND_EVENT_RECORDING_UNPAUSED:
+			eventHandler->HandleRecordStateChanged(OBS_WEBSOCKET_OUTPUT_RESUMED);
+			break;
+		case OBS_FRONTEND_EVENT_REPLAY_BUFFER_STARTING:
+			eventHandler->HandleReplayBufferStateChanged(OBS_WEBSOCKET_OUTPUT_STARTING);
+			break;
+		case OBS_FRONTEND_EVENT_REPLAY_BUFFER_STARTED:
+			eventHandler->HandleReplayBufferStateChanged(OBS_WEBSOCKET_OUTPUT_STARTED);
+			break;
+		case OBS_FRONTEND_EVENT_REPLAY_BUFFER_STOPPING:
+			eventHandler->HandleReplayBufferStateChanged(OBS_WEBSOCKET_OUTPUT_STOPPING);
+			break;
+		case OBS_FRONTEND_EVENT_REPLAY_BUFFER_STOPPED:
+			eventHandler->HandleReplayBufferStateChanged(OBS_WEBSOCKET_OUTPUT_STOPPED);
+			break;
+		case OBS_FRONTEND_EVENT_VIRTUALCAM_STARTED:
+			eventHandler->HandleVirtualcamStateChanged(OBS_WEBSOCKET_OUTPUT_STARTED);
+			break;
+		case OBS_FRONTEND_EVENT_VIRTUALCAM_STOPPED:
+			eventHandler->HandleVirtualcamStateChanged(OBS_WEBSOCKET_OUTPUT_STOPPED);
+			break;
+		case OBS_FRONTEND_EVENT_REPLAY_BUFFER_SAVED:
+			eventHandler->HandleReplayBufferSaved();
+			break;
 
-	// Outputs
+		default:
-	case OBS_FRONTEND_EVENT_STREAMING_STARTING:
+			break;
-		eventHandler->HandleStreamStateChanged(OBS_WEBSOCKET_OUTPUT_STARTING);
-		break;
-	case OBS_FRONTEND_EVENT_STREAMING_STARTED:
-		eventHandler->HandleStreamStateChanged(OBS_WEBSOCKET_OUTPUT_STARTED);
-		break;
-	case OBS_FRONTEND_EVENT_STREAMING_STOPPING:
-		eventHandler->HandleStreamStateChanged(OBS_WEBSOCKET_OUTPUT_STOPPING);
-		break;
-	case OBS_FRONTEND_EVENT_STREAMING_STOPPED:
-		eventHandler->HandleStreamStateChanged(OBS_WEBSOCKET_OUTPUT_STOPPED);
-		break;
-	case OBS_FRONTEND_EVENT_RECORDING_STARTING:
-		eventHandler->HandleRecordStateChanged(OBS_WEBSOCKET_OUTPUT_STARTING);
-		break;
-	case OBS_FRONTEND_EVENT_RECORDING_STARTED:
-		eventHandler->HandleRecordStateChanged(OBS_WEBSOCKET_OUTPUT_STARTED);
-		break;
-	case OBS_FRONTEND_EVENT_RECORDING_STOPPING:
-		eventHandler->HandleRecordStateChanged(OBS_WEBSOCKET_OUTPUT_STOPPING);
-		break;
-	case OBS_FRONTEND_EVENT_RECORDING_STOPPED:
-		eventHandler->HandleRecordStateChanged(OBS_WEBSOCKET_OUTPUT_STOPPED);
-		break;
-	case OBS_FRONTEND_EVENT_RECORDING_PAUSED:
-		eventHandler->HandleRecordStateChanged(OBS_WEBSOCKET_OUTPUT_PAUSED);
-		break;
-	case OBS_FRONTEND_EVENT_RECORDING_UNPAUSED:
-		eventHandler->HandleRecordStateChanged(OBS_WEBSOCKET_OUTPUT_RESUMED);
-		break;
-	case OBS_FRONTEND_EVENT_REPLAY_BUFFER_STARTING:
-		eventHandler->HandleReplayBufferStateChanged(OBS_WEBSOCKET_OUTPUT_STARTING);
-		break;
-	case OBS_FRONTEND_EVENT_REPLAY_BUFFER_STARTED:
-		eventHandler->HandleReplayBufferStateChanged(OBS_WEBSOCKET_OUTPUT_STARTED);
-		break;
-	case OBS_FRONTEND_EVENT_REPLAY_BUFFER_STOPPING:
-		eventHandler->HandleReplayBufferStateChanged(OBS_WEBSOCKET_OUTPUT_STOPPING);
-		break;
-	case OBS_FRONTEND_EVENT_REPLAY_BUFFER_STOPPED:
-		eventHandler->HandleReplayBufferStateChanged(OBS_WEBSOCKET_OUTPUT_STOPPED);
-		break;
-	case OBS_FRONTEND_EVENT_VIRTUALCAM_STARTED:
-		eventHandler->HandleVirtualcamStateChanged(OBS_WEBSOCKET_OUTPUT_STARTED);
-		break;
-	case OBS_FRONTEND_EVENT_VIRTUALCAM_STOPPED:
-		eventHandler->HandleVirtualcamStateChanged(OBS_WEBSOCKET_OUTPUT_STOPPED);
-		break;
-	case OBS_FRONTEND_EVENT_REPLAY_BUFFER_SAVED:
-		eventHandler->HandleReplayBufferSaved();
-		break;
-
-	default:
-		break;
 	}
 }
 
 // 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())
@@ -498,22 +376,21 @@ void EventHandler::SourceCreatedMultiHandler(void *param, calldata_t *data)
 	eventHandler->ConnectSourceSignals(source);
 
 	switch (obs_source_get_type(source)) {
-	case OBS_SOURCE_TYPE_INPUT:
+		case OBS_SOURCE_TYPE_INPUT:
-		eventHandler->HandleInputCreated(source);
+			eventHandler->HandleInputCreated(source);
-		break;
+			break;
-	case OBS_SOURCE_TYPE_SCENE:
+		case OBS_SOURCE_TYPE_SCENE:
-		eventHandler->HandleSceneCreated(source);
+			eventHandler->HandleSceneCreated(source);
-		break;
+			break;
-	default:
+		default:
-		break;
+			break;
 	}
 }
 
-// Only called for destruction of a public sourcs
+// Only called for destruction of a public source
-// Used as a fallback if an input/scene is not explicitly removed
 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");
@@ -528,26 +405,20 @@ void EventHandler::SourceDestroyedMultiHandler(void *param, calldata_t *data)
 		return;
 
 	switch (obs_source_get_type(source)) {
-	case OBS_SOURCE_TYPE_INPUT:
+		case OBS_SOURCE_TYPE_INPUT:
-		// Only emit removed if the input has not already been removed. This is the case when removing the last scene item of an input.
+			// We have to call `InputRemoved` with source_destroy because source_removed is not called when an input's last scene item is removed
-		if (!obs_source_removed(source))
 			eventHandler->HandleInputRemoved(source);
-		break;
+			break;
-	case OBS_SOURCE_TYPE_SCENE:
+		case OBS_SOURCE_TYPE_SCENE:
-		// Only emit removed if the scene has not already been removed.
+			break;
-		if (!obs_source_removed(source))
+		default:
-			eventHandler->HandleSceneRemoved(source);
+			break;
-		break;
-	default:
-		break;
 	}
 }
 
-// We prefer remove signals over destroy signals because they are more time-accurate.
-// For example, if an input is "removed" but there is a dangling ref, you still want to know that it shouldn't exist, but it's not guaranteed to be destroyed.
 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;
@@ -557,20 +428,20 @@ void EventHandler::SourceRemovedMultiHandler(void *param, calldata_t *data)
 		return;
 
 	switch (obs_source_get_type(source)) {
-	case OBS_SOURCE_TYPE_INPUT:
+		case OBS_SOURCE_TYPE_INPUT:
-		eventHandler->HandleInputRemoved(source);
+			break;
-		break;
+		case OBS_SOURCE_TYPE_SCENE:
-	case OBS_SOURCE_TYPE_SCENE:
+			// Scenes emit the `removed` signal when they are removed from OBS, as expected
-		eventHandler->HandleSceneRemoved(source);
+			eventHandler->HandleSceneRemoved(source);
-		break;
+			break;
-	default:
+		default:
-		break;
+			break;
 	}
 }
 
 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;
@@ -585,15 +456,17 @@ void EventHandler::SourceRenamedMultiHandler(void *param, calldata_t *data)
 		return;
 
 	switch (obs_source_get_type(source)) {
-	case OBS_SOURCE_TYPE_INPUT:
+		case OBS_SOURCE_TYPE_INPUT:
-		eventHandler->HandleInputNameChanged(source, oldSourceName, sourceName);
+			eventHandler->HandleInputNameChanged(source, oldSourceName, sourceName);
-		break;
+			break;
-	case OBS_SOURCE_TYPE_TRANSITION:
+		case OBS_SOURCE_TYPE_FILTER:
-		break;
+			break;
-	case OBS_SOURCE_TYPE_SCENE:
+		case OBS_SOURCE_TYPE_TRANSITION:
-		eventHandler->HandleSceneNameChanged(source, oldSourceName, sourceName);
+			break;
-		break;
+		case OBS_SOURCE_TYPE_SCENE:
-	default:
+			eventHandler->HandleSceneNameChanged(source, oldSourceName, sourceName);
-		break;
+			break;
+		default:
+			break;
 	}
 }

src/eventhandler/EventHandler.h

@@ -29,121 +29,105 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #include "../utils/Obs_VolumeMeter.h"
 #include "../plugin-macros.generated.h"
 
-class EventHandler {
+class EventHandler
-public:
+{
-	EventHandler();
+	public:
-	~EventHandler();
+		EventHandler();
+		~EventHandler();
 
-	typedef std::function<void(uint64_t, std::string, json, uint8_t)> BroadcastCallback;
+		typedef std::function<void(uint64_t, std::string, json, uint8_t)> BroadcastCallback;
-	void SetBroadcastCallback(BroadcastCallback cb);
+		void SetBroadcastCallback(BroadcastCallback cb);
-	typedef std::function<void()> ObsLoadedCallback;
+		typedef std::function<void()> ObsLoadedCallback;
-	void SetObsLoadedCallback(ObsLoadedCallback cb);
+		void SetObsLoadedCallback(ObsLoadedCallback cb);
 
-	void ProcessSubscription(uint64_t eventSubscriptions);
+		void ProcessSubscription(uint64_t eventSubscriptions);
-	void ProcessUnsubscription(uint64_t eventSubscriptions);
+		void ProcessUnsubscription(uint64_t eventSubscriptions);
 
-private:
+	private:
-	BroadcastCallback _broadcastCallback;
+		BroadcastCallback _broadcastCallback;
-	ObsLoadedCallback _obsLoadedCallback;
+		ObsLoadedCallback _obsLoadedCallback;
 
-	std::atomic<bool> _obsLoaded;
+		std::atomic<bool> _obsLoaded;
 
-	std::unique_ptr<Utils::Obs::VolumeMeter::Handler> _inputVolumeMetersHandler;
+		std::unique_ptr<Utils::Obs::VolumeMeter::Handler> _inputVolumeMetersHandler;
-	std::atomic<uint64_t> _inputVolumeMetersRef;
+		std::atomic<uint64_t> _inputVolumeMetersRef;
-	std::atomic<uint64_t> _inputActiveStateChangedRef;
+		std::atomic<uint64_t> _inputActiveStateChangedRef;
-	std::atomic<uint64_t> _inputShowStateChangedRef;
+		std::atomic<uint64_t> _inputShowStateChangedRef;
-	std::atomic<uint64_t> _sceneItemTransformChangedRef;
+		std::atomic<uint64_t> _sceneItemTransformChangedRef;
 
-	void ConnectSourceSignals(obs_source_t *source);
+		void ConnectSourceSignals(obs_source_t *source);
-	void DisconnectSourceSignals(obs_source_t *source);
+		void DisconnectSourceSignals(obs_source_t *source);
 
-	void BroadcastEvent(uint64_t requiredIntent, std::string eventType, json eventData = nullptr, uint8_t rpcVersion = 0);
+		void BroadcastEvent(uint64_t requiredIntent, std::string eventType, json eventData = nullptr, uint8_t rpcVersion = 0);
 
-	// Signal handler: frontend
+		// Signal handler: frontend
-	static void OnFrontendEvent(enum obs_frontend_event event, void *private_data);
+		static void OnFrontendEvent(enum obs_frontend_event event, void *private_data);
 
-	// Signal handler: libobs
+		// Signal handler: libobs
-	static void SourceCreatedMultiHandler(void *param, calldata_t *data);
+		static void SourceCreatedMultiHandler(void *param, calldata_t *data);
-	static void SourceDestroyedMultiHandler(void *param, calldata_t *data);
+		static void SourceDestroyedMultiHandler(void *param, calldata_t *data);
-	static void SourceRemovedMultiHandler(void *param, calldata_t *data);
+		static void SourceRemovedMultiHandler(void *param, calldata_t *data);
 
-	// Signal handler: source
+		// Signal handler: source
-	static void SourceRenamedMultiHandler(void *param, calldata_t *data);
+		static void SourceRenamedMultiHandler(void *param, calldata_t *data);
-	static void SourceMediaPauseMultiHandler(void *param, calldata_t *data);
+		static void SourceMediaPauseMultiHandler(void *param, calldata_t *data);
-	static void SourceMediaPlayMultiHandler(void *param, calldata_t *data);
+		static void SourceMediaPlayMultiHandler(void *param, calldata_t *data);
-	static void SourceMediaRestartMultiHandler(void *param, calldata_t *data);
+		static void SourceMediaRestartMultiHandler(void *param, calldata_t *data);
-	static void SourceMediaStopMultiHandler(void *param, calldata_t *data);
+		static void SourceMediaStopMultiHandler(void *param, calldata_t *data);
-	static void SourceMediaNextMultiHandler(void *param, calldata_t *data);
+		static void SourceMediaNextMultiHandler(void *param, calldata_t *data);
-	static void SourceMediaPreviousMultiHandler(void *param, calldata_t *data);
+		static void SourceMediaPreviousMultiHandler(void *param, calldata_t *data);
 
-	// General
-	void HandleExitStarted();
-	void HandleStudioModeStateChanged(bool enabled);
 
-	// Config
+		// General
-	void HandleCurrentSceneCollectionChanging();
+		void HandleExitStarted();
-	void HandleCurrentSceneCollectionChanged();
+		void HandleStudioModeStateChanged(bool enabled);
-	void HandleSceneCollectionListChanged();
-	void HandleCurrentProfileChanging();
-	void HandleCurrentProfileChanged();
-	void HandleProfileListChanged();
 
-	// Scenes
+		// Config
-	void HandleSceneCreated(obs_source_t *source);
+		void HandleCurrentSceneCollectionChanging();
-	void HandleSceneRemoved(obs_source_t *source);
+		void HandleCurrentSceneCollectionChanged();
-	void HandleSceneNameChanged(obs_source_t *source, std::string oldSceneName, std::string sceneName);
+		void HandleSceneCollectionListChanged();
-	void HandleCurrentProgramSceneChanged();
+		void HandleCurrentProfileChanging();
-	void HandleCurrentPreviewSceneChanged();
+		void HandleCurrentProfileChanged();
-	void HandleSceneListChanged();
+		void HandleProfileListChanged();
 
-	// Inputs
+		// Scenes
-	void HandleInputCreated(obs_source_t *source);
+		void HandleSceneCreated(obs_source_t *source);
-	void HandleInputRemoved(obs_source_t *source);
+		void HandleSceneRemoved(obs_source_t *source);
-	void HandleInputNameChanged(obs_source_t *source, std::string oldInputName, std::string inputName);
+		void HandleSceneNameChanged(obs_source_t *source, std::string oldSceneName, std::string sceneName);
-	void HandleInputVolumeMeters(std::vector<json> inputs);                        // AudioMeter::Handler callback
+		void HandleCurrentProgramSceneChanged();
-	static void HandleInputActiveStateChanged(void *param, calldata_t *data);      // Direct callback
+		void HandleCurrentPreviewSceneChanged();
-	static void HandleInputShowStateChanged(void *param, calldata_t *data);        // Direct callback
+		void HandleSceneListChanged();
-	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
+		// Inputs
-	void HandleCurrentSceneTransitionChanged();
+		void HandleInputCreated(obs_source_t *source);
-	void HandleCurrentSceneTransitionDurationChanged();
+		void HandleInputRemoved(obs_source_t *source);
-	static void HandleSceneTransitionStarted(void *param, calldata_t *data);    // Direct callback
+		void HandleInputNameChanged(obs_source_t *source, std::string oldInputName, std::string inputName);
-	static void HandleSceneTransitionEnded(void *param, calldata_t *data);      // Direct callback
+		void HandleInputVolumeMeters(std::vector<json> inputs); // AudioMeter::Handler callback
-	static void HandleSceneTransitionVideoEnded(void *param, calldata_t *data); // Direct callback
+		static void HandleInputActiveStateChanged(void *param, calldata_t *data); // Direct callback
+		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 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
 
-	// Filters
+		// Outputs
-	static void FilterAddMultiHandler(void *param, calldata_t *data);           // Direct callback
+		void HandleStreamStateChanged(ObsOutputState state);
-	static void FilterRemoveMultiHandler(void *param, calldata_t *data);        // Direct callback
+		void HandleRecordStateChanged(ObsOutputState state);
-	static void HandleSourceFilterListReindexed(void *param, calldata_t *data); // Direct callback
+		void HandleReplayBufferStateChanged(ObsOutputState state);
-	void HandleSourceFilterCreated(obs_source_t *source, obs_source_t *filter);
+		void HandleVirtualcamStateChanged(ObsOutputState state);
-	void HandleSourceFilterRemoved(obs_source_t *source, obs_source_t *filter);
+		void HandleReplayBufferSaved();
-	static void HandleSourceFilterNameChanged(void *param, calldata_t *data);        // Direct callback
-	static void HandleSourceFilterEnableStateChanged(void *param, calldata_t *data); // Direct callback
 
-	// Outputs
+		// Scene Items
-	void HandleStreamStateChanged(ObsOutputState state);
+		static void HandleSceneItemCreated(void *param, calldata_t *data); // Direct callback
-	void HandleRecordStateChanged(ObsOutputState state);
+		static void HandleSceneItemRemoved(void *param, calldata_t *data); // Direct callback
-	void HandleReplayBufferStateChanged(ObsOutputState state);
+		static void HandleSceneItemListReindexed(void *param, calldata_t *data); // Direct callback
-	void HandleVirtualcamStateChanged(ObsOutputState state);
+		static void HandleSceneItemEnableStateChanged(void *param, calldata_t *data); // Direct callback
-	void HandleReplayBufferSaved();
+		static void HandleSceneItemLockStateChanged(void *param, calldata_t *data); // Direct callback
+		static void HandleSceneItemTransformChanged(void *param, calldata_t *data); // Direct callback
 
-	// Scene Items
+		// Media Inputs
-	static void HandleSceneItemCreated(void *param, calldata_t *data);            // Direct callback
+		static void HandleMediaInputPlaybackStarted(void *param, calldata_t *data); // Direct callback
-	static void HandleSceneItemRemoved(void *param, calldata_t *data);            // Direct callback
+		static void HandleMediaInputPlaybackEnded(void *param, calldata_t *data); // Direct callback
-	static void HandleSceneItemListReindexed(void *param, calldata_t *data);      // Direct callback
+		void HandleMediaInputActionTriggered(obs_source_t *source, ObsMediaInputAction action);
-	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
-	static void HandleMediaInputPlaybackStarted(void *param, calldata_t *data); // Direct callback
-	static void HandleMediaInputPlaybackEnded(void *param, calldata_t *data);   // Direct callback
-	void HandleMediaInputActionTriggered(obs_source_t *source, ObsMediaInputAction action);
 };

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);
-}

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 inputName        | String         | Name of the input
- * @dataField inputAudioTracks | Object | Object of audio tracks along with their associated enable states
+ * @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)
@@ -344,7 +311,6 @@ void EventHandler::HandleInputAudioTracksChanged(void *param, calldata_t *data)
  * The monitor type of an input has changed.
  *
  * Available types are:
- *
  * - `OBS_MONITORING_TYPE_NONE`
  * - `OBS_MONITORING_TYPE_MONITOR_ONLY`
  * - `OBS_MONITORING_TYPE_MONITOR_AND_OUTPUT`
@@ -362,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)
@@ -373,9 +339,11 @@ void EventHandler::HandleInputAudioMonitorTypeChanged(void *param, calldata_t *d
 
 	enum obs_monitoring_type monitorType = (obs_monitoring_type)calldata_int(data, "type");
 
+	std::string monitorTypeString = Utils::Obs::StringHelper::GetInputMonitorType(monitorType);
+
 	json eventData;
 	eventData["inputName"] = obs_source_get_name(source);
-	eventData["monitorType"] = monitorType;
+	eventData["monitorType"] = monitorTypeString;
 	eventHandler->BroadcastEvent(EventSubscription::Inputs, "InputAudioMonitorTypeChanged", eventData);
 }
 

src/eventhandler/EventHandler_MediaInputs.cpp

@@ -19,14 +19,11 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 
 #include "EventHandler.h"
 
-#define CASE(x) \
+#define CASE(x) case x: return #x;
-	case x: \
-		return #x;
 
-std::string GetMediaInputActionString(ObsMediaInputAction action)
+std::string GetMediaInputActionString(ObsMediaInputAction action) {
-{
 	switch (action) {
-	default:
+		default:
 		CASE(OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PAUSE)
 		CASE(OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PLAY)
 		CASE(OBS_WEBSOCKET_MEDIA_INPUT_ACTION_RESTART)
@@ -38,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)
@@ -52,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)
@@ -66,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)
@@ -80,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)
@@ -94,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)
@@ -108,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)
@@ -135,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)
@@ -164,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)

src/eventhandler/EventHandler_Outputs.cpp

@@ -19,19 +19,18 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 
 #include "EventHandler.h"
 
-static bool GetOutputStateActive(ObsOutputState state)
+static bool GetOutputStateActive(ObsOutputState state) {
-{
+	switch(state) {
-	switch (state) {
+		case OBS_WEBSOCKET_OUTPUT_STARTED:
-	case OBS_WEBSOCKET_OUTPUT_STARTED:
+		case OBS_WEBSOCKET_OUTPUT_RESUMED:
-	case OBS_WEBSOCKET_OUTPUT_RESUMED:
+			return true;
-		return true;
+		case OBS_WEBSOCKET_OUTPUT_STARTING:
-	case OBS_WEBSOCKET_OUTPUT_STARTING:
+		case OBS_WEBSOCKET_OUTPUT_STOPPING:
-	case OBS_WEBSOCKET_OUTPUT_STOPPING:
+		case OBS_WEBSOCKET_OUTPUT_STOPPED:
-	case OBS_WEBSOCKET_OUTPUT_STOPPED:
+		case OBS_WEBSOCKET_OUTPUT_PAUSED:
-	case OBS_WEBSOCKET_OUTPUT_PAUSED:
+			return false;
-		return false;
+		default:
-	default:
+			return false;
-		return false;
 	}
 }
 
@@ -53,7 +52,7 @@ void EventHandler::HandleStreamStateChanged(ObsOutputState state)
 {
 	json eventData;
 	eventData["outputActive"] = GetOutputStateActive(state);
-	eventData["outputState"] = state;
+	eventData["outputState"] = Utils::Obs::StringHelper::GetOutputState(state);
 	BroadcastEvent(EventSubscription::Outputs, "StreamStateChanged", eventData);
 }
 
@@ -62,7 +61,6 @@ void EventHandler::HandleStreamStateChanged(ObsOutputState state)
  *
  * @dataField outputActive | Boolean | Whether the output is active
  * @dataField outputState  | String  | The specific state of the output
- * @dataField outputPath   | String  | File name for the saved recording, if record stopped. `null` otherwise
  *
  * @eventType RecordStateChanged
  * @eventSubscription Outputs
@@ -76,12 +74,7 @@ void EventHandler::HandleRecordStateChanged(ObsOutputState state)
 {
 	json eventData;
 	eventData["outputActive"] = GetOutputStateActive(state);
-	eventData["outputState"] = state;
+	eventData["outputState"] = Utils::Obs::StringHelper::GetOutputState(state);
-	if (state == OBS_WEBSOCKET_OUTPUT_STOPPED || state == OBS_WEBSOCKET_OUTPUT_STARTED) {
-		eventData["outputPath"] = Utils::Obs::StringHelper::GetLastRecordFileName();
-	} else {
-		eventData["outputPath"] = nullptr;
-	}
 	BroadcastEvent(EventSubscription::Outputs, "RecordStateChanged", eventData);
 }
 
@@ -103,7 +96,7 @@ void EventHandler::HandleReplayBufferStateChanged(ObsOutputState state)
 {
 	json eventData;
 	eventData["outputActive"] = GetOutputStateActive(state);
-	eventData["outputState"] = state;
+	eventData["outputState"] = Utils::Obs::StringHelper::GetOutputState(state);
 	BroadcastEvent(EventSubscription::Outputs, "ReplayBufferStateChanged", eventData);
 }
 
@@ -125,7 +118,7 @@ void EventHandler::HandleVirtualcamStateChanged(ObsOutputState state)
 {
 	json eventData;
 	eventData["outputActive"] = GetOutputStateActive(state);
-	eventData["outputState"] = state;
+	eventData["outputState"] = Utils::Obs::StringHelper::GetOutputState(state);
 	BroadcastEvent(EventSubscription::Outputs, "VirtualcamStateChanged", eventData);
 }
 
@@ -145,6 +138,6 @@ void EventHandler::HandleVirtualcamStateChanged(ObsOutputState state)
 void EventHandler::HandleReplayBufferSaved()
 {
 	json eventData;
-	eventData["savedReplayPath"] = Utils::Obs::StringHelper::GetLastReplayBufferFileName();
+	eventData["savedReplayPath"] = Utils::Obs::StringHelper::GetLastReplayBufferFilePath();
 	BroadcastEvent(EventSubscription::Outputs, "ReplayBufferSaved", eventData);
 }

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 sceneName        | String  | Name of the scene the item is in
- * @dataField sceneItemId     | Number  | Numeric ID of the scene item
+ * @dataField sceneItemId      | Number  | Numeric ID of the scene item
- * @dataField sceneItemLocked | Boolean | Whether the scene item is locked
+ * @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;

src/eventhandler/EventHandler_Scenes.cpp

@@ -124,7 +124,7 @@ void EventHandler::HandleCurrentPreviewSceneChanged()
 {
 	OBSSourceAutoRelease currentPreviewScene = obs_frontend_get_current_preview_scene();
 
-	// This event may be called when OBS is not in studio mode, however retreiving the source while not in studio mode will return null.
+	// This event may be called when OBS is not in studio mode, however retreiving the source while not in studio mode will return null. 
 	if (!currentPreviewScene)
 		return;
 

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);
-}

src/eventhandler/types/EventSubscription.h

@@ -157,15 +157,13 @@ namespace EventSubscription {
 		* Helper to receive all non-high-volume events.
 		*
 		* @enumIdentifier All
-		* @enumValue (General | Config | Scenes | Inputs | Transitions | Filters | Outputs | SceneItems | MediaInputs | Vendors | Ui)
+		* @enumValue (General | Config | Scenes | Inputs | Transitions | Filters | Outputs | SceneItems | MediaInputs | Vendors)
 		* @enumType EventSubscription
 		* @rpcVersion -1
 		* @initialVersion 5.0.0
 		* @api enums
 		*/
-		All = (General | Config | Scenes | Inputs | Transitions | Filters | Outputs | SceneItems | MediaInputs | Vendors |
+		All = (General | Config | Scenes | Inputs | Transitions | Filters | Outputs | SceneItems | MediaInputs | Ui | Vendors),
-		       Ui),
-
 		/**
 		* Subscription value to receive the `InputVolumeMeters` high-volume event.
 		*

src/forms/ConnectInfo.cpp

@@ -28,13 +28,18 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #include "../Config.h"
 #include "../utils/Platform.h"
 
-ConnectInfo::ConnectInfo(QWidget *parent) : QDialog(parent, Qt::Dialog), ui(new Ui::ConnectInfo)
+ConnectInfo::ConnectInfo(QWidget* parent) :
+	QDialog(parent, Qt::Dialog),
+	ui(new Ui::ConnectInfo)
 {
 	ui->setupUi(this);
 
-	connect(ui->copyServerIpButton, &QPushButton::clicked, this, &ConnectInfo::CopyServerIpButtonClicked);
+	connect(ui->copyServerIpButton, &QPushButton::clicked,
-	connect(ui->copyServerPortButton, &QPushButton::clicked, this, &ConnectInfo::CopyServerPortButtonClicked);
+		this, &ConnectInfo::CopyServerIpButtonClicked);
-	connect(ui->copyServerPasswordButton, &QPushButton::clicked, this, &ConnectInfo::CopyServerPasswordButtonClicked);
+	connect(ui->copyServerPortButton, &QPushButton::clicked,
+		this, &ConnectInfo::CopyServerPortButtonClicked);
+	connect(ui->copyServerPasswordButton, &QPushButton::clicked,
+		this, &ConnectInfo::CopyServerPasswordButtonClicked);
 }
 
 ConnectInfo::~ConnectInfo()
@@ -108,14 +113,14 @@ void ConnectInfo::DrawQr(QString qrText)
 	QPixmap map(230, 230);
 	map.fill(Qt::white);
 	QPainter painter(&map);
-
+	
 	qrcodegen::QrCode qr = qrcodegen::QrCode::encodeText(QT_TO_UTF8(qrText), qrcodegen::QrCode::Ecc::MEDIUM);
 	const int s = qr.getSize() > 0 ? qr.getSize() : 1;
 	const double w = map.width();
 	const double h = map.height();
-	const double aspect = w / h;
+	const double aspect = w/h;
 	const double size = ((aspect > 1.0) ? h : w);
-	const double scale = size / (s + 2);
+	const double scale = size / (s+2);
 	painter.setPen(Qt::NoPen);
 	painter.setBrush(Qt::black);
 

src/forms/ConnectInfo.h

@@ -25,11 +25,12 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 
 #include "ui_ConnectInfo.h"
 
-class ConnectInfo : public QDialog {
+class ConnectInfo : public QDialog
+{
 	Q_OBJECT
 
 public:
-	explicit ConnectInfo(QWidget *parent = 0);
+	explicit ConnectInfo(QWidget* parent = 0);
 	~ConnectInfo();
 	void showEvent(QShowEvent *event);
 	void RefreshData();

src/forms/SettingsDialog.cpp

@@ -37,12 +37,12 @@ QString GetToolTipIconHtml()
 	return iconTemplate.arg(iconFile);
 }
 
-SettingsDialog::SettingsDialog(QWidget *parent)
+SettingsDialog::SettingsDialog(QWidget* parent) :
-	: QDialog(parent, Qt::Dialog),
+	QDialog(parent, Qt::Dialog),
-	  ui(new Ui::SettingsDialog),
+	ui(new Ui::SettingsDialog),
-	  connectInfo(new ConnectInfo),
+	connectInfo(new ConnectInfo),
-	  sessionTableTimer(new QTimer),
+	sessionTableTimer(new QTimer),
-	  passwordManuallyEdited(false)
+	passwordManuallyEdited(false)
 {
 	ui->setupUi(this);
 	ui->websocketSessionTable->horizontalHeader()->resizeSection(3, 100); // Resize Session Table column widths
@@ -54,13 +54,18 @@ SettingsDialog::SettingsDialog(QWidget *parent)
 	// Set the appropriate tooltip icon for the theme
 	ui->enableDebugLoggingToolTipLabel->setText(GetToolTipIconHtml());
 
-	connect(sessionTableTimer, &QTimer::timeout, this, &SettingsDialog::FillSessionTable);
+	connect(sessionTableTimer, &QTimer::timeout,
-	connect(ui->buttonBox, &QDialogButtonBox::clicked, this, &SettingsDialog::DialogButtonClicked);
+		this, &SettingsDialog::FillSessionTable);
-	connect(ui->enableAuthenticationCheckBox, &QCheckBox::stateChanged, this,
+	connect(ui->buttonBox, &QDialogButtonBox::clicked,
-		&SettingsDialog::EnableAuthenticationCheckBoxChanged);
+		this, &SettingsDialog::DialogButtonClicked);
-	connect(ui->generatePasswordButton, &QPushButton::clicked, this, &SettingsDialog::GeneratePasswordButtonClicked);
+	connect(ui->enableAuthenticationCheckBox, &QCheckBox::stateChanged,
-	connect(ui->showConnectInfoButton, &QPushButton::clicked, this, &SettingsDialog::ShowConnectInfoButtonClicked);
+		this, &SettingsDialog::EnableAuthenticationCheckBoxChanged);
-	connect(ui->serverPasswordLineEdit, &QLineEdit::textEdited, this, &SettingsDialog::PasswordEdited);
+	connect(ui->generatePasswordButton, &QPushButton::clicked,
+		this, &SettingsDialog::GeneratePasswordButtonClicked);
+	connect(ui->showConnectInfoButton, &QPushButton::clicked,
+		this, &SettingsDialog::ShowConnectInfoButtonClicked);
+	connect(ui->serverPasswordLineEdit, &QLineEdit::textEdited,
+		this, &SettingsDialog::PasswordEdited);
 }
 
 SettingsDialog::~SettingsDialog()
@@ -78,8 +83,18 @@ void SettingsDialog::showEvent(QShowEvent *)
 		return;
 	}
 
-	if (conf->PortOverridden)
+	ui->enableWebSocketServerCheckBox->setChecked(conf->ServerEnabled);
+	ui->enableSystemTrayAlertsCheckBox->setChecked(conf->AlertsEnabled);
+	ui->enableDebugLoggingCheckBox->setChecked(conf->DebugEnabled);
+	ui->enableAuthenticationCheckBox->setChecked(conf->AuthRequired);
+	ui->serverPasswordLineEdit->setText(conf->ServerPassword);
+	ui->serverPasswordLineEdit->setEnabled(conf->AuthRequired);
+	ui->generatePasswordButton->setEnabled(conf->AuthRequired);
+	ui->serverPortSpinBox->setValue(conf->ServerPort);
+
+	if (conf->PortOverridden) {
 		ui->serverPortSpinBox->setEnabled(false);
+	}
 
 	if (conf->PasswordOverridden) {
 		ui->enableAuthenticationCheckBox->setEnabled(false);
@@ -89,7 +104,7 @@ void SettingsDialog::showEvent(QShowEvent *)
 
 	passwordManuallyEdited = false;
 
-	RefreshData();
+	FillSessionTable();
 
 	sessionTableTimer->start(1000);
 }
@@ -110,27 +125,6 @@ void SettingsDialog::ToggleShowHide()
 		setVisible(false);
 }
 
-void SettingsDialog::RefreshData()
-{
-	auto conf = GetConfig();
-	if (!conf) {
-		blog(LOG_ERROR, "[SettingsDialog::RefreshData] Unable to retreive config!");
-		return;
-	}
-
-	ui->enableWebSocketServerCheckBox->setChecked(conf->ServerEnabled);
-	ui->enableSystemTrayAlertsCheckBox->setChecked(conf->AlertsEnabled);
-	ui->enableDebugLoggingCheckBox->setChecked(conf->DebugEnabled);
-	ui->serverPortSpinBox->setValue(conf->ServerPort);
-	ui->enableAuthenticationCheckBox->setChecked(conf->AuthRequired);
-	ui->serverPasswordLineEdit->setText(conf->ServerPassword);
-
-	ui->serverPasswordLineEdit->setEnabled(conf->AuthRequired);
-	ui->generatePasswordButton->setEnabled(conf->AuthRequired);
-
-	FillSessionTable();
-}
-
 void SettingsDialog::DialogButtonClicked(QAbstractButton *button)
 {
 	if (button == ui->buttonBox->button(QDialogButtonBox::Ok)) {
@@ -168,30 +162,28 @@ void SettingsDialog::SaveFormData()
 		int ret = msgBox.exec();
 
 		switch (ret) {
-		case QMessageBox::Yes:
+			case QMessageBox::Yes:
-			break;
+				break;
-		case QMessageBox::No:
+			case QMessageBox::No:
-		default:
+			default:
-			ui->serverPasswordLineEdit->setText(conf->ServerPassword);
+				ui->serverPasswordLineEdit->setText(conf->ServerPassword);
-			return;
+				return;
 		}
 	}
 
-	bool needsRestart =
+	bool needsRestart = (conf->ServerEnabled != ui->enableWebSocketServerCheckBox->isChecked()) ||
-		(conf->ServerEnabled != ui->enableWebSocketServerCheckBox->isChecked()) ||
+						(ui->enableAuthenticationCheckBox->isChecked() && conf->ServerPassword != ui->serverPasswordLineEdit->text()) ||
-		(conf->ServerPort != ui->serverPortSpinBox->value()) ||
+						(conf->ServerPort != ui->serverPortSpinBox->value());
-		(ui->enableAuthenticationCheckBox->isChecked() && conf->ServerPassword != ui->serverPasswordLineEdit->text());
 
 	conf->ServerEnabled = ui->enableWebSocketServerCheckBox->isChecked();
 	conf->AlertsEnabled = ui->enableSystemTrayAlertsCheckBox->isChecked();
 	conf->DebugEnabled = ui->enableDebugLoggingCheckBox->isChecked();
-	conf->ServerPort = ui->serverPortSpinBox->value();
 	conf->AuthRequired = ui->enableAuthenticationCheckBox->isChecked();
 	conf->ServerPassword = ui->serverPasswordLineEdit->text();
+	conf->ServerPort = ui->serverPortSpinBox->value();
 
 	conf->Save();
 
-	RefreshData();
 	connectInfo->RefreshData();
 
 	if (needsRestart) {
@@ -234,8 +226,7 @@ void SettingsDialog::FillSessionTable()
 		QTableWidgetItem *durationItem = new QTableWidgetItem(QTime(0, 0, sessionDuration).toString("hh:mm:ss"));
 		ui->websocketSessionTable->setItem(i, 1, durationItem);
 
-		QTableWidgetItem *statsItem =
+		QTableWidgetItem *statsItem = new QTableWidgetItem(QString("%1/%2").arg(session.incomingMessages).arg(session.outgoingMessages));
-			new QTableWidgetItem(QString("%1/%2").arg(session.incomingMessages).arg(session.outgoingMessages));
 		ui->websocketSessionTable->setItem(i, 2, statsItem);
 
 		QLabel *identifiedLabel = new QLabel();
@@ -255,7 +246,9 @@ void SettingsDialog::FillSessionTable()
 		invalidateButtonLayout->setContentsMargins(0, 0, 0, 0);
 		invalidateButtonWidget->setLayout(invalidateButtonLayout);
 		ui->websocketSessionTable->setCellWidget(i, 4, invalidateButtonWidget);
-		connect(invalidateButton, &QPushButton::clicked, [=]() { webSocketServer->InvalidateSession(session.hdl); });
+		connect(invalidateButton, &QPushButton::clicked, [=]() {
+			webSocketServer->InvalidateSession(session.hdl);
+		});
 
 		i++;
 	}
@@ -292,11 +285,11 @@ void SettingsDialog::ShowConnectInfoButtonClicked()
 		int ret = msgBox.exec();
 
 		switch (ret) {
-		case QMessageBox::Yes:
+			case QMessageBox::Yes:
-			break;
+				break;
-		case QMessageBox::No:
+			case QMessageBox::No:
-		default:
+			default:
-			return;
+				return;
 		}
 	}
 

src/forms/SettingsDialog.h

@@ -27,16 +27,16 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 
 #include "ui_SettingsDialog.h"
 
-class SettingsDialog : public QDialog {
+class SettingsDialog : public QDialog
+{
 	Q_OBJECT
 
 public:
-	explicit SettingsDialog(QWidget *parent = 0);
+	explicit SettingsDialog(QWidget* parent = 0);
 	~SettingsDialog();
 	void showEvent(QShowEvent *event);
 	void hideEvent(QHideEvent *event);
 	void ToggleShowHide();
-	void RefreshData();
 
 private Q_SLOTS:
 	void DialogButtonClicked(QAbstractButton *button);

src/forms/SettingsDialog.ui

@@ -151,7 +151,7 @@
          <number>65534</number>
         </property>
         <property name="value">
-         <number>4455</number>
+         <number>4444</number>
         </property>
        </widget>
       </item>

src/obs-websocket.cpp

@@ -32,16 +32,10 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 OBS_DECLARE_MODULE()
 OBS_MODULE_USE_DEFAULT_LOCALE("obs-websocket", "en-US")
 OBS_MODULE_AUTHOR("OBSProject")
-const char *obs_module_name(void)
+const char *obs_module_name(void) { return "obs-websocket"; }
-{
+const char *obs_module_description(void) { return obs_module_text("OBSWebSocket.Plugin.Description"); }
-	return "obs-websocket";
-}
-const char *obs_module_description(void)
-{
-	return obs_module_text("OBSWebSocket.Plugin.Description");
-}
 
-os_cpu_usage_info_t *_cpuUsageInfo;
+os_cpu_usage_info_t* _cpuUsageInfo;
 ConfigPtr _config;
 EventHandlerPtr _eventHandler;
 WebSocketApiPtr _webSocketApi;
@@ -52,10 +46,8 @@ void WebSocketApiEventCallback(std::string vendorName, std::string eventType, ob
 
 bool obs_module_load(void)
 {
-	blog(LOG_INFO, "[obs_module_load] you can haz websockets (Version: %s | RPC Version: %d)", OBS_WEBSOCKET_VERSION,
+	blog(LOG_INFO, "[obs_module_load] you can haz websockets (Version: %s | RPC Version: %d)", OBS_WEBSOCKET_VERSION, OBS_WEBSOCKET_RPC_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();
@@ -76,13 +68,13 @@ 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();
 
 	// Add the settings dialog to the tools menu
-	const char *menuActionText = obs_module_text("OBSWebSocket.Settings.DialogTitle");
+	const char* menuActionText = obs_module_text("OBSWebSocket.Settings.DialogTitle");
-	QAction *menuAction = (QAction *)obs_frontend_add_tools_menu_qaction(menuActionText);
+	QAction* menuAction = (QAction*)obs_frontend_add_tools_menu_qaction(menuActionText);
 	QObject::connect(menuAction, &QAction::triggered, [] { _settingsDialog->ToggleShowHide(); });
 
 	blog(LOG_INFO, "[obs_module_load] Module loaded.");
@@ -118,7 +110,7 @@ void obs_module_unload()
 	blog(LOG_INFO, "[obs_module_unload] Finished shutting down.");
 }
 
-os_cpu_usage_info_t *GetCpuUsageInfo()
+os_cpu_usage_info_t* GetCpuUsageInfo()
 {
 	return _cpuUsageInfo;
 }
@@ -197,26 +189,12 @@ void obs_module_post_load()
 {
 	blog(LOG_INFO, "[obs_module_post_load] Post load started.");
 
-	// Test plugin API version fetch
-	uint apiVersion = obs_websocket_get_api_version();
-	blog(LOG_INFO, "[obs_module_post_load] obs-websocket plugin API version: %u", apiVersion);
-
-	// Test calling obs-websocket requests
-	struct obs_websocket_request_response *response = obs_websocket_call_request("GetVersion");
-	if (response) {
-		blog(LOG_INFO, "[obs_module_post_load] Called GetVersion. Status Code: %u | Comment: %s | Response Data: %s",
-		     response->status_code, response->comment, response->response_data);
-		obs_websocket_request_response_free(response);
-	}
-
-	// Test vendor creation
 	auto vendor = obs_websocket_register_vendor("obs-websocket-test");
 	if (!vendor) {
 		blog(LOG_WARNING, "[obs_module_post_load] Failed to create vendor!");
 		return;
 	}
 
-	// Test vendor request registration
 	if (!obs_websocket_vendor_register_request(vendor, "TestRequest", test_vendor_request_cb, vendor)) {
 		blog(LOG_WARNING, "[obs_module_post_load] Failed to register vendor request!");
 		return;

src/obs-websocket.h

@@ -21,12 +21,18 @@ 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"
 
-struct Config;
+class Config;
 typedef std::shared_ptr<Config> ConfigPtr;
 
 class EventHandler;
@@ -38,7 +44,7 @@ typedef std::shared_ptr<WebSocketApi> WebSocketApiPtr;
 class WebSocketServer;
 typedef std::shared_ptr<WebSocketServer> WebSocketServerPtr;
 
-os_cpu_usage_info_t *GetCpuUsageInfo();
+os_cpu_usage_info_t* GetCpuUsageInfo();
 
 ConfigPtr GetConfig();
 

src/requesthandler/RequestBatchHandler.cpp

@@ -24,7 +24,8 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #include "../utils/Compat.h"
 #include "../obs-websocket.h"
 
-struct SerialFrameBatch {
+struct SerialFrameBatch
+{
 	RequestHandler &requestHandler;
 	std::queue<RequestBatchRequest> requests;
 	std::vector<RequestResult> results;
@@ -36,46 +37,43 @@ struct SerialFrameBatch {
 	std::mutex conditionMutex;
 	std::condition_variable condition;
 
-	SerialFrameBatch(RequestHandler &requestHandler, json &variables, bool haltOnFailure)
+	SerialFrameBatch(RequestHandler &requestHandler, json &variables, bool haltOnFailure) :
-		: requestHandler(requestHandler),
+		requestHandler(requestHandler),
-		  variables(variables),
+		variables(variables),
-		  haltOnFailure(haltOnFailure),
+		haltOnFailure(haltOnFailure),
-		  frameCount(0),
+		frameCount(0),
-		  sleepUntilFrame(0)
+		sleepUntilFrame(0)
-	{
+	{}
-	}
 };
 
-struct ParallelBatchResults {
+struct ParallelBatchResults
+{
 	RequestHandler &requestHandler;
 	std::vector<RequestResult> results;
 
 	std::mutex conditionMutex;
 	std::condition_variable condition;
 
-	ParallelBatchResults(RequestHandler &requestHandler) : requestHandler(requestHandler) {}
+	ParallelBatchResults(RequestHandler &requestHandler) :
+		requestHandler(requestHandler)
+	{}
 };
 
 // `{"inputName": "inputNameVariable"}` is essentially `inputName = inputNameVariable`
 static void PreProcessVariables(const json &variables, RequestBatchRequest &request)
 {
-	if (variables.empty() || !request.InputVariables.is_object() || request.InputVariables.empty() ||
+	if (variables.empty() || !request.InputVariables.is_object() || request.InputVariables.empty() || !request.RequestData.is_object())
-	    !request.RequestData.is_object())
 		return;
 
-	for (auto &[key, value] : request.InputVariables.items()) {
+	for (auto& [key, value] : request.InputVariables.items()) {
 		if (!value.is_string()) {
-			blog_debug(
+			blog_debug("[WebSocketServer::ProcessRequestBatch] Value of field `%s` in `inputVariables `is not a string. Skipping!", key.c_str());
-				"[WebSocketServer::ProcessRequestBatch] Value of field `%s` in `inputVariables `is not a string. Skipping!",
-				key.c_str());
 			continue;
 		}
 
 		std::string valueString = value;
 		if (!variables.contains(valueString)) {
-			blog_debug(
+			blog_debug("[WebSocketServer::ProcessRequestBatch] `inputVariables` requested variable `%s`, but it does not exist. Skipping!", valueString.c_str());
-				"[WebSocketServer::ProcessRequestBatch] `inputVariables` requested variable `%s`, but it does not exist. Skipping!",
-				valueString.c_str());
 			continue;
 		}
 
@@ -91,19 +89,15 @@ static void PostProcessVariables(json &variables, const RequestBatchRequest &req
 	if (!request.OutputVariables.is_object() || request.OutputVariables.empty() || requestResult.ResponseData.empty())
 		return;
 
-	for (auto &[key, value] : request.OutputVariables.items()) {
+	for (auto& [key, value] : request.OutputVariables.items()) {
 		if (!value.is_string()) {
-			blog_debug(
+			blog_debug("[WebSocketServer::ProcessRequestBatch] Value of field `%s` in `outputVariables` is not a string. Skipping!", key.c_str());
-				"[WebSocketServer::ProcessRequestBatch] Value of field `%s` in `outputVariables` is not a string. Skipping!",
-				key.c_str());
 			continue;
 		}
 
 		std::string valueString = value;
 		if (!requestResult.ResponseData.contains(valueString)) {
-			blog_debug(
+			blog_debug("[WebSocketServer::ProcessRequestBatch] `outputVariables` requested responseData field `%s`, but it does not exist. Skipping!", valueString.c_str());
-				"[WebSocketServer::ProcessRequestBatch] `outputVariables` requested responseData field `%s`, but it does not exist. Skipping!",
-				valueString.c_str());
 			continue;
 		}
 
@@ -115,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++;
@@ -162,10 +156,7 @@ static void ObsTickCallback(void *param, float)
 		serialFrameBatch->condition.notify_one();
 }
 
-std::vector<RequestResult>
+std::vector<RequestResult> RequestBatchHandler::ProcessRequestBatch(QThreadPool &threadPool, SessionPtr session, RequestBatchExecutionType::RequestBatchExecutionType executionType, std::vector<RequestBatchRequest> &requests, json &variables, bool haltOnFailure)
-RequestBatchHandler::ProcessRequestBatch(QThreadPool &threadPool, SessionPtr session,
-					 RequestBatchExecutionType::RequestBatchExecutionType executionType,
-					 std::vector<RequestBatchRequest> &requests, json &variables, bool haltOnFailure)
 {
 	RequestHandler requestHandler(session);
 	if (executionType == RequestBatchExecutionType::SerialRealtime) {
@@ -198,7 +189,7 @@ RequestBatchHandler::ProcessRequestBatch(QThreadPool &threadPool, SessionPtr ses
 
 		// Wait until the graphics thread processes the last request in the queue
 		std::unique_lock<std::mutex> lock(serialFrameBatch.conditionMutex);
-		serialFrameBatch.condition.wait(lock, [&serialFrameBatch] { return serialFrameBatch.requests.empty(); });
+		serialFrameBatch.condition.wait(lock, [&serialFrameBatch]{return serialFrameBatch.requests.empty();});
 
 		// Remove the created callback entry since we don't need it anymore
 		obs_remove_tick_callback(ObsTickCallback, &serialFrameBatch);
@@ -224,9 +215,7 @@ RequestBatchHandler::ProcessRequestBatch(QThreadPool &threadPool, SessionPtr ses
 
 		// Wait for the last request to finish processing
 		size_t requestCount = requests.size();
-		parallelResults.condition.wait(lock, [&parallelResults, requestCount] {
+		parallelResults.condition.wait(lock, [&parallelResults, requestCount]{return parallelResults.results.size() == requestCount;});
-			return parallelResults.results.size() == requestCount;
-		});
 
 		return parallelResults.results;
 	}

src/requesthandler/RequestBatchHandler.h

@@ -24,8 +24,5 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #include "rpc/RequestBatchRequest.h"
 
 namespace RequestBatchHandler {
-	std::vector<RequestResult> ProcessRequestBatch(QThreadPool &threadPool, SessionPtr session,
+	std::vector<RequestResult> ProcessRequestBatch(QThreadPool &threadPool, SessionPtr session, RequestBatchExecutionType::RequestBatchExecutionType executionType, std::vector<RequestBatchRequest> &requests, json &variables, bool haltOnFailure);
-						       RequestBatchExecutionType::RequestBatchExecutionType executionType,
-						       std::vector<RequestBatchRequest> &requests, json &variables,
-						       bool haltOnFailure);
 }

src/requesthandler/RequestHandler.cpp

@@ -17,13 +17,10 @@ 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},
 	{"GetStats", &RequestHandler::GetStats},
@@ -50,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},
@@ -69,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},
@@ -87,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},
 
@@ -105,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},
@@ -135,36 +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},
-	{"GetSceneItemPrivateSettings", &RequestHandler::GetSceneItemPrivateSettings},
-	{"SetSceneItemPrivateSettings", &RequestHandler::SetSceneItemPrivateSettings},
-
-	// 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},
-	{"GetOutputList", &RequestHandler::GetOutputList},
-	{"GetOutputStatus", &RequestHandler::GetOutputStatus},
-	{"ToggleOutput", &RequestHandler::ToggleOutput},
-	{"StartOutput", &RequestHandler::StartOutput},
-	{"StopOutput", &RequestHandler::StopOutput},
-	{"GetOutputSettings", &RequestHandler::GetOutputSettings},
-	{"SetOutputSettings", &RequestHandler::SetOutputSettings},
 
 	// Stream
 	{"GetStreamStatus", &RequestHandler::GetStreamStatus},
 	{"ToggleStream", &RequestHandler::ToggleStream},
 	{"StartStream", &RequestHandler::StartStream},
 	{"StopStream", &RequestHandler::StopStream},
-	{"SendStreamCaption", &RequestHandler::SendStreamCaption},
 
 	// Record
 	{"GetRecordStatus", &RequestHandler::GetRecordStatus},
@@ -174,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},
@@ -184,32 +134,25 @@ 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},
-	{"GetMonitorList", &RequestHandler::GetMonitorList},
-	{"OpenVideoMixProjector", &RequestHandler::OpenVideoMixProjector},
-	{"OpenSourceProjector", &RequestHandler::OpenSourceProjector},
 };
 
-RequestHandler::RequestHandler(SessionPtr session) : _session(session) {}
+RequestHandler::RequestHandler(SessionPtr session) :
-
+	_session(session)
-RequestResult RequestHandler::ProcessRequest(const Request &request)
 {
-#ifdef PLUGIN_TESTS
+}
-	ScopeProfiler prof{"obs_websocket_request_processing"};
-#endif
 
+RequestResult RequestHandler::ProcessRequest(const Request& request)
+{
 	if (!request.RequestData.is_object() && !request.RequestData.is_null())
 		return RequestResult::Error(RequestStatus::InvalidRequestFieldType, "Your request data is not an object.");
 
 	if (request.RequestType.empty())
-		return RequestResult::Error(RequestStatus::MissingRequestType, "Your request's `requestType` may not be empty.");
+		return RequestResult::Error(RequestStatus::MissingRequestType, "Your request is missing a `requestType`");
 
 	RequestMethodHandler handler;
 	try {
 		handler = _handlerMap.at(request.RequestType);
-	} catch (const std::out_of_range &oor) {
+	} catch (const std::out_of_range& oor) {
 		return RequestResult::Error(RequestStatus::UnknownRequestType, "Your request type is not valid.");
 	}
 
@@ -219,7 +162,7 @@ RequestResult RequestHandler::ProcessRequest(const Request &request)
 std::vector<std::string> RequestHandler::GetRequestList()
 {
 	std::vector<std::string> ret;
-	for (auto const &[key, val] : _handlerMap) {
+	for (auto const& [key, val] : _handlerMap) {
 		ret.push_back(key);
 	}
 

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>
 
@@ -33,183 +33,130 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #include "../plugin-macros.generated.h"
 
 class RequestHandler;
-typedef RequestResult (RequestHandler::*RequestMethodHandler)(const Request &);
+typedef RequestResult(RequestHandler::*RequestMethodHandler)(const Request&);
 
 class RequestHandler {
-public:
+	public:
-	RequestHandler(SessionPtr session = nullptr);
+		RequestHandler(SessionPtr session);
 
-	RequestResult ProcessRequest(const Request &request);
+		RequestResult ProcessRequest(const Request& request);
-	std::vector<std::string> GetRequestList();
+		std::vector<std::string> GetRequestList();
 
-private:
+	private:
-	// General
+		// General
-	RequestResult GetVersion(const Request &);
+		RequestResult GetVersion(const Request&);
-	RequestResult GetStats(const Request &);
+		RequestResult GetStats(const Request&);
-	RequestResult BroadcastCustomEvent(const Request &);
+		RequestResult BroadcastCustomEvent(const Request&);
-	RequestResult CallVendorRequest(const Request &);
+		RequestResult CallVendorRequest(const Request&);
-	RequestResult GetHotkeyList(const Request &);
+		RequestResult GetHotkeyList(const Request&);
-	RequestResult TriggerHotkeyByName(const Request &);
+		RequestResult TriggerHotkeyByName(const Request&);
-	RequestResult TriggerHotkeyByKeySequence(const Request &);
+		RequestResult TriggerHotkeyByKeySequence(const Request&);
-	RequestResult Sleep(const Request &);
+		RequestResult Sleep(const Request&);
 
-	// Config
+		// Config
-	RequestResult GetPersistentData(const Request &);
+		RequestResult GetPersistentData(const Request&);
-	RequestResult SetPersistentData(const Request &);
+		RequestResult SetPersistentData(const Request&);
-	RequestResult GetSceneCollectionList(const Request &);
+		RequestResult GetSceneCollectionList(const Request&);
-	RequestResult SetCurrentSceneCollection(const Request &);
+		RequestResult SetCurrentSceneCollection(const Request&);
-	RequestResult CreateSceneCollection(const Request &);
+		RequestResult CreateSceneCollection(const Request&);
-	RequestResult GetProfileList(const Request &);
+		RequestResult GetProfileList(const Request&);
-	RequestResult SetCurrentProfile(const Request &);
+		RequestResult SetCurrentProfile(const Request&);
-	RequestResult CreateProfile(const Request &);
+		RequestResult CreateProfile(const Request&);
-	RequestResult RemoveProfile(const Request &);
+		RequestResult RemoveProfile(const Request&);
-	RequestResult GetProfileParameter(const Request &);
+		RequestResult GetProfileParameter(const Request&);
-	RequestResult SetProfileParameter(const Request &);
+		RequestResult SetProfileParameter(const Request&);
-	RequestResult GetVideoSettings(const Request &);
+		RequestResult GetVideoSettings(const Request&);
-	RequestResult SetVideoSettings(const Request &);
+		RequestResult SetVideoSettings(const Request&);
-	RequestResult GetStreamServiceSettings(const Request &);
+		RequestResult GetStreamServiceSettings(const Request&);
-	RequestResult SetStreamServiceSettings(const Request &);
+		RequestResult SetStreamServiceSettings(const Request&);
-	RequestResult GetRecordDirectory(const Request &);
 
-	// Sources
+		// Sources
-	RequestResult GetSourceActive(const Request &);
+		RequestResult GetSourceActive(const Request&);
-	RequestResult GetSourceScreenshot(const Request &);
+		RequestResult GetSourceScreenshot(const Request&);
-	RequestResult SaveSourceScreenshot(const Request &);
+		RequestResult SaveSourceScreenshot(const Request&);
-	RequestResult GetSourcePrivateSettings(const Request &);
-	RequestResult SetSourcePrivateSettings(const Request &);
 
-	// Scenes
+		// Scenes
-	RequestResult GetSceneList(const Request &);
+		RequestResult GetSceneList(const Request&);
-	RequestResult GetGroupList(const Request &);
+		RequestResult GetCurrentProgramScene(const Request&);
-	RequestResult GetCurrentProgramScene(const Request &);
+		RequestResult SetCurrentProgramScene(const Request&);
-	RequestResult SetCurrentProgramScene(const Request &);
+		RequestResult GetCurrentPreviewScene(const Request&);
-	RequestResult GetCurrentPreviewScene(const Request &);
+		RequestResult SetCurrentPreviewScene(const Request&);
-	RequestResult SetCurrentPreviewScene(const Request &);
+		RequestResult CreateScene(const Request&);
-	RequestResult CreateScene(const Request &);
+		RequestResult RemoveScene(const Request&);
-	RequestResult RemoveScene(const Request &);
+		RequestResult SetSceneName(const Request&);
-	RequestResult SetSceneName(const Request &);
-	RequestResult GetSceneSceneTransitionOverride(const Request &);
-	RequestResult SetSceneSceneTransitionOverride(const Request &);
 
-	// Inputs
+		// Inputs
-	RequestResult GetInputList(const Request &);
+		RequestResult GetInputList(const Request&);
-	RequestResult GetInputKindList(const Request &);
+		RequestResult GetInputKindList(const Request&);
-	RequestResult GetSpecialInputs(const Request &);
+		RequestResult CreateInput(const Request&);
-	RequestResult CreateInput(const Request &);
+		RequestResult RemoveInput(const Request&);
-	RequestResult RemoveInput(const Request &);
+		RequestResult SetInputName(const Request&);
-	RequestResult SetInputName(const Request &);
+		RequestResult GetInputDefaultSettings(const Request&);
-	RequestResult GetInputDefaultSettings(const Request &);
+		RequestResult GetInputSettings(const Request&);
-	RequestResult GetInputSettings(const Request &);
+		RequestResult SetInputSettings(const Request&);
-	RequestResult SetInputSettings(const Request &);
+		RequestResult GetInputMute(const Request&);
-	RequestResult GetInputMute(const Request &);
+		RequestResult SetInputMute(const Request&);
-	RequestResult SetInputMute(const Request &);
+		RequestResult ToggleInputMute(const Request&);
-	RequestResult ToggleInputMute(const Request &);
+		RequestResult GetInputVolume(const Request&);
-	RequestResult GetInputVolume(const Request &);
+		RequestResult SetInputVolume(const Request&);
-	RequestResult SetInputVolume(const Request &);
+		RequestResult GetInputAudioSyncOffset(const Request&);
-	RequestResult GetInputAudioBalance(const Request &);
+		RequestResult SetInputAudioSyncOffset(const Request&);
-	RequestResult SetInputAudioBalance(const Request &);
+		RequestResult GetInputAudioMonitorType(const Request&);
-	RequestResult GetInputAudioSyncOffset(const Request &);
+		RequestResult SetInputAudioMonitorType(const Request&);
-	RequestResult SetInputAudioSyncOffset(const Request &);
+		RequestResult GetInputPropertiesListPropertyItems(const Request&);
-	RequestResult GetInputAudioMonitorType(const Request &);
+		RequestResult PressInputPropertiesButton(const Request&);
-	RequestResult SetInputAudioMonitorType(const Request &);
-	RequestResult GetInputAudioTracks(const Request &);
-	RequestResult SetInputAudioTracks(const Request &);
-	RequestResult GetInputPropertiesListPropertyItems(const Request &);
-	RequestResult PressInputPropertiesButton(const Request &);
 
-	// Transitions
+		// Transitions
-	RequestResult GetTransitionKindList(const Request &);
+		RequestResult GetTransitionKindList(const Request&);
-	RequestResult GetSceneTransitionList(const Request &);
+		RequestResult GetSceneTransitionList(const Request&);
-	RequestResult GetCurrentSceneTransition(const Request &);
+		RequestResult GetCurrentSceneTransition(const Request&);
-	RequestResult SetCurrentSceneTransition(const Request &);
+		RequestResult SetCurrentSceneTransition(const Request&);
-	RequestResult SetCurrentSceneTransitionDuration(const Request &);
+		RequestResult SetCurrentSceneTransitionDuration(const Request&);
-	RequestResult SetCurrentSceneTransitionSettings(const Request &);
+		RequestResult SetCurrentSceneTransitionSettings(const Request&);
-	RequestResult GetCurrentSceneTransitionCursor(const Request &);
+		RequestResult TriggerStudioModeTransition(const Request&);
-	RequestResult TriggerStudioModeTransition(const Request &);
-	RequestResult SetTBarPosition(const Request &);
 
-	// Filters
+		// Scene Items
-	RequestResult GetSourceFilterList(const Request &);
+		RequestResult GetSceneItemList(const Request&);
-	RequestResult GetSourceFilterDefaultSettings(const Request &);
+		RequestResult GetGroupSceneItemList(const Request&);
-	RequestResult CreateSourceFilter(const Request &);
+		RequestResult GetSceneItemId(const Request&);
-	RequestResult RemoveSourceFilter(const Request &);
+		RequestResult CreateSceneItem(const Request&);
-	RequestResult SetSourceFilterName(const Request &);
+		RequestResult RemoveSceneItem(const Request&);
-	RequestResult GetSourceFilter(const Request &);
+		RequestResult DuplicateSceneItem(const Request&);
-	RequestResult SetSourceFilterIndex(const Request &);
+		RequestResult GetSceneItemTransform(const Request&);
-	RequestResult SetSourceFilterSettings(const Request &);
+		RequestResult SetSceneItemTransform(const Request&);
-	RequestResult SetSourceFilterEnabled(const Request &);
+		RequestResult GetSceneItemEnabled(const Request&);
+		RequestResult SetSceneItemEnabled(const Request&);
+		RequestResult GetSceneItemLocked(const Request&);
+		RequestResult SetSceneItemLocked(const Request&);
+		RequestResult GetSceneItemIndex(const Request&);
+		RequestResult SetSceneItemIndex(const Request&);
 
-	// Scene Items
+		// Stream
-	RequestResult GetSceneItemList(const Request &);
+		RequestResult GetStreamStatus(const Request&);
-	RequestResult GetGroupSceneItemList(const Request &);
+		RequestResult ToggleStream(const Request&);
-	RequestResult GetSceneItemId(const Request &);
+		RequestResult StartStream(const Request&);
-	RequestResult CreateSceneItem(const Request &);
+		RequestResult StopStream(const Request&);
-	RequestResult RemoveSceneItem(const Request &);
-	RequestResult DuplicateSceneItem(const Request &);
-	RequestResult GetSceneItemTransform(const Request &);
-	RequestResult SetSceneItemTransform(const Request &);
-	RequestResult GetSceneItemEnabled(const Request &);
-	RequestResult SetSceneItemEnabled(const Request &);
-	RequestResult GetSceneItemLocked(const Request &);
-	RequestResult SetSceneItemLocked(const Request &);
-	RequestResult GetSceneItemIndex(const Request &);
-	RequestResult SetSceneItemIndex(const Request &);
-	RequestResult GetSceneItemBlendMode(const Request &);
-	RequestResult SetSceneItemBlendMode(const Request &);
-	RequestResult GetSceneItemPrivateSettings(const Request &);
-	RequestResult SetSceneItemPrivateSettings(const Request &);
 
-	// Outputs
+		// Record
-	RequestResult GetVirtualCamStatus(const Request &);
+		RequestResult GetRecordStatus(const Request&);
-	RequestResult ToggleVirtualCam(const Request &);
+		RequestResult ToggleRecord(const Request&);
-	RequestResult StartVirtualCam(const Request &);
+		RequestResult StartRecord(const Request&);
-	RequestResult StopVirtualCam(const Request &);
+		RequestResult StopRecord(const Request&);
-	RequestResult GetReplayBufferStatus(const Request &);
+		RequestResult ToggleRecordPause(const Request&);
-	RequestResult ToggleReplayBuffer(const Request &);
+		RequestResult PauseRecord(const Request&);
-	RequestResult StartReplayBuffer(const Request &);
+		RequestResult ResumeRecord(const Request&);
-	RequestResult StopReplayBuffer(const Request &);
+		RequestResult GetRecordDirectory(const Request&);
-	RequestResult SaveReplayBuffer(const Request &);
-	RequestResult GetLastReplayBufferReplay(const Request &);
-	RequestResult GetOutputList(const Request &);
-	RequestResult GetOutputStatus(const Request &);
-	RequestResult ToggleOutput(const Request &);
-	RequestResult StartOutput(const Request &);
-	RequestResult StopOutput(const Request &);
-	RequestResult GetOutputSettings(const Request &);
-	RequestResult SetOutputSettings(const Request &);
 
-	// Stream
+		// Media Inputs
-	RequestResult GetStreamStatus(const Request &);
+		RequestResult GetMediaInputStatus(const Request&);
-	RequestResult ToggleStream(const Request &);
+		RequestResult SetMediaInputCursor(const Request&);
-	RequestResult StartStream(const Request &);
+		RequestResult OffsetMediaInputCursor(const Request&);
-	RequestResult StopStream(const Request &);
+		RequestResult TriggerMediaInputAction(const Request&);
-	RequestResult SendStreamCaption(const Request &);
 
-	// Record
+		// Ui
-	RequestResult GetRecordStatus(const Request &);
+		RequestResult GetStudioModeEnabled(const Request&);
-	RequestResult ToggleRecord(const Request &);
+		RequestResult SetStudioModeEnabled(const Request&);
-	RequestResult StartRecord(const Request &);
-	RequestResult StopRecord(const Request &);
-	RequestResult ToggleRecordPause(const Request &);
-	RequestResult PauseRecord(const Request &);
-	RequestResult ResumeRecord(const Request &);
 
-	// Media Inputs
+		SessionPtr _session;
-	RequestResult GetMediaInputStatus(const Request &);
+		static const std::map<std::string, RequestMethodHandler> _handlerMap;
-	RequestResult SetMediaInputCursor(const Request &);
-	RequestResult OffsetMediaInputCursor(const Request &);
-	RequestResult TriggerMediaInputAction(const Request &);
-
-	// Ui
-	RequestResult GetStudioModeEnabled(const Request &);
-	RequestResult SetStudioModeEnabled(const Request &);
-	RequestResult OpenInputPropertiesDialog(const Request &);
-	RequestResult OpenInputFiltersDialog(const Request &);
-	RequestResult OpenInputInteractDialog(const Request &);
-	RequestResult GetMonitorList(const Request &);
-	RequestResult OpenVideoMixProjector(const Request &);
-	RequestResult OpenSourceProjector(const Request &);
-
-	SessionPtr _session;
-	static const std::unordered_map<std::string, RequestMethodHandler> _handlerMap;
 };

src/requesthandler/RequestHandler_Config.cpp

@@ -37,7 +37,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
  * @category config
  * @api requests
  */
-RequestResult RequestHandler::GetPersistentData(const Request &request)
+RequestResult RequestHandler::GetPersistentData(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -53,8 +53,7 @@ RequestResult RequestHandler::GetPersistentData(const Request &request)
 	else if (realm == "OBS_WEBSOCKET_DATA_REALM_PROFILE")
 		persistentDataPath += "/obsWebSocketPersistentData.json";
 	else
-		return RequestResult::Error(RequestStatus::ResourceNotFound,
+		return RequestResult::Error(RequestStatus::ResourceNotFound, "You have specified an invalid persistent data realm.");
-					    "You have specified an invalid persistent data realm.");
 
 	json responseData;
 	json persistentData;
@@ -80,12 +79,11 @@ RequestResult RequestHandler::GetPersistentData(const Request &request)
  * @category config
  * @api requests
  */
-RequestResult RequestHandler::SetPersistentData(const Request &request)
+RequestResult RequestHandler::SetPersistentData(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
-	if (!(request.ValidateString("realm", statusCode, comment) && request.ValidateString("slotName", statusCode, comment) &&
+	if (!(request.ValidateString("realm", statusCode, comment) && request.ValidateString("slotName", statusCode, comment) && request.ValidateBasic("slotValue", statusCode, comment)))
-	      request.ValidateBasic("slotValue", statusCode, comment)))
 		return RequestResult::Error(statusCode, comment);
 
 	std::string realm = request.RequestData["realm"];
@@ -98,15 +96,13 @@ RequestResult RequestHandler::SetPersistentData(const Request &request)
 	else if (realm == "OBS_WEBSOCKET_DATA_REALM_PROFILE")
 		persistentDataPath += "/obsWebSocketPersistentData.json";
 	else
-		return RequestResult::Error(RequestStatus::ResourceNotFound,
+		return RequestResult::Error(RequestStatus::ResourceNotFound, "You have specified an invalid persistent data realm.");
-					    "You have specified an invalid persistent data realm.");
 
 	json persistentData = json::object();
 	Utils::Json::GetJsonFileContent(persistentDataPath, persistentData);
 	persistentData[slotName] = slotValue;
 	if (!Utils::Json::SetJsonFileContent(persistentDataPath, persistentData))
-		return RequestResult::Error(RequestStatus::RequestProcessingFailed,
+		return RequestResult::Error(RequestStatus::RequestProcessingFailed, "Unable to write persistent data. No permissions?");
-					    "Unable to write persistent data. No permissions?");
 
 	return RequestResult::Success();
 }
@@ -124,7 +120,7 @@ RequestResult RequestHandler::SetPersistentData(const Request &request)
  * @category config
  * @api requests
  */
-RequestResult RequestHandler::GetSceneCollectionList(const Request &)
+RequestResult RequestHandler::GetSceneCollectionList(const Request&)
 {
 	json responseData;
 	responseData["currentSceneCollectionName"] = Utils::Obs::StringHelper::GetCurrentSceneCollection();
@@ -146,7 +142,7 @@ RequestResult RequestHandler::GetSceneCollectionList(const Request &)
  * @category config
  * @api requests
  */
-RequestResult RequestHandler::SetCurrentSceneCollection(const Request &request)
+RequestResult RequestHandler::SetCurrentSceneCollection(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -162,10 +158,9 @@ RequestResult RequestHandler::SetCurrentSceneCollection(const Request &request)
 	std::string currentSceneCollectionName = Utils::Obs::StringHelper::GetCurrentSceneCollection();
 	// Avoid queueing tasks if nothing will change
 	if (currentSceneCollectionName != sceneCollectionName) {
-		obs_queue_task(
+		obs_queue_task(OBS_TASK_UI, [](void* param) {
-			OBS_TASK_UI,
+			obs_frontend_set_current_scene_collection(reinterpret_cast<const char*>(param));
-			[](void *param) { obs_frontend_set_current_scene_collection(static_cast<const char *>(param)); },
+		}, (void*)sceneCollectionName.c_str(), true);
-			(void *)sceneCollectionName.c_str(), true);
 	}
 
 	return RequestResult::Success();
@@ -185,7 +180,7 @@ RequestResult RequestHandler::SetCurrentSceneCollection(const Request &request)
  * @category config
  * @api requests
  */
-RequestResult RequestHandler::CreateSceneCollection(const Request &request)
+RequestResult RequestHandler::CreateSceneCollection(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -198,10 +193,9 @@ 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),
+	QMetaObject::invokeMethod(mainWindow, "AddSceneCollection", Qt::BlockingQueuedConnection, Q_RETURN_ARG(bool, success), Q_ARG(bool, true), Q_ARG(QString, QString::fromStdString(sceneCollectionName)));
-				  Q_ARG(bool, true), Q_ARG(QString, QString::fromStdString(sceneCollectionName)));
 	if (!success)
 		return RequestResult::Error(RequestStatus::ResourceCreationFailed, "Failed to create the scene collection.");
 
@@ -221,7 +215,7 @@ RequestResult RequestHandler::CreateSceneCollection(const Request &request)
  * @category config
  * @api requests
  */
-RequestResult RequestHandler::GetProfileList(const Request &)
+RequestResult RequestHandler::GetProfileList(const Request&)
 {
 	json responseData;
 	responseData["currentProfileName"] = Utils::Obs::StringHelper::GetCurrentProfile();
@@ -241,7 +235,7 @@ RequestResult RequestHandler::GetProfileList(const Request &)
  * @category config
  * @api requests
  */
-RequestResult RequestHandler::SetCurrentProfile(const Request &request)
+RequestResult RequestHandler::SetCurrentProfile(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -257,9 +251,9 @@ RequestResult RequestHandler::SetCurrentProfile(const Request &request)
 	std::string currentProfileName = Utils::Obs::StringHelper::GetCurrentProfile();
 	// Avoid queueing tasks if nothing will change
 	if (currentProfileName != profileName) {
-		obs_queue_task(
+		obs_queue_task(OBS_TASK_UI, [](void* param) {
-			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);
+		}, (void*)profileName.c_str(), true);
 	}
 
 	return RequestResult::Success();
@@ -277,7 +271,7 @@ RequestResult RequestHandler::SetCurrentProfile(const Request &request)
  * @category config
  * @api requests
  */
-RequestResult RequestHandler::CreateProfile(const Request &request)
+RequestResult RequestHandler::CreateProfile(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -290,9 +284,8 @@ 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,
+	QMetaObject::invokeMethod(mainWindow, "NewProfile", Qt::BlockingQueuedConnection, Q_ARG(QString, QString::fromStdString(profileName)));
-				  Q_ARG(QString, QString::fromStdString(profileName)));
 
 	return RequestResult::Success();
 }
@@ -309,7 +302,7 @@ RequestResult RequestHandler::CreateProfile(const Request &request)
  * @category config
  * @api requests
  */
-RequestResult RequestHandler::RemoveProfile(const Request &request)
+RequestResult RequestHandler::RemoveProfile(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -325,9 +318,8 @@ 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,
+	QMetaObject::invokeMethod(mainWindow, "DeleteProfile", Qt::BlockingQueuedConnection, Q_ARG(QString, QString::fromStdString(profileName)));
-				  Q_ARG(QString, QString::fromStdString(profileName)));
 
 	return RequestResult::Success();
 }
@@ -348,18 +340,17 @@ RequestResult RequestHandler::RemoveProfile(const Request &request)
  * @category config
  * @api requests
  */
-RequestResult RequestHandler::GetProfileParameter(const Request &request)
+RequestResult RequestHandler::GetProfileParameter(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
-	if (!(request.ValidateString("parameterCategory", statusCode, comment) &&
+	if (!(request.ValidateString("parameterCategory", statusCode, comment) && request.ValidateString("parameterName", statusCode, comment)))
-	      request.ValidateString("parameterName", statusCode, comment)))
 		return RequestResult::Error(statusCode, comment);
 
 	std::string parameterCategory = request.RequestData["parameterCategory"];
 	std::string parameterName = request.RequestData["parameterName"];
 
-	config_t *profile = obs_frontend_get_profile_config();
+	config_t* profile = obs_frontend_get_profile_config();
 
 	if (!profile)
 		blog(LOG_ERROR, "[RequestHandler::GetProfileParameter] Profile is invalid.");
@@ -367,8 +358,7 @@ RequestResult RequestHandler::GetProfileParameter(const Request &request)
 	json responseData;
 	if (config_has_default_value(profile, parameterCategory.c_str(), parameterName.c_str())) {
 		responseData["parameterValue"] = config_get_string(profile, parameterCategory.c_str(), parameterName.c_str());
-		responseData["defaultParameterValue"] =
+		responseData["defaultParameterValue"] = config_get_default_string(profile, parameterCategory.c_str(), parameterName.c_str());
-			config_get_default_string(profile, parameterCategory.c_str(), parameterName.c_str());
 	} else if (config_has_user_value(profile, parameterCategory.c_str(), parameterName.c_str())) {
 		responseData["parameterValue"] = config_get_string(profile, parameterCategory.c_str(), parameterName.c_str());
 		responseData["defaultParameterValue"] = nullptr;
@@ -394,24 +384,23 @@ RequestResult RequestHandler::GetProfileParameter(const Request &request)
  * @category config
  * @api requests
  */
-RequestResult RequestHandler::SetProfileParameter(const Request &request)
+RequestResult RequestHandler::SetProfileParameter(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
 	if (!(request.ValidateString("parameterCategory", statusCode, comment) &&
-	      request.ValidateString("parameterName", statusCode, comment)))
+	request.ValidateString("parameterName", statusCode, comment)))
 		return RequestResult::Error(statusCode, comment);
 
 	std::string parameterCategory = request.RequestData["parameterCategory"];
 	std::string parameterName = request.RequestData["parameterName"];
 
-	config_t *profile = obs_frontend_get_profile_config();
+	config_t* profile = obs_frontend_get_profile_config();
 
 	// Using check helpers here would just make the logic more complicated
 	if (!request.RequestData.contains("parameterValue") || request.RequestData["parameterValue"].is_null()) {
 		if (!config_remove_value(profile, parameterCategory.c_str(), parameterName.c_str()))
-			return RequestResult::Error(RequestStatus::ResourceNotFound,
+			return RequestResult::Error(RequestStatus::ResourceNotFound, "There are no existing instances of that profile parameter.");
-						    "There are no existing instances of that profile parameter.");
 	} else if (request.RequestData["parameterValue"].is_string()) {
 		std::string parameterValue = request.RequestData["parameterValue"];
 		config_set_string(profile, parameterCategory.c_str(), parameterName.c_str(), parameterValue.c_str());
@@ -419,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();
 }
 
@@ -443,7 +430,7 @@ RequestResult RequestHandler::SetProfileParameter(const Request &request)
  * @category config
  * @api requests
  */
-RequestResult RequestHandler::GetVideoSettings(const Request &)
+RequestResult RequestHandler::GetVideoSettings(const Request&)
 {
 	struct obs_video_info ovi;
 	if (!obs_get_video_info(&ovi))
@@ -479,27 +466,23 @@ RequestResult RequestHandler::GetVideoSettings(const Request &)
  * @category config
  * @api requests
  */
-RequestResult RequestHandler::SetVideoSettings(const Request &request)
+RequestResult RequestHandler::SetVideoSettings(const Request& request)
 {
 	if (obs_video_active())
-		return RequestResult::Error(RequestStatus::OutputRunning,
+		return RequestResult::Error(RequestStatus::OutputRunning, "Video settings cannot be changed while an output is active.");
-					    "Video settings cannot be changed while an output is active.");
 
 	RequestStatus::RequestStatus statusCode = RequestStatus::NoError;
 	std::string comment;
 	bool changeFps = (request.Contains("fpsNumerator") && request.Contains("fpsDenominator"));
-	if (changeFps && !(request.ValidateOptionalNumber("fpsNumerator", statusCode, comment, 1) &&
+	if (changeFps && !(request.ValidateOptionalNumber("fpsNumerator", statusCode, comment, 1) && request.ValidateOptionalNumber("fpsDenominator", statusCode, comment, 1)))
-			   request.ValidateOptionalNumber("fpsDenominator", statusCode, comment, 1)))
 		return RequestResult::Error(statusCode, comment);
 
 	bool changeBaseRes = (request.Contains("baseWidth") && request.Contains("baseHeight"));
-	if (changeBaseRes && !(request.ValidateOptionalNumber("baseWidth", statusCode, comment, 8, 4096) &&
+	if (changeBaseRes && !(request.ValidateOptionalNumber("baseWidth", statusCode, comment, 8, 4096) && request.ValidateOptionalNumber("baseHeight", statusCode, comment, 8, 4096)))
-			       request.ValidateOptionalNumber("baseHeight", statusCode, comment, 8, 4096)))
 		return RequestResult::Error(statusCode, comment);
 
 	bool changeOutputRes = (request.Contains("outputWidth") && request.Contains("outputHeight"));
-	if (changeOutputRes && !(request.ValidateOptionalNumber("outputWidth", statusCode, comment, 8, 4096) &&
+	if (changeOutputRes && !(request.ValidateOptionalNumber("outputWidth", statusCode, comment, 8, 4096) && request.ValidateOptionalNumber("outputHeight", statusCode, comment, 8, 4096)))
-				 request.ValidateOptionalNumber("outputHeight", statusCode, comment, 8, 4096)))
 		return RequestResult::Error(statusCode, comment);
 
 	config_t *config = obs_frontend_get_profile_config();
@@ -542,7 +525,7 @@ RequestResult RequestHandler::SetVideoSettings(const Request &request)
  * @category config
  * @api requests
  */
-RequestResult RequestHandler::GetStreamServiceSettings(const Request &)
+RequestResult RequestHandler::GetStreamServiceSettings(const Request&)
 {
 	json responseData;
 
@@ -569,24 +552,21 @@ RequestResult RequestHandler::GetStreamServiceSettings(const Request &)
  * @category config
  * @api requests
  */
-RequestResult RequestHandler::SetStreamServiceSettings(const Request &request)
+RequestResult RequestHandler::SetStreamServiceSettings(const Request& request)
 {
 	if (obs_frontend_streaming_active())
-		return RequestResult::Error(RequestStatus::OutputRunning,
+		return RequestResult::Error(RequestStatus::OutputRunning, "You cannot change stream service settings while streaming.");
-					    "You cannot change stream service settings while streaming.");
 
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
-	if (!(request.ValidateString("streamServiceType", statusCode, comment) &&
+	if (!(request.ValidateString("streamServiceType", statusCode, comment) && request.ValidateObject("streamServiceSettings", statusCode, comment)))
-	      request.ValidateObject("streamServiceSettings", statusCode, comment)))
 		return RequestResult::Error(statusCode, comment);
 
 	OBSService currentStreamService = obs_frontend_get_streaming_service();
 
 	std::string streamServiceType = obs_service_get_type(currentStreamService);
 	std::string requestedStreamServiceType = request.RequestData["streamServiceType"];
-	OBSDataAutoRelease requestedStreamServiceSettings =
+	OBSDataAutoRelease requestedStreamServiceSettings = Utils::Json::JsonToObsData(request.RequestData["streamServiceSettings"]);
-		Utils::Json::JsonToObsData(request.RequestData["streamServiceSettings"]);
 
 	// Don't create a new service if the current service is the same type.
 	if (streamServiceType == requestedStreamServiceType) {
@@ -600,13 +580,10 @@ RequestResult RequestHandler::SetStreamServiceSettings(const Request &request)
 		obs_service_update(currentStreamService, newStreamServiceSettings);
 	} else {
 		// TODO: This leaks memory. I have no idea why.
-		OBSService newStreamService = obs_service_create(requestedStreamServiceType.c_str(), "obs_websocket_custom_service",
+		OBSService newStreamService = obs_service_create(requestedStreamServiceType.c_str(), "obs_websocket_custom_service", requestedStreamServiceSettings, nullptr);
-								 requestedStreamServiceSettings, nullptr);
 		// TODO: Check service type here, instead of relying on service creation to fail.
 		if (!newStreamService)
-			return RequestResult::Error(
+			return RequestResult::Error(RequestStatus::ResourceCreationFailed, "Failed to create the stream service with the requested streamServiceType. It may be an invalid type.");
-				RequestStatus::ResourceCreationFailed,
-				"Failed to create the stream service with the requested streamServiceType. It may be an invalid type.");
 
 		obs_frontend_set_streaming_service(newStreamService);
 	}
@@ -615,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);
-}

src/requesthandler/RequestHandler_Filters.cpp

@@ -18,322 +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    | String  | 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();
-}

src/requesthandler/RequestHandler_General.cpp

@@ -18,7 +18,6 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 */
 
 #include <QImageWriter>
-#include <QSysInfo>
 
 #include "RequestHandler.h"
 #include "../websocketserver/WebSocketServer.h"
@@ -26,6 +25,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #include "../WebSocketApi.h"
 #include "../obs-websocket.h"
 
+
 /**
  * Gets data about the current plugin and RPC version.
  *
@@ -34,8 +34,6 @@ with this program. If not, see <https://www.gnu.org/licenses/>
  * @responseField rpcVersion            | Number        | Current latest obs-websocket RPC version
  * @responseField availableRequests     | Array<String> | Array of available RPC requests for the currently negotiated RPC version
  * @responseField supportedImageFormats | Array<String> | Image formats available in `GetSourceScreenshot` and `SaveSourceScreenshot` requests.
- * @responseField platform              | String        | Name of the platform. Usually `windows`, `macos`, or `ubuntu` (linux flavor). Not guaranteed to be any of those
- * @responseField platformDescription   | String        | Description of the platform, like `Windows 10 (10.0)`
  *
  * @requestType GetVersion
  * @complexity 1
@@ -44,7 +42,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
  * @category general
  * @api requests
  */
-RequestResult RequestHandler::GetVersion(const Request &)
+RequestResult RequestHandler::GetVersion(const Request&)
 {
 	json responseData;
 	responseData["obsVersion"] = Utils::Obs::StringHelper::GetObsVersion();
@@ -54,14 +52,11 @@ RequestResult RequestHandler::GetVersion(const Request &)
 
 	QList<QByteArray> imageWriterFormats = QImageWriter::supportedImageFormats();
 	std::vector<std::string> supportedImageFormats;
-	for (const QByteArray &format : imageWriterFormats) {
+	for (const QByteArray& format : imageWriterFormats) {
 		supportedImageFormats.push_back(format.toStdString());
 	}
 	responseData["supportedImageFormats"] = supportedImageFormats;
 
-	responseData["platform"] = QSysInfo::productType().toStdString();
-	responseData["platformDescription"] = QSysInfo::prettyProductName().toStdString();
-
 	return RequestResult::Success(responseData);
 }
 
@@ -87,17 +82,12 @@ RequestResult RequestHandler::GetVersion(const Request &)
  * @category general
  * @api requests
  */
-RequestResult RequestHandler::GetStats(const Request &)
+RequestResult RequestHandler::GetStats(const Request&)
 {
 	json responseData = Utils::Obs::ObjectHelper::GetStats();
 
-	if (_session) {
+	responseData["webSocketSessionIncomingMessages"] = _session->IncomingMessages();
-		responseData["webSocketSessionIncomingMessages"] = _session->IncomingMessages();
+	responseData["webSocketSessionOutgoingMessages"] = _session->OutgoingMessages();
-		responseData["webSocketSessionOutgoingMessages"] = _session->OutgoingMessages();
-	} else {
-		responseData["webSocketSessionIncomingMessages"] = nullptr;
-		responseData["webSocketSessionOutgoingMessages"] = nullptr;
-	}
 
 	return RequestResult::Success(responseData);
 }
@@ -114,7 +104,7 @@ RequestResult RequestHandler::GetStats(const Request &)
  * @category general
  * @api requests
  */
-RequestResult RequestHandler::BroadcastCustomEvent(const Request &request)
+RequestResult RequestHandler::BroadcastCustomEvent(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -140,8 +130,6 @@ RequestResult RequestHandler::BroadcastCustomEvent(const Request &request)
  * @requestField requestType  | String | The request type to call
  * @requestField ?requestData | Object | Object containing appropriate request data | {}
  *
- * @responseField vendorName   | String | Echoed of `vendorName`
- * @responseField requestType  | String | Echoed of `requestType`
  * @responseField responseData | Object | Object containing appropriate response data. {} if request does not provide any response data
  *
  * @requestType CallVendorRequest
@@ -151,12 +139,11 @@ RequestResult RequestHandler::BroadcastCustomEvent(const Request &request)
  * @category general
  * @api requests
  */
-RequestResult RequestHandler::CallVendorRequest(const Request &request)
+RequestResult RequestHandler::CallVendorRequest(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
-	if (!request.ValidateString("vendorName", statusCode, comment) ||
+	if (!request.ValidateString("vendorName", statusCode, comment) || !request.ValidateString("requestType", statusCode, comment))
-	    !request.ValidateString("requestType", statusCode, comment))
 		return RequestResult::Error(statusCode, comment);
 
 	std::string vendorName = request.RequestData["vendorName"];
@@ -174,23 +161,20 @@ RequestResult RequestHandler::CallVendorRequest(const Request &request)
 
 	auto webSocketApi = GetWebSocketApi();
 	if (!webSocketApi)
-		return RequestResult::Error(RequestStatus::RequestProcessingFailed,
+		return RequestResult::Error(RequestStatus::RequestProcessingFailed, "Unable to call request due to internal error.");
-					    "Unable to call request due to internal error.");
 
 	auto ret = webSocketApi->PerformVendorRequest(vendorName, requestType, requestData, obsResponseData);
 	switch (ret) {
-	default:
+		default:
-	case WebSocketApi::RequestReturnCode::Normal:
+		case WebSocketApi::RequestReturnCode::Normal:
-		break;
+			break;
-	case WebSocketApi::RequestReturnCode::NoVendor:
+		case WebSocketApi::RequestReturnCode::NoVendor:
-		return RequestResult::Error(RequestStatus::ResourceNotFound, "No vendor was found by that name.");
+			return RequestResult::Error(RequestStatus::ResourceNotFound, "No vendor was found by that name.");
-	case WebSocketApi::RequestReturnCode::NoVendorRequest:
+		case WebSocketApi::RequestReturnCode::NoVendorRequest:
-		return RequestResult::Error(RequestStatus::ResourceNotFound, "No request was found by that name.");
+			return RequestResult::Error(RequestStatus::ResourceNotFound, "No request was found by that name.");
 	}
 
 	json responseData;
-	responseData["vendorName"] = vendorName;
-	responseData["requestType"] = requestType;
 	responseData["responseData"] = Utils::Json::ObsDataToJson(obsResponseData);
 
 	return RequestResult::Success(responseData);
@@ -208,7 +192,7 @@ RequestResult RequestHandler::CallVendorRequest(const Request &request)
  * @category general
  * @api requests
  */
-RequestResult RequestHandler::GetHotkeyList(const Request &)
+RequestResult RequestHandler::GetHotkeyList(const Request&)
 {
 	json responseData;
 	responseData["hotkeys"] = Utils::Obs::ArrayHelper::GetHotkeyNameList();
@@ -227,7 +211,7 @@ RequestResult RequestHandler::GetHotkeyList(const Request &)
  * @category general
  * @api requests
  */
-RequestResult RequestHandler::TriggerHotkeyByName(const Request &request)
+RequestResult RequestHandler::TriggerHotkeyByName(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -260,7 +244,7 @@ RequestResult RequestHandler::TriggerHotkeyByName(const Request &request)
  * @category general
  * @api requests
  */
-RequestResult RequestHandler::TriggerHotkeyByKeySequence(const Request &request)
+RequestResult RequestHandler::TriggerHotkeyByKeySequence(const Request& request)
 {
 	obs_key_combination_t combo = {0};
 
@@ -282,23 +266,19 @@ RequestResult RequestHandler::TriggerHotkeyByKeySequence(const Request &request)
 
 		const json keyModifiersJson = request.RequestData["keyModifiers"];
 		uint32_t keyModifiers = 0;
-		if (keyModifiersJson.contains("shift") && keyModifiersJson["shift"].is_boolean() &&
+		if (keyModifiersJson.contains("shift") && keyModifiersJson["shift"].is_boolean() && keyModifiersJson["shift"].get<bool>())
-		    keyModifiersJson["shift"].get<bool>())
 			keyModifiers |= INTERACT_SHIFT_KEY;
-		if (keyModifiersJson.contains("control") && keyModifiersJson["control"].is_boolean() &&
+		if (keyModifiersJson.contains("control") && keyModifiersJson["control"].is_boolean() && keyModifiersJson["control"].get<bool>())
-		    keyModifiersJson["control"].get<bool>())
 			keyModifiers |= INTERACT_CONTROL_KEY;
 		if (keyModifiersJson.contains("alt") && keyModifiersJson["alt"].is_boolean() && keyModifiersJson["alt"].get<bool>())
 			keyModifiers |= INTERACT_ALT_KEY;
-		if (keyModifiersJson.contains("command") && keyModifiersJson["command"].is_boolean() &&
+		if (keyModifiersJson.contains("command") && keyModifiersJson["command"].is_boolean() && keyModifiersJson["command"].get<bool>())
-		    keyModifiersJson["command"].get<bool>())
 			keyModifiers |= INTERACT_COMMAND_KEY;
 		combo.modifiers = keyModifiers;
 	}
 
 	if (!combo.modifiers && (combo.key == OBS_KEY_NONE || combo.key >= OBS_KEY_LAST_VALUE))
-		return RequestResult::Error(RequestStatus::CannotAct,
+		return RequestResult::Error(RequestStatus::CannotAct, "Your provided request fields cannot be used to trigger a hotkey.");
-					    "Your provided request fields cannot be used to trigger a hotkey.");
 
 	// Apparently things break when you don't start by setting the combo to false
 	obs_hotkey_inject_event(combo, false);
@@ -321,7 +301,7 @@ RequestResult RequestHandler::TriggerHotkeyByKeySequence(const Request &request)
  * @category general
  * @api requests
  */
-RequestResult RequestHandler::Sleep(const Request &request)
+RequestResult RequestHandler::Sleep(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;

src/requesthandler/RequestHandler_Inputs.cpp

@@ -33,7 +33,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
  * @api requests
  * @category inputs
  */
-RequestResult RequestHandler::GetInputList(const Request &request)
+RequestResult RequestHandler::GetInputList(const Request& request)
 {
 	std::string inputKind;
 
@@ -65,7 +65,7 @@ RequestResult RequestHandler::GetInputList(const Request &request)
  * @api requests
  * @category inputs
  */
-RequestResult RequestHandler::GetInputKindList(const Request &request)
+RequestResult RequestHandler::GetInputKindList(const Request& request)
 {
 	bool unversioned = false;
 
@@ -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.
  *
@@ -138,13 +101,12 @@ RequestResult RequestHandler::GetSpecialInputs(const Request &)
  * @api requests
  * @category inputs
  */
-RequestResult RequestHandler::CreateInput(const Request &request)
+RequestResult RequestHandler::CreateInput(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
 	OBSSourceAutoRelease sceneSource = request.ValidateScene("sceneName", statusCode, comment);
-	if (!(sceneSource && request.ValidateString("inputName", statusCode, comment) &&
+	if (!(sceneSource && request.ValidateString("inputName", statusCode, comment) && request.ValidateString("inputKind", statusCode, comment)))
-	      request.ValidateString("inputKind", statusCode, comment)))
 		return RequestResult::Error(statusCode, comment);
 
 	std::string inputName = request.RequestData["inputName"];
@@ -155,9 +117,7 @@ RequestResult RequestHandler::CreateInput(const Request &request)
 	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(
+		return RequestResult::Error(RequestStatus::InvalidInputKind, "Your specified input kind is not supported by OBS. Check that your specified kind is properly versioned and that any necessary plugins are loaded.");
-			RequestStatus::InvalidInputKind,
-			"Your specified input kind is not supported by OBS. Check that your specified kind is properly versioned and that any necessary plugins are loaded.");
 
 	OBSDataAutoRelease inputSettings = nullptr;
 	if (request.Contains("inputSettings")) {
@@ -178,8 +138,7 @@ RequestResult RequestHandler::CreateInput(const Request &request)
 	}
 
 	// Create the input and add it as a scene item to the destination scene
-	OBSSceneItemAutoRelease sceneItem =
+	OBSSceneItemAutoRelease sceneItem = Utils::Obs::ActionHelper::CreateInput(inputName, inputKind, inputSettings, scene, sceneItemEnabled);
-		Utils::Obs::ActionHelper::CreateInput(inputName, inputKind, inputSettings, scene, sceneItemEnabled);
 
 	if (!sceneItem)
 		return RequestResult::Error(RequestStatus::ResourceCreationFailed, "Creation of the input or scene item failed.");
@@ -203,7 +162,7 @@ RequestResult RequestHandler::CreateInput(const Request &request)
  * @api requests
  * @category inputs
  */
-RequestResult RequestHandler::RemoveInput(const Request &request)
+RequestResult RequestHandler::RemoveInput(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -232,7 +191,7 @@ RequestResult RequestHandler::RemoveInput(const Request &request)
  * @api requests
  * @category inputs
  */
-RequestResult RequestHandler::SetInputName(const Request &request)
+RequestResult RequestHandler::SetInputName(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -244,8 +203,7 @@ RequestResult RequestHandler::SetInputName(const Request &request)
 
 	OBSSourceAutoRelease existingSource = obs_get_source_by_name(newInputName.c_str());
 	if (existingSource)
-		return RequestResult::Error(RequestStatus::ResourceAlreadyExists,
+		return RequestResult::Error(RequestStatus::ResourceAlreadyExists, "A source already exists by that new input name.");
-					    "A source already exists by that new input name.");
 
 	obs_source_set_name(input, newInputName.c_str());
 
@@ -266,7 +224,7 @@ RequestResult RequestHandler::SetInputName(const Request &request)
  * @api requests
  * @category inputs
  */
-RequestResult RequestHandler::GetInputDefaultSettings(const Request &request)
+RequestResult RequestHandler::GetInputDefaultSettings(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -274,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)
@@ -304,7 +259,7 @@ RequestResult RequestHandler::GetInputDefaultSettings(const Request &request)
  * @api requests
  * @category inputs
  */
-RequestResult RequestHandler::GetInputSettings(const Request &request)
+RequestResult RequestHandler::GetInputSettings(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -334,7 +289,7 @@ RequestResult RequestHandler::GetInputSettings(const Request &request)
  * @api requests
  * @category inputs
  */
-RequestResult RequestHandler::SetInputSettings(const Request &request)
+RequestResult RequestHandler::SetInputSettings(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -354,8 +309,7 @@ RequestResult RequestHandler::SetInputSettings(const Request &request)
 	OBSDataAutoRelease newSettings = Utils::Json::JsonToObsData(request.RequestData["inputSettings"]);
 	if (!newSettings)
 		// This should never happen
-		return RequestResult::Error(RequestStatus::RequestProcessingFailed,
+		return RequestResult::Error(RequestStatus::RequestProcessingFailed, "An internal data conversion operation failed. Please report this!");
-					    "An internal data conversion operation failed. Please report this!");
 
 	if (overlay)
 		// Applies the new settings on top of the existing user settings
@@ -384,7 +338,7 @@ RequestResult RequestHandler::SetInputSettings(const Request &request)
  * @api requests
  * @category inputs
  */
-RequestResult RequestHandler::GetInputMute(const Request &request)
+RequestResult RequestHandler::GetInputMute(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -392,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);
@@ -413,7 +364,7 @@ RequestResult RequestHandler::GetInputMute(const Request &request)
  * @api requests
  * @category inputs
  */
-RequestResult RequestHandler::SetInputMute(const Request &request)
+RequestResult RequestHandler::SetInputMute(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -421,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();
@@ -443,7 +391,7 @@ RequestResult RequestHandler::SetInputMute(const Request &request)
  * @api requests
  * @category inputs
  */
-RequestResult RequestHandler::ToggleInputMute(const Request &request)
+RequestResult RequestHandler::ToggleInputMute(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -451,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);
 
@@ -477,7 +422,7 @@ RequestResult RequestHandler::ToggleInputMute(const Request &request)
  * @api requests
  * @category inputs
  */
-RequestResult RequestHandler::GetInputVolume(const Request &request)
+RequestResult RequestHandler::GetInputVolume(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -485,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)
@@ -504,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
@@ -513,7 +455,7 @@ RequestResult RequestHandler::GetInputVolume(const Request &request)
  * @api requests
  * @category inputs
  */
-RequestResult RequestHandler::SetInputVolume(const Request &request)
+RequestResult RequestHandler::SetInputVolume(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -521,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);
@@ -549,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.
  *
@@ -626,7 +504,7 @@ RequestResult RequestHandler::SetInputAudioBalance(const Request &request)
  * @api requests
  * @category inputs
  */
-RequestResult RequestHandler::GetInputAudioSyncOffset(const Request &request)
+RequestResult RequestHandler::GetInputAudioSyncOffset(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -634,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;
@@ -657,7 +532,7 @@ RequestResult RequestHandler::GetInputAudioSyncOffset(const Request &request)
  * @api requests
  * @category inputs
  */
-RequestResult RequestHandler::SetInputAudioSyncOffset(const Request &request)
+RequestResult RequestHandler::SetInputAudioSyncOffset(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -665,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);
 
@@ -678,7 +550,6 @@ RequestResult RequestHandler::SetInputAudioSyncOffset(const Request &request)
  * Gets the audio monitor type of an input.
  *
  * The available audio monitor types are:
- *
  * - `OBS_MONITORING_TYPE_NONE`
  * - `OBS_MONITORING_TYPE_MONITOR_ONLY`
  * - `OBS_MONITORING_TYPE_MONITOR_AND_OUTPUT`
@@ -694,7 +565,7 @@ RequestResult RequestHandler::SetInputAudioSyncOffset(const Request &request)
  * @api requests
  * @category inputs
  */
-RequestResult RequestHandler::GetInputAudioMonitorType(const Request &request)
+RequestResult RequestHandler::GetInputAudioMonitorType(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -702,11 +573,8 @@ 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"] = obs_source_get_monitoring_type(input);
+	responseData["monitorType"] = Utils::Obs::StringHelper::GetInputMonitorType(input);
 
 	return RequestResult::Success(responseData);
 }
@@ -724,7 +592,7 @@ RequestResult RequestHandler::GetInputAudioMonitorType(const Request &request)
  * @api requests
  * @category inputs
  */
-RequestResult RequestHandler::SetInputAudioMonitorType(const Request &request)
+RequestResult RequestHandler::SetInputAudioMonitorType(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -732,13 +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")
@@ -748,104 +609,13 @@ RequestResult RequestHandler::SetInputAudioMonitorType(const Request &request)
 	else if (monitorTypeString == "OBS_MONITORING_TYPE_MONITOR_AND_OUTPUT")
 		monitorType = OBS_MONITORING_TYPE_MONITOR_AND_OUTPUT;
 	else
-		return RequestResult::Error(RequestStatus::InvalidRequestField,
+		return RequestResult::Error(RequestStatus::InvalidRequestField, std::string("Unknown monitor type: ") + monitorTypeString);
-					    std::string("Unknown monitor type: ") + monitorTypeString);
 
 	obs_source_set_monitoring_type(input, monitorType);
 
 	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.
  *
@@ -863,7 +633,7 @@ RequestResult RequestHandler::SetInputAudioTracks(const Request &request)
  * @api requests
  * @category inputs
  */
-RequestResult RequestHandler::GetInputPropertiesListPropertyItems(const Request &request)
+RequestResult RequestHandler::GetInputPropertiesListPropertyItems(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -901,7 +671,7 @@ RequestResult RequestHandler::GetInputPropertiesListPropertyItems(const Request
  * @api requests
  * @category inputs
  */
-RequestResult RequestHandler::PressInputPropertiesButton(const Request &request)
+RequestResult RequestHandler::PressInputPropertiesButton(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;

src/requesthandler/RequestHandler_MediaInputs.cpp

@@ -29,7 +29,6 @@ bool IsMediaTimeValid(obs_source_t *input)
  * Gets the status of a media input.
  *
  * Media States:
- *
  * - `OBS_MEDIA_STATE_NONE`
  * - `OBS_MEDIA_STATE_PLAYING`
  * - `OBS_MEDIA_STATE_OPENING`
@@ -52,7 +51,7 @@ bool IsMediaTimeValid(obs_source_t *input)
  * @api requests
  * @category media inputs
  */
-RequestResult RequestHandler::GetMediaInputStatus(const Request &request)
+RequestResult RequestHandler::GetMediaInputStatus(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -61,8 +60,7 @@ RequestResult RequestHandler::GetMediaInputStatus(const Request &request)
 		return RequestResult::Error(statusCode, comment);
 
 	json responseData;
-	responseData["mediaState"] = obs_source_media_get_state(input);
+	responseData["mediaState"] = Utils::Obs::StringHelper::GetMediaInputState(input);
-	;
 
 	if (IsMediaTimeValid(input)) {
 		responseData["mediaDuration"] = obs_source_media_get_duration(input);
@@ -90,7 +88,7 @@ RequestResult RequestHandler::GetMediaInputStatus(const Request &request)
  * @api requests
  * @category media inputs
  */
-RequestResult RequestHandler::SetMediaInputCursor(const Request &request)
+RequestResult RequestHandler::SetMediaInputCursor(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -99,8 +97,7 @@ RequestResult RequestHandler::SetMediaInputCursor(const Request &request)
 		return RequestResult::Error(statusCode, comment);
 
 	if (!IsMediaTimeValid(input))
-		return RequestResult::Error(RequestStatus::InvalidResourceState,
+		return RequestResult::Error(RequestStatus::InvalidResourceState, "The media input must be playing or paused in order to set the cursor position.");
-					    "The media input must be playing or paused in order to set the cursor position.");
 
 	int64_t mediaCursor = request.RequestData["mediaCursor"];
 
@@ -125,7 +122,7 @@ RequestResult RequestHandler::SetMediaInputCursor(const Request &request)
  * @api requests
  * @category media inputs
  */
-RequestResult RequestHandler::OffsetMediaInputCursor(const Request &request)
+RequestResult RequestHandler::OffsetMediaInputCursor(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -134,8 +131,7 @@ RequestResult RequestHandler::OffsetMediaInputCursor(const Request &request)
 		return RequestResult::Error(statusCode, comment);
 
 	if (!IsMediaTimeValid(input))
-		return RequestResult::Error(RequestStatus::InvalidResourceState,
+		return RequestResult::Error(RequestStatus::InvalidResourceState, "The media input must be playing or paused in order to set the cursor position.");
-					    "The media input must be playing or paused in order to set the cursor position.");
 
 	int64_t mediaCursorOffset = request.RequestData["mediaCursorOffset"];
 	int64_t mediaCursor = obs_source_media_get_time(input) + mediaCursorOffset;
@@ -161,7 +157,7 @@ RequestResult RequestHandler::OffsetMediaInputCursor(const Request &request)
  * @api requests
  * @category media inputs
  */
-RequestResult RequestHandler::TriggerMediaInputAction(const Request &request)
+RequestResult RequestHandler::TriggerMediaInputAction(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -169,33 +165,33 @@ RequestResult RequestHandler::TriggerMediaInputAction(const Request &request)
 	if (!(input && request.ValidateString("mediaAction", statusCode, comment)))
 		return RequestResult::Error(statusCode, comment);
 
-	enum ObsMediaInputAction mediaAction = request.RequestData["mediaAction"];
+	std::string mediaActionString = request.RequestData["mediaAction"];
+	auto mediaAction = Utils::Obs::EnumHelper::GetMediaInputAction(mediaActionString);
 
 	switch (mediaAction) {
-	default:
+		default:
-	case OBS_WEBSOCKET_MEDIA_INPUT_ACTION_NONE:
+		case OBS_WEBSOCKET_MEDIA_INPUT_ACTION_NONE:
-		return RequestResult::Error(RequestStatus::InvalidRequestField,
+			return RequestResult::Error(RequestStatus::InvalidRequestField, "You have specified an invalid media input action.");
-					    "You have specified an invalid media input action.");
+		case OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PLAY:
-	case OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PLAY:
+			// Shoutout to whoever implemented this API call like this
-		// Shoutout to whoever implemented this API call like this
+			obs_source_media_play_pause(input, false);
-		obs_source_media_play_pause(input, false);
+			break;
-		break;
+		case OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PAUSE:
-	case OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PAUSE:
+			obs_source_media_play_pause(input, true);
-		obs_source_media_play_pause(input, true);
+			break;
-		break;
+		case OBS_WEBSOCKET_MEDIA_INPUT_ACTION_STOP:
-	case OBS_WEBSOCKET_MEDIA_INPUT_ACTION_STOP:
+			obs_source_media_stop(input);
-		obs_source_media_stop(input);
+			break;
-		break;
+		case OBS_WEBSOCKET_MEDIA_INPUT_ACTION_RESTART:
-	case OBS_WEBSOCKET_MEDIA_INPUT_ACTION_RESTART:
+			// I'm only implementing this because I'm nice. I think its a really dumb action.
-		// I'm only implementing this because I'm nice. I think its a really dumb action.
+			obs_source_media_restart(input);
-		obs_source_media_restart(input);
+			break;
-		break;
+		case OBS_WEBSOCKET_MEDIA_INPUT_ACTION_NEXT:
-	case OBS_WEBSOCKET_MEDIA_INPUT_ACTION_NEXT:
+			obs_source_media_next(input);
-		obs_source_media_next(input);
+			break;
-		break;
+		case OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PREVIOUS:
-	case OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PREVIOUS:
+			obs_source_media_previous(input);
-		obs_source_media_previous(input);
+			break;
-		break;
 	}
 
 	return RequestResult::Success();

src/requesthandler/RequestHandler_Outputs.cpp

@@ -1,488 +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::GetLastReplayBufferFileName();
-	return RequestResult::Success(responseData);
-}
-
-/**
- * Gets the list of available outputs.
- *
- * @requestType GetOutputList
- * @complexity 4
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category outputs
- */
-RequestResult RequestHandler::GetOutputList(const Request &)
-{
-	json responseData;
-	responseData["outputs"] = Utils::Obs::ArrayHelper::GetOutputList();
-	return RequestResult::Success(responseData);
-}
-
-/**
- * Gets the status of an output.
- *
- * @requestField outputName | String | Output name
- *
- * @responseField outputActive        | Boolean | Whether the output is active
- * @responseField outputReconnecting  | Boolean | Whether the output is reconnecting
- * @responseField outputTimecode      | String  | Current formatted timecode string for the output
- * @responseField outputDuration      | Number  | Current duration in milliseconds for the output
- * @responseField outputCongestion    | Number  | Congestion of the output
- * @responseField outputBytes         | Number  | Number of bytes sent by the output
- * @responseField outputSkippedFrames | Number  | Number of frames skipped by the output's process
- * @responseField outputTotalFrames   | Number  | Total number of frames delivered by the output's process
- *
- * @requestType GetOutputStatus
- * @complexity 4
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category outputs
- */
-RequestResult RequestHandler::GetOutputStatus(const Request &request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSOutputAutoRelease output = request.ValidateOutput("outputName", statusCode, comment);
-	if (!output)
-		return RequestResult::Error(statusCode, comment);
-
-	uint64_t outputDuration = Utils::Obs::NumberHelper::GetOutputDuration(output);
-
-	json responseData;
-	responseData["outputActive"] = obs_output_active(output);
-	responseData["outputReconnecting"] = obs_output_reconnecting(output);
-	responseData["outputTimecode"] = Utils::Obs::StringHelper::DurationToTimecode(outputDuration);
-	responseData["outputDuration"] = outputDuration;
-	responseData["outputCongestion"] = obs_output_get_congestion(output);
-	responseData["outputBytes"] = obs_output_get_total_bytes(output);
-	responseData["outputSkippedFrames"] = obs_output_get_frames_dropped(output);
-	responseData["outputTotalFrames"] = obs_output_get_total_frames(output);
-
-	return RequestResult::Success(responseData);
-}
-
-/**
- * Toggles the status of an output.
- *
- * @requestField outputName | String | Output name
- *
- * @responseField outputActive | Boolean | Whether the output is active
- * 
- * @requestType ToggleOutput
- * @complexity 4
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category outputs
- */
-RequestResult RequestHandler::ToggleOutput(const Request &request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSOutputAutoRelease output = request.ValidateOutput("outputName", statusCode, comment);
-	if (!output)
-		return RequestResult::Error(statusCode, comment);
-
-	bool outputActive = obs_output_active(output);
-	if (outputActive)
-		obs_output_stop(output);
-	else
-		obs_output_start(output);
-
-	json responseData;
-	responseData["outputActive"] = !outputActive;
-	return RequestResult::Success(responseData);
-}
-
-/**
- * Starts an output.
- *
- * @requestField outputName | String | Output name
- *
- * @requestType StartOutput
- * @complexity 4
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category outputs
- */
-RequestResult RequestHandler::StartOutput(const Request &request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSOutputAutoRelease output = request.ValidateOutput("outputName", statusCode, comment);
-	if (!output)
-		return RequestResult::Error(statusCode, comment);
-
-	if (obs_output_active(output))
-		return RequestResult::Error(RequestStatus::OutputRunning);
-
-	obs_output_start(output);
-
-	return RequestResult::Success();
-}
-
-/**
- * Stops an output.
- *
- * @requestField outputName | String | Output name
- *
- * @requestType StopOutput
- * @complexity 4
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category outputs
- */
-RequestResult RequestHandler::StopOutput(const Request &request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSOutputAutoRelease output = request.ValidateOutput("outputName", statusCode, comment);
-	if (!output)
-		return RequestResult::Error(statusCode, comment);
-
-	if (!obs_output_active(output))
-		return RequestResult::Error(RequestStatus::OutputNotRunning);
-
-	obs_output_stop(output);
-
-	return RequestResult::Success();
-}
-
-/**
- * Gets the settings of an output.
- *
- * @requestField outputName | String | Output name
- *
- * @responseField outputSettings | Object | Output settings
- *
- * @requestType GetOutputSettings
- * @complexity 4
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category outputs
- */
-RequestResult RequestHandler::GetOutputSettings(const Request &request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSOutputAutoRelease output = request.ValidateOutput("outputName", statusCode, comment);
-	if (!output)
-		return RequestResult::Error(statusCode, comment);
-
-	OBSDataAutoRelease outputSettings = obs_output_get_settings(output);
-
-	json responseData;
-	responseData["outputSettings"] = Utils::Json::ObsDataToJson(outputSettings);
-	return RequestResult::Success(responseData);
-}
-
-/**
- * Sets the settings of an output.
- *
- * @requestField outputName     | String | Output name
- * @requestField outputSettings | Object | Output settings
- *
- * @requestType SetOutputSettings
- * @complexity 4
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @api requests
- * @category outputs
- */
-RequestResult RequestHandler::SetOutputSettings(const Request &request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSOutputAutoRelease output = request.ValidateOutput("outputName", statusCode, comment);
-	if (!(output && request.ValidateObject("outputSettings", statusCode, comment, true)))
-		return RequestResult::Error(statusCode, comment);
-
-	OBSDataAutoRelease newSettings = Utils::Json::JsonToObsData(request.RequestData["outputSettings"]);
-	if (!newSettings)
-		// This should never happen
-		return RequestResult::Error(RequestStatus::RequestProcessingFailed,
-					    "An internal data conversion operation failed. Please report this!");
-
-	obs_output_update(output, newSettings);
-
-	return RequestResult::Success();
-}

src/requesthandler/RequestHandler_Record.cpp

@@ -35,7 +35,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
  * @api requests
  * @category record
  */
-RequestResult RequestHandler::GetRecordStatus(const Request &)
+RequestResult RequestHandler::GetRecordStatus(const Request&)
 {
 	OBSOutputAutoRelease recordOutput = obs_frontend_get_recording_output();
 
@@ -61,7 +61,7 @@ RequestResult RequestHandler::GetRecordStatus(const Request &)
  * @api requests
  * @category record
  */
-RequestResult RequestHandler::ToggleRecord(const Request &)
+RequestResult RequestHandler::ToggleRecord(const Request&)
 {
 	json responseData;
 	if (obs_frontend_recording_active()) {
@@ -85,7 +85,7 @@ RequestResult RequestHandler::ToggleRecord(const Request &)
  * @api requests
  * @category record
  */
-RequestResult RequestHandler::StartRecord(const Request &)
+RequestResult RequestHandler::StartRecord(const Request&)
 {
 	if (obs_frontend_recording_active())
 		return RequestResult::Error(RequestStatus::OutputRunning);
@@ -99,8 +99,6 @@ RequestResult RequestHandler::StartRecord(const Request &)
 /**
  * Stops the record output.
  *
- * @responseField outputPath | String | File name for the saved recording
- *
  * @requestType StopRecord
  * @complexity 1
  * @rpcVersion -1
@@ -108,7 +106,7 @@ RequestResult RequestHandler::StartRecord(const Request &)
  * @api requests
  * @category record
  */
-RequestResult RequestHandler::StopRecord(const Request &)
+RequestResult RequestHandler::StopRecord(const Request&)
 {
 	if (!obs_frontend_recording_active())
 		return RequestResult::Error(RequestStatus::OutputNotRunning);
@@ -116,10 +114,7 @@ RequestResult RequestHandler::StopRecord(const Request &)
 	// TODO: Call signal directly to perform blocking wait
 	obs_frontend_recording_stop();
 
-	json responseData;
+	return RequestResult::Success();
-	responseData["outputPath"] = Utils::Obs::StringHelper::GetLastRecordFileName();
-
-	return RequestResult::Success(responseData);
 }
 
 /**
@@ -132,7 +127,7 @@ RequestResult RequestHandler::StopRecord(const Request &)
  * @api requests
  * @category record
  */
-RequestResult RequestHandler::ToggleRecordPause(const Request &)
+RequestResult RequestHandler::ToggleRecordPause(const Request&)
 {
 	json responseData;
 	if (obs_frontend_recording_paused()) {
@@ -156,7 +151,7 @@ RequestResult RequestHandler::ToggleRecordPause(const Request &)
  * @api requests
  * @category record
  */
-RequestResult RequestHandler::PauseRecord(const Request &)
+RequestResult RequestHandler::PauseRecord(const Request&)
 {
 	if (obs_frontend_recording_paused())
 		return RequestResult::Error(RequestStatus::OutputPaused);
@@ -177,7 +172,7 @@ RequestResult RequestHandler::PauseRecord(const Request &)
  * @api requests
  * @category record
  */
-RequestResult RequestHandler::ResumeRecord(const Request &)
+RequestResult RequestHandler::ResumeRecord(const Request&)
 {
 	if (!obs_frontend_recording_paused())
 		return RequestResult::Error(RequestStatus::OutputNotPaused);
@@ -187,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);
+}

src/requesthandler/RequestHandler_SceneItems.cpp

@@ -35,7 +35,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
  * @api requests
  * @category scene items
  */
-RequestResult RequestHandler::GetSceneItemList(const Request &request)
+RequestResult RequestHandler::GetSceneItemList(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -67,7 +67,7 @@ RequestResult RequestHandler::GetSceneItemList(const Request &request)
  * @api requests
  * @category scene items
  */
-RequestResult RequestHandler::GetGroupSceneItemList(const Request &request)
+RequestResult RequestHandler::GetGroupSceneItemList(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -86,9 +86,8 @@ RequestResult RequestHandler::GetGroupSceneItemList(const Request &request)
  *
  * Scenes and Groups
  *
- * @requestField sceneName     | String | Name of the scene or group to search in
+ * @requestField sceneName  | String | Name of the scene or group to search in
- * @requestField sourceName    | String | Name of the source to find
+ * @requestField sourceName | String | Name of the source to find
- * @requestField ?searchOffset | Number | Number of matches to skip during search. >= 0 means first forward. -1 means last (top) item | >= -1 | 0
  *
  * @responseField sceneItemId | Number | Numeric ID of the scene item
  *
@@ -99,28 +98,19 @@ RequestResult RequestHandler::GetGroupSceneItemList(const Request &request)
  * @api requests
  * @category scene items
  */
-RequestResult RequestHandler::GetSceneItemId(const Request &request)
+RequestResult RequestHandler::GetSceneItemId(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
-	OBSSceneAutoRelease scene =
+	OBSSceneAutoRelease scene = request.ValidateScene2("sceneName", statusCode, comment, OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP);
-		request.ValidateScene2("sceneName", statusCode, comment, OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP);
 	if (!(scene && request.ValidateString("sourceName", statusCode, comment)))
 		return RequestResult::Error(statusCode, comment);
 
 	std::string sourceName = request.RequestData["sourceName"];
 
-	int offset = 0;
+	OBSSceneItemAutoRelease item = Utils::Obs::SearchHelper::GetSceneItemByName(scene, sourceName);
-	if (request.Contains("searchOffset")) {
-		if (!request.ValidateOptionalNumber("searchOffset", statusCode, comment, -1))
-			return RequestResult::Error(statusCode, comment);
-		offset = request.RequestData["searchOffset"];
-	}
-
-	OBSSceneItemAutoRelease item = Utils::Obs::SearchHelper::GetSceneItemByName(scene, sourceName, offset);
 	if (!item)
-		return RequestResult::Error(RequestStatus::ResourceNotFound,
+		return RequestResult::Error(RequestStatus::ResourceNotFound, "No scene items were found in the specified scene by that name.");
-					    "No scene items were found in the specified scene by that name or offset.");
 
 	json responseData;
 	responseData["sceneItemId"] = obs_sceneitem_get_id(item);
@@ -146,7 +136,7 @@ RequestResult RequestHandler::GetSceneItemId(const Request &request)
  * @api requests
  * @category scene items
  */
-RequestResult RequestHandler::CreateSceneItem(const Request &request)
+RequestResult RequestHandler::CreateSceneItem(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -195,7 +185,7 @@ RequestResult RequestHandler::CreateSceneItem(const Request &request)
  * @api requests
  * @category scene items
  */
-RequestResult RequestHandler::RemoveSceneItem(const Request &request)
+RequestResult RequestHandler::RemoveSceneItem(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -227,7 +217,7 @@ RequestResult RequestHandler::RemoveSceneItem(const Request &request)
  * @api requests
  * @category scene items
  */
-RequestResult RequestHandler::DuplicateSceneItem(const Request &request)
+RequestResult RequestHandler::DuplicateSceneItem(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -242,10 +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));
+		destinationScene = obs_sceneitem_get_scene(sceneItem);
-		if (!destinationScene)
+		obs_scene_addref(destinationScene);
-			return RequestResult::Error(RequestStatus::RequestProcessingFailed,
-						    "Internal error: Failed to get ref for scene of scene item.");
 	}
 
 	if (obs_sceneitem_is_group(sceneItem) && obs_sceneitem_get_scene(sceneItem) == destinationScene) {
@@ -262,8 +250,7 @@ RequestResult RequestHandler::DuplicateSceneItem(const Request &request)
 	obs_sceneitem_get_crop(sceneItem, &sceneItemCrop);
 
 	// Create the new item
-	OBSSceneItemAutoRelease newSceneItem = Utils::Obs::ActionHelper::CreateSceneItem(
+	OBSSceneItemAutoRelease newSceneItem = Utils::Obs::ActionHelper::CreateSceneItem(sceneItemSource, destinationScene, sceneItemEnabled, &sceneItemTransform, &sceneItemCrop);
-		sceneItemSource, destinationScene, sceneItemEnabled, &sceneItemTransform, &sceneItemCrop);
 	obs_scene_release(destinationScene);
 	if (!newSceneItem)
 		return RequestResult::Error(RequestStatus::ResourceCreationFailed, "Failed to create the scene item.");
@@ -291,12 +278,11 @@ RequestResult RequestHandler::DuplicateSceneItem(const Request &request)
  * @api requests
  * @category scene items
  */
-RequestResult RequestHandler::GetSceneItemTransform(const Request &request)
+RequestResult RequestHandler::GetSceneItemTransform(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
-	OBSSceneItemAutoRelease sceneItem = request.ValidateSceneItem("sceneName", "sceneItemId", statusCode, comment,
+	OBSSceneItemAutoRelease sceneItem = request.ValidateSceneItem("sceneName", "sceneItemId", statusCode, comment, OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP);
-								      OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP);
 	if (!sceneItem)
 		return RequestResult::Error(statusCode, comment);
 
@@ -320,12 +306,11 @@ RequestResult RequestHandler::GetSceneItemTransform(const Request &request)
  * @api requests
  * @category scene items
  */
-RequestResult RequestHandler::SetSceneItemTransform(const Request &request)
+RequestResult RequestHandler::SetSceneItemTransform(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
-	OBSSceneItemAutoRelease sceneItem = request.ValidateSceneItem("sceneName", "sceneItemId", statusCode, comment,
+	OBSSceneItemAutoRelease sceneItem = request.ValidateSceneItem("sceneName", "sceneItemId", statusCode, comment, OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP);
-								      OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP);
 	if (!(sceneItem && request.ValidateObject("sceneItemTransform", statusCode, comment)))
 		return RequestResult::Error(statusCode, comment);
 
@@ -369,8 +354,7 @@ RequestResult RequestHandler::SetSceneItemTransform(const Request &request)
 		float scaleX = r.RequestData["scaleX"];
 		float finalWidth = scaleX * sourceWidth;
 		if (!(finalWidth > -90001.0 && finalWidth < 90001.0))
-			return RequestResult::Error(RequestStatus::RequestFieldOutOfRange,
+			return RequestResult::Error(RequestStatus::RequestFieldOutOfRange, "The field scaleX is too small or large for the current source resolution.");
-						    "The field `scaleX` is too small or large for the current source resolution.");
 		sceneItemTransform.scale.x = scaleX;
 		transformChanged = true;
 	}
@@ -380,8 +364,7 @@ RequestResult RequestHandler::SetSceneItemTransform(const Request &request)
 		float scaleY = r.RequestData["scaleY"];
 		float finalHeight = scaleY * sourceHeight;
 		if (!(finalHeight > -90001.0 && finalHeight < 90001.0))
-			return RequestResult::Error(RequestStatus::RequestFieldOutOfRange,
+			return RequestResult::Error(RequestStatus::RequestFieldOutOfRange, "The field scaleY is too small or large for the current source resolution.");
-						    "The field `scaleY` is too small or large for the current source resolution.");
 		sceneItemTransform.scale.y = scaleY;
 		transformChanged = true;
 	}
@@ -396,10 +379,10 @@ RequestResult RequestHandler::SetSceneItemTransform(const Request &request)
 	if (r.Contains("boundsType")) {
 		if (!r.ValidateOptionalString("boundsType", statusCode, comment))
 			return RequestResult::Error(statusCode, comment);
-		enum obs_bounds_type boundsType = r.RequestData["boundsType"];
+		std::string boundsTypeString = r.RequestData["boundsType"];
-		if (boundsType == OBS_BOUNDS_NONE && r.RequestData["boundsType"] != "OBS_BOUNDS_NONE")
+		enum obs_bounds_type boundsType = Utils::Obs::EnumHelper::GetSceneItemBoundsType(boundsTypeString);
-			return RequestResult::Error(RequestStatus::InvalidRequestField,
+		if (boundsType == OBS_BOUNDS_NONE && boundsTypeString != "OBS_BOUNDS_NONE")
-						    "The field `boundsType` has an invalid value.");
+			return RequestResult::Error(RequestStatus::InvalidRequestField, "The field boundsType has an invalid value.");
 		sceneItemTransform.bounds_type = boundsType;
 		transformChanged = true;
 	}
@@ -478,12 +461,11 @@ RequestResult RequestHandler::SetSceneItemTransform(const Request &request)
  * @api requests
  * @category scene items
  */
-RequestResult RequestHandler::GetSceneItemEnabled(const Request &request)
+RequestResult RequestHandler::GetSceneItemEnabled(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
-	OBSSceneItemAutoRelease sceneItem = request.ValidateSceneItem("sceneName", "sceneItemId", statusCode, comment,
+	OBSSceneItemAutoRelease sceneItem = request.ValidateSceneItem("sceneName", "sceneItemId", statusCode, comment, OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP);
-								      OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP);
 	if (!sceneItem)
 		return RequestResult::Error(statusCode, comment);
 
@@ -509,12 +491,11 @@ RequestResult RequestHandler::GetSceneItemEnabled(const Request &request)
  * @api requests
  * @category scene items
  */
-RequestResult RequestHandler::SetSceneItemEnabled(const Request &request)
+RequestResult RequestHandler::SetSceneItemEnabled(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
-	OBSSceneItemAutoRelease sceneItem = request.ValidateSceneItem("sceneName", "sceneItemId", statusCode, comment,
+	OBSSceneItemAutoRelease sceneItem = request.ValidateSceneItem("sceneName", "sceneItemId", statusCode, comment, OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP);
-								      OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP);
 	if (!(sceneItem && request.ValidateBoolean("sceneItemEnabled", statusCode, comment)))
 		return RequestResult::Error(statusCode, comment);
 
@@ -542,12 +523,11 @@ RequestResult RequestHandler::SetSceneItemEnabled(const Request &request)
  * @api requests
  * @category scene items
  */
-RequestResult RequestHandler::GetSceneItemLocked(const Request &request)
+RequestResult RequestHandler::GetSceneItemLocked(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
-	OBSSceneItemAutoRelease sceneItem = request.ValidateSceneItem("sceneName", "sceneItemId", statusCode, comment,
+	OBSSceneItemAutoRelease sceneItem = request.ValidateSceneItem("sceneName", "sceneItemId", statusCode, comment, OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP);
-								      OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP);
 	if (!sceneItem)
 		return RequestResult::Error(statusCode, comment);
 
@@ -573,12 +553,11 @@ RequestResult RequestHandler::GetSceneItemLocked(const Request &request)
  * @api requests
  * @category scene items
  */
-RequestResult RequestHandler::SetSceneItemLocked(const Request &request)
+RequestResult RequestHandler::SetSceneItemLocked(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
-	OBSSceneItemAutoRelease sceneItem = request.ValidateSceneItem("sceneName", "sceneItemId", statusCode, comment,
+	OBSSceneItemAutoRelease sceneItem = request.ValidateSceneItem("sceneName", "sceneItemId", statusCode, comment, OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP);
-								      OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP);
 	if (!(sceneItem && request.ValidateBoolean("sceneItemLocked", statusCode, comment)))
 		return RequestResult::Error(statusCode, comment);
 
@@ -608,12 +587,11 @@ RequestResult RequestHandler::SetSceneItemLocked(const Request &request)
  * @api requests
  * @category scene items
  */
-RequestResult RequestHandler::GetSceneItemIndex(const Request &request)
+RequestResult RequestHandler::GetSceneItemIndex(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
-	OBSSceneItemAutoRelease sceneItem = request.ValidateSceneItem("sceneName", "sceneItemId", statusCode, comment,
+	OBSSceneItemAutoRelease sceneItem = request.ValidateSceneItem("sceneName", "sceneItemId", statusCode, comment, OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP);
-								      OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP);
 	if (!sceneItem)
 		return RequestResult::Error(statusCode, comment);
 
@@ -639,12 +617,11 @@ RequestResult RequestHandler::GetSceneItemIndex(const Request &request)
  * @api requests
  * @category scene items
  */
-RequestResult RequestHandler::SetSceneItemIndex(const Request &request)
+RequestResult RequestHandler::SetSceneItemIndex(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
-	OBSSceneItemAutoRelease sceneItem = request.ValidateSceneItem("sceneName", "sceneItemId", statusCode, comment,
+	OBSSceneItemAutoRelease sceneItem = request.ValidateSceneItem("sceneName", "sceneItemId", statusCode, comment, OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP);
-								      OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP);
 	if (!(sceneItem && request.ValidateNumber("sceneItemIndex", statusCode, comment, 0, 8192)))
 		return RequestResult::Error(statusCode, comment);
 
@@ -654,120 +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"] = 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);
-
-	enum obs_blending_type blendMode = request.RequestData["sceneItemBlendMode"];
-	if (blendMode == OBS_BLEND_NORMAL && request.RequestData["sceneItemBlendMode"] != "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();
-}
-
-// Intentionally undocumented
-RequestResult RequestHandler::GetSceneItemPrivateSettings(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);
-
-	OBSDataAutoRelease privateSettings = obs_sceneitem_get_private_settings(sceneItem);
-
-	json responseData;
-	responseData["sceneItemSettings"] = Utils::Json::ObsDataToJson(privateSettings);
-
-	return RequestResult::Success(responseData);
-}
-
-// Intentionally undocumented
-RequestResult RequestHandler::SetSceneItemPrivateSettings(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.ValidateObject("sceneItemSettings", statusCode, comment, true))
-		return RequestResult::Error(statusCode, comment);
-
-	OBSDataAutoRelease privateSettings = obs_sceneitem_get_private_settings(sceneItem);
-
-	OBSDataAutoRelease newSettings = Utils::Json::JsonToObsData(request.RequestData["sceneItemSettings"]);
-
-	// Always overlays to prevent destroying internal source unintentionally
-	obs_data_apply(privateSettings, newSettings);
-
-	return RequestResult::Success();
-}

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
@@ -33,7 +33,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
  * @api requests
  * @category scenes
  */
-RequestResult RequestHandler::GetSceneList(const Request &)
+RequestResult RequestHandler::GetSceneList(const Request&)
 {
 	json responseData;
 
@@ -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.
  *
@@ -89,7 +66,7 @@ RequestResult RequestHandler::GetGroupList(const Request &)
  * @api requests
  * @category scenes
  */
-RequestResult RequestHandler::GetCurrentProgramScene(const Request &)
+RequestResult RequestHandler::GetCurrentProgramScene(const Request&)
 {
 	json responseData;
 	OBSSourceAutoRelease currentProgramScene = obs_frontend_get_current_scene();
@@ -110,7 +87,7 @@ RequestResult RequestHandler::GetCurrentProgramScene(const Request &)
  * @api requests
  * @category scenes
  */
-RequestResult RequestHandler::SetCurrentProgramScene(const Request &request)
+RequestResult RequestHandler::SetCurrentProgramScene(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -137,7 +114,7 @@ RequestResult RequestHandler::SetCurrentProgramScene(const Request &request)
  * @api requests
  * @category scenes
  */
-RequestResult RequestHandler::GetCurrentPreviewScene(const Request &)
+RequestResult RequestHandler::GetCurrentPreviewScene(const Request&)
 {
 	if (!obs_frontend_preview_program_mode_active())
 		return RequestResult::Error(RequestStatus::StudioModeNotActive);
@@ -164,7 +141,7 @@ RequestResult RequestHandler::GetCurrentPreviewScene(const Request &)
  * @api requests
  * @category scenes
  */
-RequestResult RequestHandler::SetCurrentPreviewScene(const Request &request)
+RequestResult RequestHandler::SetCurrentPreviewScene(const Request& request)
 {
 	if (!obs_frontend_preview_program_mode_active())
 		return RequestResult::Error(RequestStatus::StudioModeNotActive);
@@ -192,7 +169,7 @@ RequestResult RequestHandler::SetCurrentPreviewScene(const Request &request)
  * @api requests
  * @category scenes
  */
-RequestResult RequestHandler::CreateScene(const Request &request)
+RequestResult RequestHandler::CreateScene(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -226,7 +203,7 @@ RequestResult RequestHandler::CreateScene(const Request &request)
  * @api requests
  * @category scenes
  */
-RequestResult RequestHandler::RemoveScene(const Request &request)
+RequestResult RequestHandler::RemoveScene(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -235,8 +212,7 @@ RequestResult RequestHandler::RemoveScene(const Request &request)
 		return RequestResult::Error(statusCode, comment);
 
 	if (Utils::Obs::NumberHelper::GetSceneCount() < 2)
-		return RequestResult::Error(RequestStatus::NotEnoughResources,
+		return RequestResult::Error(RequestStatus::NotEnoughResources, "You cannot remove the last scene in the collection.");
-					    "You cannot remove the last scene in the collection.");
 
 	obs_source_remove(scene);
 
@@ -256,7 +232,7 @@ RequestResult RequestHandler::RemoveScene(const Request &request)
  * @api requests
  * @category scenes
  */
-RequestResult RequestHandler::SetSceneName(const Request &request)
+RequestResult RequestHandler::SetSceneName(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -268,114 +244,9 @@ RequestResult RequestHandler::SetSceneName(const Request &request)
 
 	OBSSourceAutoRelease existingSource = obs_get_source_by_name(newSceneName.c_str());
 	if (existingSource)
-		return RequestResult::Error(RequestStatus::ResourceAlreadyExists,
+		return RequestResult::Error(RequestStatus::ResourceAlreadyExists, "A source already exists by that new scene name.");
-					    "A source already exists by that new scene name.");
 
 	obs_source_set_name(scene, newSceneName.c_str());
 
 	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();
-}

src/requesthandler/RequestHandler_Sources.cpp

@@ -56,14 +56,14 @@ QImage TakeSourceScreenshot(obs_source_t *source, bool &success, uint32_t reques
 	ret.fill(0);
 
 	// Video image buffer
-	uint8_t *videoData = nullptr;
+	uint8_t* videoData = nullptr;
 	uint32_t videoLinesize = 0;
 
 	// Enter graphics context
 	obs_enter_graphics();
 
-	gs_texrender_t *texRender = gs_texrender_create(GS_RGBA, GS_ZS_NONE);
+	gs_texrender_t* texRender = gs_texrender_create(GS_RGBA, GS_ZS_NONE);
-	gs_stagesurf_t *stageSurface = gs_stagesurface_create(imgWidth, imgHeight, GS_RGBA);
+	gs_stagesurf_t* stageSurface = gs_stagesurface_create(imgWidth, imgHeight, GS_RGBA);
 
 	success = false;
 	gs_texrender_reset(texRender);
@@ -88,7 +88,7 @@ QImage TakeSourceScreenshot(obs_source_t *source, bool &success, uint32_t reques
 		if (gs_stagesurface_map(stageSurface, &videoData, &videoLinesize)) {
 			int lineSize = ret.bytesPerLine();
 			for (uint y = 0; y < imgHeight; y++) {
-				memcpy(ret.scanLine(y), videoData + (y * videoLinesize), lineSize);
+			 	memcpy(ret.scanLine(y), videoData + (y * videoLinesize), lineSize);
 			}
 			gs_stagesurface_unmap(stageSurface);
 			success = true;
@@ -126,7 +126,7 @@ bool IsImageFormatValid(std::string format)
  * @api requests
  * @category sources
  */
-RequestResult RequestHandler::GetSourceActive(const Request &request)
+RequestResult RequestHandler::GetSourceActive(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -166,7 +166,7 @@ RequestResult RequestHandler::GetSourceActive(const Request &request)
  * @api requests
  * @category sources
  */
-RequestResult RequestHandler::GetSourceScreenshot(const Request &request)
+RequestResult RequestHandler::GetSourceScreenshot(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -180,8 +180,7 @@ RequestResult RequestHandler::GetSourceScreenshot(const Request &request)
 	std::string imageFormat = request.RequestData["imageFormat"];
 
 	if (!IsImageFormatValid(imageFormat))
-		return RequestResult::Error(RequestStatus::InvalidRequestField,
+		return RequestResult::Error(RequestStatus::InvalidRequestField, "Your specified image format is invalid or not supported by this system.");
-					    "Your specified image format is invalid or not supported by this system.");
 
 	uint32_t requestedWidth{0};
 	uint32_t requestedHeight{0};
@@ -254,13 +253,12 @@ RequestResult RequestHandler::GetSourceScreenshot(const Request &request)
  * @api requests
  * @category sources
  */
-RequestResult RequestHandler::SaveSourceScreenshot(const Request &request)
+RequestResult RequestHandler::SaveSourceScreenshot(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
 	OBSSourceAutoRelease source = request.ValidateSource("sourceName", statusCode, comment);
-	if (!(source && request.ValidateString("imageFormat", statusCode, comment) &&
+	if (!(source && request.ValidateString("imageFormat", statusCode, comment) && request.ValidateString("imageFilePath", statusCode, comment)))
-	      request.ValidateString("imageFilePath", statusCode, comment)))
 		return RequestResult::Error(statusCode, comment);
 
 	if (obs_source_get_type(source) != OBS_SOURCE_TYPE_INPUT && obs_source_get_type(source) != OBS_SOURCE_TYPE_SCENE)
@@ -270,8 +268,7 @@ RequestResult RequestHandler::SaveSourceScreenshot(const Request &request)
 	std::string imageFilePath = request.RequestData["imageFilePath"];
 
 	if (!IsImageFormatValid(imageFormat))
-		return RequestResult::Error(RequestStatus::InvalidRequestField,
+		return RequestResult::Error(RequestStatus::InvalidRequestField, "Your specified image format is invalid or not supported by this system.");
-					    "Your specified image format is invalid or not supported by this system.");
 
 	QFileInfo filePathInfo(QString::fromStdString(imageFilePath));
 	if (!filePathInfo.absoluteDir().exists())
@@ -315,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, true))
-		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();
-}

src/requesthandler/RequestHandler_Stream.cpp

@@ -26,7 +26,6 @@ with this program. If not, see <https://www.gnu.org/licenses/>
  * @responseField outputReconnecting  | Boolean | Whether the output is currently reconnecting
  * @responseField outputTimecode      | String  | Current formatted timecode string for the output
  * @responseField outputDuration      | Number  | Current duration in milliseconds for the output
- * @responseField outputCongestion    | Number  | Congestion of the output
  * @responseField outputBytes         | Number  | Number of bytes sent by the output
  * @responseField outputSkippedFrames | Number  | Number of frames skipped by the output's process
  * @responseField outputTotalFrames   | Number  | Total number of frames delivered by the output's process
@@ -38,7 +37,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
  * @api requests
  * @category stream
  */
-RequestResult RequestHandler::GetStreamStatus(const Request &)
+RequestResult RequestHandler::GetStreamStatus(const Request&)
 {
 	OBSOutputAutoRelease streamOutput = obs_frontend_get_streaming_output();
 
@@ -49,7 +48,6 @@ RequestResult RequestHandler::GetStreamStatus(const Request &)
 	responseData["outputReconnecting"] = obs_output_reconnecting(streamOutput);
 	responseData["outputTimecode"] = Utils::Obs::StringHelper::DurationToTimecode(outputDuration);
 	responseData["outputDuration"] = outputDuration;
-	responseData["outputCongestion"] = obs_output_get_congestion(streamOutput);
 	responseData["outputBytes"] = (uint64_t)obs_output_get_total_bytes(streamOutput);
 	responseData["outputSkippedFrames"] = obs_output_get_frames_dropped(streamOutput);
 	responseData["outputTotalFrames"] = obs_output_get_total_frames(streamOutput);
@@ -69,7 +67,7 @@ RequestResult RequestHandler::GetStreamStatus(const Request &)
  * @api requests
  * @category stream
  */
-RequestResult RequestHandler::ToggleStream(const Request &)
+RequestResult RequestHandler::ToggleStream(const Request&)
 {
 	json responseData;
 	if (obs_frontend_streaming_active()) {
@@ -93,7 +91,7 @@ RequestResult RequestHandler::ToggleStream(const Request &)
  * @api requests
  * @category stream
  */
-RequestResult RequestHandler::StartStream(const Request &)
+RequestResult RequestHandler::StartStream(const Request&)
 {
 	if (obs_frontend_streaming_active())
 		return RequestResult::Error(RequestStatus::OutputRunning);
@@ -114,7 +112,7 @@ RequestResult RequestHandler::StartStream(const Request &)
  * @api requests
  * @category stream
  */
-RequestResult RequestHandler::StopStream(const Request &)
+RequestResult RequestHandler::StopStream(const Request&)
 {
 	if (!obs_frontend_streaming_active())
 		return RequestResult::Error(RequestStatus::OutputNotRunning);
@@ -124,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();
-}

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"
 
 /**
@@ -35,7 +33,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
  * @api requests
  * @category transitions
  */
-RequestResult RequestHandler::GetTransitionKindList(const Request &)
+RequestResult RequestHandler::GetTransitionKindList(const Request&)
 {
 	json responseData;
 	responseData["transitionKinds"] = Utils::Obs::ArrayHelper::GetTransitionKindList();
@@ -56,7 +54,7 @@ RequestResult RequestHandler::GetTransitionKindList(const Request &)
  * @api requests
  * @category transitions
  */
-RequestResult RequestHandler::GetSceneTransitionList(const Request &)
+RequestResult RequestHandler::GetSceneTransitionList(const Request&)
 {
 	json responseData;
 
@@ -91,12 +89,11 @@ RequestResult RequestHandler::GetSceneTransitionList(const Request &)
  * @api requests
  * @category transitions
  */
-RequestResult RequestHandler::GetCurrentSceneTransition(const Request &)
+RequestResult RequestHandler::GetCurrentSceneTransition(const Request&)
 {
 	OBSSourceAutoRelease transition = obs_frontend_get_current_transition();
 	if (!transition)
-		return RequestResult::Error(RequestStatus::InvalidResourceState,
+		return RequestResult::Error(RequestStatus::InvalidResourceState, "OBS does not currently have a scene transition set."); // This should not happen!
-					    "OBS does not currently have a scene transition set."); // This should not happen!
 
 	json responseData;
 	responseData["transitionName"] = obs_source_get_name(transition);
@@ -136,7 +133,7 @@ RequestResult RequestHandler::GetCurrentSceneTransition(const Request &)
  * @api requests
  * @category transitions
  */
-RequestResult RequestHandler::SetCurrentSceneTransition(const Request &request)
+RequestResult RequestHandler::SetCurrentSceneTransition(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -166,7 +163,7 @@ RequestResult RequestHandler::SetCurrentSceneTransition(const Request &request)
  * @api requests
  * @category transitions
  */
-RequestResult RequestHandler::SetCurrentSceneTransitionDuration(const Request &request)
+RequestResult RequestHandler::SetCurrentSceneTransitionDuration(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -193,7 +190,7 @@ RequestResult RequestHandler::SetCurrentSceneTransitionDuration(const Request &r
  * @api requests
  * @category transitions
  */
-RequestResult RequestHandler::SetCurrentSceneTransitionSettings(const Request &request)
+RequestResult RequestHandler::SetCurrentSceneTransitionSettings(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -202,12 +199,10 @@ RequestResult RequestHandler::SetCurrentSceneTransitionSettings(const Request &r
 
 	OBSSourceAutoRelease transition = obs_frontend_get_current_transition();
 	if (!transition)
-		return RequestResult::Error(RequestStatus::InvalidResourceState,
+		return RequestResult::Error(RequestStatus::InvalidResourceState, "OBS does not currently have a scene transition set."); // This should not happen!
-					    "OBS does not currently have a scene transition set."); // This should not happen!
 
 	if (!obs_source_configurable(transition))
-		return RequestResult::Error(RequestStatus::ResourceNotConfigurable,
+		return RequestResult::Error(RequestStatus::ResourceNotConfigurable, "The current transition does not support custom settings.");
-					    "The current transition does not support custom settings.");
 
 	bool overlay = true;
 	if (request.Contains("overlay")) {
@@ -219,8 +214,7 @@ RequestResult RequestHandler::SetCurrentSceneTransitionSettings(const Request &r
 
 	OBSDataAutoRelease newSettings = Utils::Json::JsonToObsData(request.RequestData["transitionSettings"]);
 	if (!newSettings)
-		return RequestResult::Error(RequestStatus::RequestProcessingFailed,
+		return RequestResult::Error(RequestStatus::RequestProcessingFailed, "An internal data conversion operation failed. Please report this!");
-					    "An internal data conversion operation failed. Please report this!");
 
 	if (overlay)
 		obs_source_update(transition, newSettings);
@@ -232,33 +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.
  *
@@ -269,7 +236,7 @@ RequestResult RequestHandler::GetCurrentSceneTransitionCursor(const Request &)
  * @api requests
  * @category transitions
  */
-RequestResult RequestHandler::TriggerStudioModeTransition(const Request &)
+RequestResult RequestHandler::TriggerStudioModeTransition(const Request&)
 {
 	if (!obs_frontend_preview_program_mode_active())
 		return RequestResult::Error(RequestStatus::StudioModeNotActive);
@@ -280,49 +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();
-}

src/requesthandler/RequestHandler_Ui.cpp

@@ -17,11 +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 <QGuiApplication>
-#include <QScreen>
-#include <QRect>
-#include <sstream>
-
 #include "RequestHandler.h"
 
 /**
@@ -36,7 +31,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
  * @category ui
  * @api requests
  */
-RequestResult RequestHandler::GetStudioModeEnabled(const Request &)
+RequestResult RequestHandler::GetStudioModeEnabled(const Request&)
 {
 	json responseData;
 	responseData["studioModeEnabled"] = obs_frontend_preview_program_mode_active();
@@ -55,7 +50,7 @@ RequestResult RequestHandler::GetStudioModeEnabled(const Request &)
  * @category ui
  * @api requests
  */
-RequestResult RequestHandler::SetStudioModeEnabled(const Request &request)
+RequestResult RequestHandler::SetStudioModeEnabled(const Request& request)
 {
 	RequestStatus::RequestStatus statusCode;
 	std::string comment;
@@ -67,238 +62,11 @@ RequestResult RequestHandler::SetStudioModeEnabled(const Request &request)
 		// (Bad) Create a boolean then pass it as a reference to the task. Requires `wait` in obs_queue_task() to be true, else undefined behavior
 		bool studioModeEnabled = request.RequestData["studioModeEnabled"];
 		// Queue the task inside of the UI thread to prevent race conditions
-		obs_queue_task(
+		obs_queue_task(OBS_TASK_UI, [](void* param) {
-			OBS_TASK_UI,
+			auto studioModeEnabled = (bool*)param;
-			[](void *param) {
+			obs_frontend_set_preview_program_mode(*studioModeEnabled);
-				auto studioModeEnabled = (bool *)param;
+		}, &studioModeEnabled, true);
-				obs_frontend_set_preview_program_mode(*studioModeEnabled);
-			},
-			&studioModeEnabled, true);
 	}
 
 	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();
-}
-
-/**
- * Gets a list of connected monitors and information about them.
- *
- * @responseField monitors | Array<Object> | a list of detected monitors with some information
- *
- * @requestType GetMonitorList
- * @complexity 2
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @category ui
- * @api requests
- */
-RequestResult RequestHandler::GetMonitorList(const Request &)
-{
-	json responseData;
-	std::vector<json> monitorsData;
-	QList<QScreen *> screensList = QGuiApplication::screens();
-	for (int screenIndex = 0; screenIndex < screensList.size(); screenIndex++) {
-		json screenData;
-		QScreen const *screen = screensList[screenIndex];
-		std::stringstream nameAndIndex;
-		nameAndIndex << screen->name().toStdString();
-		nameAndIndex << '(' << screenIndex << ')';
-		screenData["monitorName"] = nameAndIndex.str();
-		screenData["monitorIndex"] = screenIndex;
-		const QRect screenGeometry = screen->geometry();
-		screenData["monitorWidth"] = screenGeometry.width();
-		screenData["monitorHeight"] = screenGeometry.height();
-		screenData["monitorPositionX"] = screenGeometry.x();
-		screenData["monitorPositionY"] = screenGeometry.y();
-		monitorsData.push_back(screenData);
-	}
-	responseData["monitors"] = monitorsData;
-	return RequestResult::Success(responseData);
-}
-
-/**
- * Opens a projector for a specific output video mix.
- *
- * Mix types:
- *
- * - `OBS_WEBSOCKET_VIDEO_MIX_TYPE_PREVIEW`
- * - `OBS_WEBSOCKET_VIDEO_MIX_TYPE_PROGRAM`
- * - `OBS_WEBSOCKET_VIDEO_MIX_TYPE_MULTIVIEW`
- *
- * Note: This request serves to provide feature parity with 4.x. It is very likely to be changed/deprecated in a future release.
- *
- * @requestField videoMixType            | String | Type of mix to open
- * @requestField ?monitorIndex      | Number | Monitor index, use `GetMonitorList` to obtain index | None | -1: Opens projector in windowed mode
- * @requestField ?projectorGeometry | String | Size/Position data for a windowed projector, in Qt Base64 encoded format. Mutually exclusive with `monitorIndex` | N/A
- *
- * @requestType OpenVideoMixProjector
- * @complexity 3
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @category ui
- * @api requests
- */
-RequestResult RequestHandler::OpenVideoMixProjector(const Request &request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	if (!request.ValidateString("videoMixType", statusCode, comment))
-		return RequestResult::Error(statusCode, comment);
-
-	std::string videoMixType = request.RequestData["videoMixType"];
-	const char *projectorType;
-	if (videoMixType == "OBS_WEBSOCKET_VIDEO_MIX_TYPE_PREVIEW")
-		projectorType = "Preview";
-	else if (videoMixType == "OBS_WEBSOCKET_VIDEO_MIX_TYPE_PROGRAM")
-		projectorType = "StudioProgram";
-	else if (videoMixType == "OBS_WEBSOCKET_VIDEO_MIX_TYPE_MULTIVIEW")
-		projectorType = "Multiview";
-	else
-		return RequestResult::Error(RequestStatus::InvalidRequestField,
-					    "The field `videoMixType` has an invalid enum value.");
-
-	int monitorIndex = -1;
-	if (request.Contains("monitorIndex")) {
-		if (!request.ValidateOptionalNumber("monitorIndex", statusCode, comment, -1, 9))
-			return RequestResult::Error(statusCode, comment);
-		monitorIndex = request.RequestData["monitorIndex"];
-	}
-
-	std::string projectorGeometry;
-	if (request.Contains("projectorGeometry")) {
-		if (!request.ValidateOptionalString("projectorGeometry", statusCode, comment))
-			return RequestResult::Error(statusCode, comment);
-		if (monitorIndex != -1)
-			return RequestResult::Error(RequestStatus::TooManyRequestFields,
-						    "`monitorIndex` and `projectorGeometry` are mutually exclusive.");
-		projectorGeometry = request.RequestData["projectorGeometry"];
-	}
-
-	obs_frontend_open_projector(projectorType, monitorIndex, projectorGeometry.c_str(), nullptr);
-
-	return RequestResult::Success();
-}
-
-/**
- * Opens a projector for a source.
- *
- * Note: This request serves to provide feature parity with 4.x. It is very likely to be changed/deprecated in a future release.
- *
- * @requestField sourceName         | String | Name of the source to open a projector for
- * @requestField ?monitorIndex      | Number | Monitor index, use `GetMonitorList` to obtain index | None | -1: Opens projector in windowed mode
- * @requestField ?projectorGeometry | String | Size/Position data for a windowed projector, in Qt Base64 encoded format. Mutually exclusive with `monitorIndex` | N/A
- *
- * @requestType OpenSourceProjector
- * @complexity 3
- * @rpcVersion -1
- * @initialVersion 5.0.0
- * @category ui
- * @api requests
- */
-RequestResult RequestHandler::OpenSourceProjector(const Request &request)
-{
-	RequestStatus::RequestStatus statusCode;
-	std::string comment;
-	OBSSourceAutoRelease source = request.ValidateSource("sourceName", statusCode, comment);
-	if (!source)
-		return RequestResult::Error(statusCode, comment);
-
-	int monitorIndex = -1;
-	if (request.Contains("monitorIndex")) {
-		if (!request.ValidateOptionalNumber("monitorIndex", statusCode, comment, -1, 9))
-			return RequestResult::Error(statusCode, comment);
-		monitorIndex = request.RequestData["monitorIndex"];
-	}
-
-	std::string projectorGeometry;
-	if (request.Contains("projectorGeometry")) {
-		if (!request.ValidateOptionalString("projectorGeometry", statusCode, comment))
-			return RequestResult::Error(statusCode, comment);
-		if (monitorIndex != -1)
-			return RequestResult::Error(RequestStatus::TooManyRequestFields,
-						    "`monitorIndex` and `projectorGeometry` are mutually exclusive.");
-		projectorGeometry = request.RequestData["projectorGeometry"];
-	}
-
-	obs_frontend_open_projector("Source", monitorIndex, projectorGeometry.c_str(), obs_source_get_name(source));
-
-	return RequestResult::Success();
-}

src/requesthandler/rpc/Request.cpp

@@ -29,12 +29,11 @@ json GetDefaultJsonObject(const json &requestData)
 		return requestData;
 }
 
-Request::Request(const std::string &requestType, const json &requestData,
+Request::Request(const std::string &requestType, const json &requestData, const RequestBatchExecutionType::RequestBatchExecutionType executionType) :
-		 const RequestBatchExecutionType::RequestBatchExecutionType executionType)
+	RequestType(requestType),
-	: RequestType(requestType),
+	HasRequestData(requestData.is_object()),
-	  HasRequestData(requestData.is_object()),
+	RequestData(GetDefaultJsonObject(requestData)),
-	  RequestData(GetDefaultJsonObject(requestData)),
+	ExecutionType(executionType)
-	  ExecutionType(executionType)
 {
 }
 
@@ -60,8 +59,7 @@ bool Request::ValidateBasic(const std::string &keyName, RequestStatus::RequestSt
 	return true;
 }
 
-bool Request::ValidateOptionalNumber(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment,
+bool Request::ValidateOptionalNumber(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const double minValue, const double maxValue) const
-				     const double minValue, const double maxValue) const
 {
 	if (!RequestData[keyName].is_number()) {
 		statusCode = RequestStatus::InvalidRequestFieldType;
@@ -72,22 +70,19 @@ bool Request::ValidateOptionalNumber(const std::string &keyName, RequestStatus::
 	double value = RequestData[keyName];
 	if (value < minValue) {
 		statusCode = RequestStatus::RequestFieldOutOfRange;
-		comment = std::string("The field value of `") + keyName + "` is below the minimum of `" + std::to_string(minValue) +
+		comment = std::string("The field value of `") + keyName + "` is below the minimum of `" + std::to_string(minValue) + "`";
-			  "`";
 		return false;
 	}
 	if (value > maxValue) {
 		statusCode = RequestStatus::RequestFieldOutOfRange;
-		comment = std::string("The field value of `") + keyName + "` is above the maximum of `" + std::to_string(maxValue) +
+		comment = std::string("The field value of `") + keyName + "` is above the maximum of `" + std::to_string(maxValue) + "`";
-			  "`";
 		return false;
 	}
 
 	return true;
 }
 
-bool Request::ValidateNumber(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment,
+bool Request::ValidateNumber(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const double minValue, const double maxValue) const
-			     const double minValue, const double maxValue) const
 {
 	if (!ValidateBasic(keyName, statusCode, comment))
 		return false;
@@ -98,8 +93,7 @@ bool Request::ValidateNumber(const std::string &keyName, RequestStatus::RequestS
 	return true;
 }
 
-bool Request::ValidateOptionalString(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment,
+bool Request::ValidateOptionalString(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const bool allowEmpty) const
-				     const bool allowEmpty) const
 {
 	if (!RequestData[keyName].is_string()) {
 		statusCode = RequestStatus::InvalidRequestFieldType;
@@ -116,8 +110,7 @@ bool Request::ValidateOptionalString(const std::string &keyName, RequestStatus::
 	return true;
 }
 
-bool Request::ValidateString(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment,
+bool Request::ValidateString(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const bool allowEmpty) const
-			     const bool allowEmpty) const
 {
 	if (!ValidateBasic(keyName, statusCode, comment))
 		return false;
@@ -128,8 +121,7 @@ bool Request::ValidateString(const std::string &keyName, RequestStatus::RequestS
 	return true;
 }
 
-bool Request::ValidateOptionalBoolean(const std::string &keyName, RequestStatus::RequestStatus &statusCode,
+bool Request::ValidateOptionalBoolean(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment) const
-				      std::string &comment) const
 {
 	if (!RequestData[keyName].is_boolean()) {
 		statusCode = RequestStatus::InvalidRequestFieldType;
@@ -151,8 +143,7 @@ bool Request::ValidateBoolean(const std::string &keyName, RequestStatus::Request
 	return true;
 }
 
-bool Request::ValidateOptionalObject(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment,
+bool Request::ValidateOptionalObject(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const bool allowEmpty) const
-				     const bool allowEmpty) const
 {
 	if (!RequestData[keyName].is_object()) {
 		statusCode = RequestStatus::InvalidRequestFieldType;
@@ -169,8 +160,7 @@ bool Request::ValidateOptionalObject(const std::string &keyName, RequestStatus::
 	return true;
 }
 
-bool Request::ValidateObject(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment,
+bool Request::ValidateObject(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const bool allowEmpty) const
-			     const bool allowEmpty) const
 {
 	if (!ValidateBasic(keyName, statusCode, comment))
 		return false;
@@ -181,8 +171,7 @@ bool Request::ValidateObject(const std::string &keyName, RequestStatus::RequestS
 	return true;
 }
 
-bool Request::ValidateOptionalArray(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment,
+bool Request::ValidateOptionalArray(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const bool allowEmpty) const
-				    const bool allowEmpty) const
 {
 	if (!RequestData[keyName].is_array()) {
 		statusCode = RequestStatus::InvalidRequestFieldType;
@@ -199,8 +188,7 @@ bool Request::ValidateOptionalArray(const std::string &keyName, RequestStatus::R
 	return true;
 }
 
-bool Request::ValidateArray(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment,
+bool Request::ValidateArray(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const bool allowEmpty) const
-			    const bool allowEmpty) const
 {
 	if (!ValidateBasic(keyName, statusCode, comment))
 		return false;
@@ -211,8 +199,7 @@ bool Request::ValidateArray(const std::string &keyName, RequestStatus::RequestSt
 	return true;
 }
 
-obs_source_t *Request::ValidateSource(const std::string &keyName, RequestStatus::RequestStatus &statusCode,
+obs_source_t *Request::ValidateSource(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment) const
-				      std::string &comment) const
 {
 	if (!ValidateString(keyName, statusCode, comment))
 		return nullptr;
@@ -229,8 +216,7 @@ obs_source_t *Request::ValidateSource(const std::string &keyName, RequestStatus:
 	return ret;
 }
 
-obs_source_t *Request::ValidateScene(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment,
+obs_source_t *Request::ValidateScene(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const ObsWebSocketSceneFilter filter) const
-				     const ObsWebSocketSceneFilter filter) const
 {
 	obs_source_t *ret = ValidateSource(keyName, statusCode, comment);
 	if (!ret)
@@ -259,8 +245,7 @@ obs_source_t *Request::ValidateScene(const std::string &keyName, RequestStatus::
 	return ret;
 }
 
-obs_scene_t *Request::ValidateScene2(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment,
+obs_scene_t *Request::ValidateScene2(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const ObsWebSocketSceneFilter filter) const
-				     const ObsWebSocketSceneFilter filter) const
 {
 	OBSSourceAutoRelease sceneSource = ValidateSource(keyName, statusCode, comment);
 	if (!sceneSource)
@@ -279,19 +264,22 @@ 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;
 	}
 }
 
-obs_source_t *Request::ValidateInput(const std::string &keyName, RequestStatus::RequestStatus &statusCode,
+obs_source_t *Request::ValidateInput(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment) const
-				     std::string &comment) const
 {
 	obs_source_t *ret = ValidateSource(keyName, statusCode, comment);
 	if (!ret)
@@ -307,32 +295,7 @@ obs_source_t *Request::ValidateInput(const std::string &keyName, RequestStatus::
 	return ret;
 }
 
-FilterPair Request::ValidateFilter(const std::string &sourceKeyName, const std::string &filterKeyName,
+obs_sceneitem_t *Request::ValidateSceneItem(const std::string &sceneKeyName, const std::string &sceneItemIdKeyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const ObsWebSocketSceneFilter filter) const
-				   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);
 	if (!scene)
@@ -346,29 +309,10 @@ obs_sceneitem_t *Request::ValidateSceneItem(const std::string &sceneKeyName, con
 	OBSSceneItem sceneItem = obs_scene_find_sceneitem_by_id(scene, sceneItemId);
 	if (!sceneItem) {
 		statusCode = RequestStatus::ResourceNotFound;
-		comment = std::string("No scene items were found in scene `") + RequestData[sceneKeyName].get<std::string>() +
+		comment = std::string("No scene items were found in scene `") + RequestData[sceneKeyName].get<std::string>() + "` with the ID `" + std::to_string(sceneItemId) + "`.";
-			  "` with the ID `" + std::to_string(sceneItemId) + "`.";
 		return nullptr;
 	}
 
 	obs_sceneitem_addref(sceneItem);
 	return sceneItem;
 }
-
-obs_output_t *Request::ValidateOutput(const std::string &keyName, RequestStatus::RequestStatus &statusCode,
-				      std::string &comment) const
-{
-	if (!ValidateString(keyName, statusCode, comment))
-		return nullptr;
-
-	std::string outputName = RequestData[keyName];
-
-	obs_output_t *ret = obs_get_output_by_name(outputName.c_str());
-	if (!ret) {
-		statusCode = RequestStatus::ResourceNotFound;
-		comment = std::string("No output was found with the name `") + outputName + "`.";
-		return nullptr;
-	}
-
-	return ret;
-}

src/requesthandler/rpc/Request.h

@@ -29,56 +29,31 @@ enum ObsWebSocketSceneFilter {
 	OBS_WEBSOCKET_SCENE_FILTER_SCENE_OR_GROUP,
 };
 
-// We return filters as a pair because `obs_filter_get_parent()` is apparently volatile
+struct Request
-struct FilterPair {
+{
-	OBSSourceAutoRelease source;
+	Request(const std::string &requestType, const json &requestData = nullptr, const RequestBatchExecutionType::RequestBatchExecutionType executionType = RequestBatchExecutionType::None);
-	OBSSourceAutoRelease filter;
-};
-
-struct Request {
-	Request(const std::string &requestType, const json &requestData = nullptr,
-		const RequestBatchExecutionType::RequestBatchExecutionType executionType = RequestBatchExecutionType::None);
 
 	// Contains the key and is not null
 	bool Contains(const std::string &keyName) const;
 
 	bool ValidateBasic(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment) const;
-	bool ValidateOptionalNumber(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment,
+	bool ValidateOptionalNumber(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const double minValue = -INFINITY, const double maxValue = INFINITY) const;
-				    const double minValue = -INFINITY, const double maxValue = INFINITY) const;
+	bool ValidateNumber(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const double minValue = -INFINITY, const double maxValue = INFINITY) const;
-	bool ValidateNumber(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment,
+	bool ValidateOptionalString(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const bool allowEmpty = false) const;
-			    const double minValue = -INFINITY, const double maxValue = INFINITY) const;
+	bool ValidateString(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const bool allowEmpty = false) const;
-	bool ValidateOptionalString(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment,
+	bool ValidateOptionalBoolean(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment) const;
-				    const bool allowEmpty = false) const;
-	bool ValidateString(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment,
-			    const bool allowEmpty = false) const;
-	bool ValidateOptionalBoolean(const std::string &keyName, RequestStatus::RequestStatus &statusCode,
-				     std::string &comment) const;
 	bool ValidateBoolean(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment) const;
-	bool ValidateOptionalObject(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment,
+	bool ValidateOptionalObject(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const bool allowEmpty = false) const;
-				    const bool allowEmpty = false) const;
+	bool ValidateObject(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const bool allowEmpty = false) const;
-	bool ValidateObject(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment,
+	bool ValidateOptionalArray(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const bool allowEmpty = false) const;
-			    const bool allowEmpty = false) const;
+	bool ValidateArray(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const bool allowEmpty = false) const;
-	bool ValidateOptionalArray(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment,
-				   const bool allowEmpty = false) const;
-	bool ValidateArray(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment,
-			   const bool allowEmpty = false) const;
 
 	// All return values have incremented refcounts
-	obs_source_t *ValidateSource(const std::string &keyName, RequestStatus::RequestStatus &statusCode,
+	obs_source_t *ValidateSource(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment) const;
-				     std::string &comment) const;
+	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_source_t *ValidateScene(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment,
+	obs_scene_t *ValidateScene2(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment, const ObsWebSocketSceneFilter filter = OBS_WEBSOCKET_SCENE_FILTER_SCENE_ONLY) const;
-				    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;
-	obs_scene_t *ValidateScene2(const std::string &keyName, RequestStatus::RequestStatus &statusCode, std::string &comment,
+	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;
-				    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;
-	obs_output_t *ValidateOutput(const std::string &keyName, RequestStatus::RequestStatus &statusCode,
-				     std::string &comment) const;
 
 	std::string RequestType;
 	bool HasRequestData;

src/requesthandler/rpc/RequestBatchRequest.cpp

@@ -18,9 +18,9 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 
 #include "RequestBatchRequest.h"
 
-RequestBatchRequest::RequestBatchRequest(const std::string &requestType, const json &requestData,
+RequestBatchRequest::RequestBatchRequest(const std::string &requestType, const json &requestData, RequestBatchExecutionType::RequestBatchExecutionType executionType, const json &inputVariables, const json &outputVariables) :
-					 RequestBatchExecutionType::RequestBatchExecutionType executionType,
+	Request(requestType, requestData, executionType),
-					 const json &inputVariables, const json &outputVariables)
+	InputVariables(inputVariables),
-	: Request(requestType, requestData, executionType), InputVariables(inputVariables), OutputVariables(outputVariables)
+	OutputVariables(outputVariables)
 {
 }

src/requesthandler/rpc/RequestBatchRequest.h

@@ -21,9 +21,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #include "Request.h"
 
 struct RequestBatchRequest : Request {
-	RequestBatchRequest(const std::string &requestType, const json &requestData,
+	RequestBatchRequest(const std::string &requestType, const json &requestData, RequestBatchExecutionType::RequestBatchExecutionType executionType, const json &inputVariables = nullptr, const json &outputVariables = nullptr);
-			    RequestBatchExecutionType::RequestBatchExecutionType executionType,
-			    const json &inputVariables = nullptr, const json &outputVariables = nullptr);
 
 	json InputVariables;
 	json OutputVariables;

src/requesthandler/rpc/RequestResult.cpp

@@ -19,8 +19,11 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 
 #include "RequestResult.h"
 
-RequestResult::RequestResult(RequestStatus::RequestStatus statusCode, json responseData, std::string comment)
+RequestResult::RequestResult(RequestStatus::RequestStatus statusCode, json responseData, std::string comment) :
-	: StatusCode(statusCode), ResponseData(responseData), Comment(comment), SleepFrames(0)
+	StatusCode(statusCode),
+	ResponseData(responseData),
+	Comment(comment),
+	SleepFrames(0)
 {
 }
 

src/requesthandler/rpc/RequestResult.h

@@ -22,9 +22,9 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #include "../types/RequestStatus.h"
 #include "../../utils/Json.h"
 
-struct RequestResult {
+struct RequestResult
-	RequestResult(RequestStatus::RequestStatus statusCode = RequestStatus::Success, json responseData = nullptr,
+{
-		      std::string comment = "");
+	RequestResult(RequestStatus::RequestStatus statusCode = RequestStatus::Success, json responseData = nullptr, std::string comment = "");
 	static RequestResult Success(json responseData = nullptr);
 	static RequestResult Error(RequestStatus::RequestStatus statusCode, std::string comment = "");
 	RequestStatus::RequestStatus StatusCode;

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,5 +77,8 @@ namespace RequestBatchExecutionType {
 		Parallel = 2,
 	};
 
-	inline bool IsValid(int8_t executionType) { return executionType >= None && executionType <= Parallel; }
+	inline bool IsValid(int executionType)
+	{
+		return executionType >= None && executionType <= Parallel;
+	}
 }

src/requesthandler/types/RequestStatus.h

@@ -262,6 +262,7 @@ namespace RequestStatus {
 		* @api enums
 		*/
 		StudioModeNotActive = 506,
+		
 
 		/**
 		* The resource was not found.
@@ -344,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.

src/utils/Compat.cpp

@@ -1,32 +1,35 @@
-/*
+/*
-obs-websocket
+obs-websocket
-Copyright (C) 2016-2021 Stephane Lepin <stephane.lepin@gmail.com>
+Copyright (C) 2016-2021 Stephane Lepin <stephane.lepin@gmail.com>
-Copyright (C) 2020-2021 Kyle Manning <tt2468@gmail.com>
+Copyright (C) 2020-2021 Kyle Manning <tt2468@gmail.com>
-
+
-This program is free software; you can redistribute it and/or modify
+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
+it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
+the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+(at your option) any later version.
-
+
-This program is distributed in the hope that it will be useful,
+This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
+but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+GNU General Public License for more details.
-
+
-You should have received a copy of the GNU General Public License along
+You should have received a copy of the GNU General Public License along
-with this program. If not, see <https://www.gnu.org/licenses/>
+with this program. If not, see <https://www.gnu.org/licenses/>
-*/
+*/
-
+
-#include "Compat.h"
+#include "Compat.h"
-
+
-Utils::Compat::StdFunctionRunnable::StdFunctionRunnable(std::function<void()> func) : cb(std::move(func)) {}
+Utils::Compat::StdFunctionRunnable::StdFunctionRunnable(std::function<void()> func) :
-
+	cb(std::move(func))
-void Utils::Compat::StdFunctionRunnable::run()
+{
-{
+}
-	cb();
+
-}
+void Utils::Compat::StdFunctionRunnable::run()
-
+{
-QRunnable *Utils::Compat::CreateFunctionRunnable(std::function<void()> func)
+	cb();
-{
+}
-	return new Utils::Compat::StdFunctionRunnable(std::move(func));
+
-}
+QRunnable *Utils::Compat::CreateFunctionRunnable(std::function<void()> func)
+{
+	return new Utils::Compat::StdFunctionRunnable(std::move(func));
+}

src/utils/Compat.h

@@ -27,10 +27,9 @@ namespace Utils {
 		// Reimplement QRunnable for std::function. Retrocompatability for Qt < 5.15
 		class StdFunctionRunnable : public QRunnable {
 			std::function<void()> cb;
-
+			public:
-		public:
+				StdFunctionRunnable(std::function<void()> func);
-			StdFunctionRunnable(std::function<void()> func);
+				void run() override;
-			void run() override;
 		};
 
 		QRunnable *CreateFunctionRunnable(std::function<void()> func);

src/utils/Crypto.cpp

@@ -63,7 +63,10 @@ bool Utils::Crypto::CheckAuthenticationString(std::string secret, std::string ch
 	secretAndChallenge += QString::fromStdString(challenge);
 
 	// Generate a SHA256 hash of secretAndChallenge
-	auto hash = QCryptographicHash::hash(secretAndChallenge.toUtf8(), QCryptographicHash::Algorithm::Sha256);
+	auto hash = QCryptographicHash::hash(
+		secretAndChallenge.toUtf8(),
+		QCryptographicHash::Algorithm::Sha256
+	);
 
 	// Encode the SHA256 hash to Base64
 	std::string expectedAuthenticationString = hash.toBase64().toStdString();

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())
@@ -45,7 +45,7 @@ void obs_data_set_json_array(obs_data_t *d, const char *key, json j)
 {
 	obs_data_array_t *array = obs_data_array_create();
 
-	for (auto &[key, value] : j.items()) {
+	for (auto& [key, value] : j.items()) {
 		if (!value.is_object())
 			continue;
 
@@ -61,7 +61,7 @@ void obs_data_set_json_array(obs_data_t *d, const char *key, json j)
 
 void obs_data_set_json_object_item(obs_data_t *d, json j)
 {
-	for (auto &[key, value] : j.items()) {
+	for (auto& [key, value] : j.items()) {
 		if (value.is_object()) {
 			obs_data_set_json_object(d, key.c_str(), value);
 		} else if (value.is_array()) {
@@ -153,22 +153,23 @@ json Utils::Json::ObsDataToJson(obs_data_t *d, bool includeDefault)
 			continue;
 
 		switch (type) {
-		case OBS_DATA_STRING:
+			case OBS_DATA_STRING:
-			set_json_string(&j, name, item);
+				set_json_string(&j, name, item);
-			break;
+				break;
-		case OBS_DATA_NUMBER:
+			case OBS_DATA_NUMBER:
-			set_json_number(&j, name, item);
+				set_json_number(&j, name, item);
-			break;
+				break;
-		case OBS_DATA_BOOLEAN:
+			case OBS_DATA_BOOLEAN:
-			set_json_bool(&j, name, item);
+				set_json_bool(&j, name, item);
-			break;
+				break;
-		case OBS_DATA_OBJECT:
+			case OBS_DATA_OBJECT:
-			set_json_object(&j, name, item, includeDefault);
+				set_json_object(&j, name, item, includeDefault);
-			break;
+				break;
-		case OBS_DATA_ARRAY:
+			case OBS_DATA_ARRAY:
-			set_json_array(&j, name, item, includeDefault);
+				set_json_array(&j, name, item, includeDefault);
-			break;
+				break;
-		default:;
+			default:
+				;
 		}
 	}
 
@@ -183,14 +184,14 @@ bool Utils::Json::GetJsonFileContent(std::string fileName, json &content)
 
 	try {
 		content = json::parse(textContent);
-	} catch (json::parse_error &e) {
+	} catch (json::parse_error& e) {
-		blog(LOG_WARNING, "Failed to decode content of JSON file `%s`. Error: %s", fileName.c_str(), e.what());
+		blog(LOG_WARNING, "Failed to decode content of JSON file `%s`. Error: %s", fileName.c_str(), e.what()); 
 		return false;
 	}
 	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);

src/utils/Json.h

@@ -25,58 +25,12 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 
 using json = nlohmann::json;
 
-NLOHMANN_JSON_SERIALIZE_ENUM(obs_source_type, {
-						      {OBS_SOURCE_TYPE_INPUT, "OBS_SOURCE_TYPE_INPUT"},
-						      {OBS_SOURCE_TYPE_FILTER, "OBS_SOURCE_TYPE_FILTER"},
-						      {OBS_SOURCE_TYPE_TRANSITION, "OBS_SOURCE_TYPE_TRANSITION"},
-						      {OBS_SOURCE_TYPE_SCENE, "OBS_SOURCE_TYPE_SCENE"},
-					      })
-
-NLOHMANN_JSON_SERIALIZE_ENUM(obs_monitoring_type,
-			     {
-				     {OBS_MONITORING_TYPE_NONE, "OBS_MONITORING_TYPE_NONE"},
-				     {OBS_MONITORING_TYPE_MONITOR_ONLY, "OBS_MONITORING_TYPE_MONITOR_ONLY"},
-				     {OBS_MONITORING_TYPE_MONITOR_AND_OUTPUT, "OBS_MONITORING_TYPE_MONITOR_AND_OUTPUT"},
-			     })
-
-NLOHMANN_JSON_SERIALIZE_ENUM(obs_media_state, {
-						      {OBS_MEDIA_STATE_NONE, "OBS_MEDIA_STATE_NONE"},
-						      {OBS_MEDIA_STATE_PLAYING, "OBS_MEDIA_STATE_PLAYING"},
-						      {OBS_MEDIA_STATE_OPENING, "OBS_MEDIA_STATE_OPENING"},
-						      {OBS_MEDIA_STATE_BUFFERING, "OBS_MEDIA_STATE_BUFFERING"},
-						      {OBS_MEDIA_STATE_PAUSED, "OBS_MEDIA_STATE_PAUSED"},
-						      {OBS_MEDIA_STATE_STOPPED, "OBS_MEDIA_STATE_STOPPED"},
-						      {OBS_MEDIA_STATE_ENDED, "OBS_MEDIA_STATE_ENDED"},
-						      {OBS_MEDIA_STATE_ERROR, "OBS_MEDIA_STATE_ERROR"},
-					      })
-
-NLOHMANN_JSON_SERIALIZE_ENUM(obs_bounds_type, {
-						      {OBS_BOUNDS_NONE, "OBS_BOUNDS_NONE"},
-						      {OBS_BOUNDS_STRETCH, "OBS_BOUNDS_STRETCH"},
-						      {OBS_BOUNDS_SCALE_INNER, "OBS_BOUNDS_SCALE_INNER"},
-						      {OBS_BOUNDS_SCALE_OUTER, "OBS_BOUNDS_SCALE_OUTER"},
-						      {OBS_BOUNDS_SCALE_TO_WIDTH, "OBS_BOUNDS_SCALE_TO_WIDTH"},
-						      {OBS_BOUNDS_SCALE_TO_HEIGHT, "OBS_BOUNDS_SCALE_TO_HEIGHT"},
-						      {OBS_BOUNDS_MAX_ONLY, "OBS_BOUNDS_MAX_ONLY"},
-					      })
-
-NLOHMANN_JSON_SERIALIZE_ENUM(obs_blending_type, {
-							{OBS_BLEND_NORMAL, "OBS_BLEND_NORMAL"},
-							{OBS_BLEND_ADDITIVE, "OBS_BLEND_ADDITIVE"},
-							{OBS_BLEND_SUBTRACT, "OBS_BLEND_SUBTRACT"},
-							{OBS_BLEND_SCREEN, "OBS_BLEND_SCREEN"},
-							{OBS_BLEND_MULTIPLY, "OBS_BLEND_MULTIPLY"},
-							{OBS_BLEND_LIGHTEN, "OBS_BLEND_LIGHTEN"},
-							{OBS_BLEND_DARKEN, "OBS_BLEND_DARKEN"},
-						})
-
 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);
+		bool SetJsonFileContent(std::string fileName, json content, bool createNew = true);
-		static inline bool Contains(const json &j, std::string key) { return j.contains(key) && !j[key].is_null(); }
 	}
 }

src/utils/Obs.h

@@ -26,44 +26,43 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #include "Json.h"
 
 // Autorelease object definitions
-inline void ___properties_dummy_addref(obs_properties_t *) {}
+inline void ___properties_dummy_addref(obs_properties_t*){}
-using OBSPropertiesAutoDestroy = OBSRef<obs_properties_t *, ___properties_dummy_addref, obs_properties_destroy>;
+using OBSPropertiesAutoDestroy = OBSRef<obs_properties_t*, ___properties_dummy_addref, obs_properties_destroy>;
 
 #if !defined(OBS_AUTORELEASE)
-inline void ___source_dummy_addref(obs_source_t *) {}
+inline void ___source_dummy_addref(obs_source_t*){}
-inline void ___scene_dummy_addref(obs_scene_t *) {}
+inline void ___scene_dummy_addref(obs_scene_t*){}
-inline void ___sceneitem_dummy_addref(obs_sceneitem_t *) {}
+inline void ___sceneitem_dummy_addref(obs_sceneitem_t*){}
-inline void ___data_dummy_addref(obs_data_t *) {}
+inline void ___data_dummy_addref(obs_data_t*){}
-inline void ___data_array_dummy_addref(obs_data_array_t *) {}
+inline void ___data_array_dummy_addref(obs_data_array_t*){}
-inline void ___output_dummy_addref(obs_output_t *) {}
+inline void ___output_dummy_addref(obs_output_t*){}
-inline void ___encoder_dummy_addref(obs_encoder_t *) {}
+inline void ___encoder_dummy_addref(obs_encoder_t *){}
-inline void ___service_dummy_addref(obs_service_t *) {}
+inline void ___service_dummy_addref(obs_service_t *){}
 
-inline void ___weak_source_dummy_addref(obs_weak_source_t *) {}
+inline void ___weak_source_dummy_addref(obs_weak_source_t*){}
-inline void ___weak_output_dummy_addref(obs_weak_output_t *) {}
+inline void ___weak_output_dummy_addref(obs_weak_output_t *){}
-inline void ___weak_encoder_dummy_addref(obs_weak_encoder_t *) {}
+inline void ___weak_encoder_dummy_addref(obs_weak_encoder_t *){}
-inline void ___weak_service_dummy_addref(obs_weak_service_t *) {}
+inline void ___weak_service_dummy_addref(obs_weak_service_t *){}
 
-using OBSSourceAutoRelease = OBSRef<obs_source_t *, ___source_dummy_addref, obs_source_release>;
+using OBSSourceAutoRelease = OBSRef<obs_source_t*, ___source_dummy_addref, obs_source_release>;
-using OBSSceneAutoRelease = OBSRef<obs_scene_t *, ___scene_dummy_addref, obs_scene_release>;
+using OBSSceneAutoRelease = OBSRef<obs_scene_t*, ___scene_dummy_addref, obs_scene_release>;
-using OBSSceneItemAutoRelease = OBSRef<obs_sceneitem_t *, ___sceneitem_dummy_addref, obs_sceneitem_release>;
+using OBSSceneItemAutoRelease = OBSRef<obs_sceneitem_t*, ___sceneitem_dummy_addref, obs_sceneitem_release>;
-using OBSDataAutoRelease = OBSRef<obs_data_t *, ___data_dummy_addref, obs_data_release>;
+using OBSDataAutoRelease = OBSRef<obs_data_t*, ___data_dummy_addref, obs_data_release>;
-using OBSDataArrayAutoRelease = OBSRef<obs_data_array_t *, ___data_array_dummy_addref, obs_data_array_release>;
+using OBSDataArrayAutoRelease = OBSRef<obs_data_array_t*, ___data_array_dummy_addref, obs_data_array_release>;
-using OBSOutputAutoRelease = OBSRef<obs_output_t *, ___output_dummy_addref, obs_output_release>;
+using OBSOutputAutoRelease = OBSRef<obs_output_t*, ___output_dummy_addref, obs_output_release>;
 using OBSEncoderAutoRelease = OBSRef<obs_encoder_t *, ___encoder_dummy_addref, obs_encoder_release>;
 using OBSServiceAutoRelease = OBSRef<obs_service_t *, ___service_dummy_addref, obs_service_release>;
 
-using OBSWeakSourceAutoRelease = OBSRef<obs_weak_source_t *, ___weak_source_dummy_addref, obs_weak_source_release>;
+using OBSWeakSourceAutoRelease = OBSRef<obs_weak_source_t*, ___weak_source_dummy_addref, obs_weak_source_release>;
 using OBSWeakOutputAutoRelease = OBSRef<obs_weak_output_t *, ___weak_output_dummy_addref, obs_weak_output_release>;
 using OBSWeakEncoderAutoRelease = OBSRef<obs_weak_encoder_t *, ___weak_encoder_dummy_addref, obs_weak_encoder_release>;
 using OBSWeakServiceAutoRelease = OBSRef<obs_weak_service_t *, ___weak_service_dummy_addref, obs_weak_service_release>;
 #endif
 
-template<typename T> T *GetCalldataPointer(const calldata_t *data, const char *name)
+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 {
@@ -77,16 +76,6 @@ enum ObsOutputState {
 	OBS_WEBSOCKET_OUTPUT_RESUMED,
 };
 
-NLOHMANN_JSON_SERIALIZE_ENUM(ObsOutputState, {
-						     {OBS_WEBSOCKET_OUTPUT_UNKNOWN, "OBS_WEBSOCKET_OUTPUT_UNKNOWN"},
-						     {OBS_WEBSOCKET_OUTPUT_STARTING, "OBS_WEBSOCKET_OUTPUT_STARTING"},
-						     {OBS_WEBSOCKET_OUTPUT_STARTED, "OBS_WEBSOCKET_OUTPUT_STARTED"},
-						     {OBS_WEBSOCKET_OUTPUT_STOPPING, "OBS_WEBSOCKET_OUTPUT_STOPPING"},
-						     {OBS_WEBSOCKET_OUTPUT_STOPPED, "OBS_WEBSOCKET_OUTPUT_STOPPED"},
-						     {OBS_WEBSOCKET_OUTPUT_PAUSED, "OBS_WEBSOCKET_OUTPUT_PAUSED"},
-						     {OBS_WEBSOCKET_OUTPUT_RESUMED, "OBS_WEBSOCKET_OUTPUT_RESUMED"},
-					     })
-
 enum ObsMediaInputAction {
 	/**
 	* No action.
@@ -160,17 +149,6 @@ enum ObsMediaInputAction {
 	OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PREVIOUS,
 };
 
-NLOHMANN_JSON_SERIALIZE_ENUM(ObsMediaInputAction,
-			     {
-				     {OBS_WEBSOCKET_MEDIA_INPUT_ACTION_NONE, "OBS_WEBSOCKET_MEDIA_INPUT_ACTION_NONE"},
-				     {OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PLAY, "OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PLAY"},
-				     {OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PAUSE, "OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PAUSE"},
-				     {OBS_WEBSOCKET_MEDIA_INPUT_ACTION_STOP, "OBS_WEBSOCKET_MEDIA_INPUT_ACTION_STOP"},
-				     {OBS_WEBSOCKET_MEDIA_INPUT_ACTION_RESTART, "OBS_WEBSOCKET_MEDIA_INPUT_ACTION_RESTART"},
-				     {OBS_WEBSOCKET_MEDIA_INPUT_ACTION_NEXT, "OBS_WEBSOCKET_MEDIA_INPUT_ACTION_NEXT"},
-				     {OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PREVIOUS, "OBS_WEBSOCKET_MEDIA_INPUT_ACTION_PREVIOUS"},
-			     })
-
 namespace Utils {
 	namespace Obs {
 		namespace StringHelper {
@@ -179,15 +157,24 @@ namespace Utils {
 			std::string GetCurrentProfile();
 			std::string GetCurrentProfilePath();
 			std::string GetCurrentRecordOutputPath();
-			std::string GetLastRecordFileName();
+			std::string GetSourceType(obs_source_t *source);
-			std::string GetLastReplayBufferFileName();
+			std::string GetInputMonitorType(enum obs_monitoring_type monitorType);
+			std::string GetInputMonitorType(obs_source_t *input);
+			std::string GetMediaInputState(obs_source_t *input);
+			std::string GetLastReplayBufferFilePath();
+			std::string GetSceneItemBoundsType(enum obs_bounds_type type);
 			std::string DurationToTimecode(uint64_t);
+			std::string GetOutputState(ObsOutputState state);
+		}
+
+		namespace EnumHelper {
+			enum obs_bounds_type GetSceneItemBoundsType(std::string boundsType);
+			enum ObsMediaInputAction GetMediaInputAction(std::string mediaAction);
 		}
 
 		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 {
@@ -196,16 +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();
-			std::vector<json> GetOutputList();
 		}
 
 		namespace ObjectHelper {
@@ -216,22 +199,12 @@ namespace Utils {
 		namespace SearchHelper {
 			obs_hotkey_t *GetHotkeyByName(std::string name);
 			obs_source_t *GetSceneTransitionByName(std::string name); // Increments source ref. Use OBSSourceAutoRelease
-			obs_sceneitem_t *GetSceneItemByName(obs_scene_t *scene, std::string name,
+			obs_sceneitem_t *GetSceneItemByName(obs_scene_t *scene, std::string name); // Increments ref. Use OBSSceneItemAutoRelease
-							    int offset = 0); // Increments ref. Use OBSSceneItemAutoRelease
 		}
 
 		namespace ActionHelper {
-			obs_sceneitem_t *
+			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
-			CreateSceneItem(obs_source_t *source, obs_scene_t *scene, bool sceneItemEnabled = true,
+			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_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);
 		}
 	}
 }

src/utils/Obs_ActionHelper.cpp

@@ -20,16 +20,16 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #include "../plugin-macros.generated.h"
 
 struct CreateSceneItemData {
-	obs_source_t *source;                             // In
+	obs_source_t *source; // In
-	bool sceneItemEnabled;                            // In
+	bool sceneItemEnabled; // In
 	obs_transform_info *sceneItemTransform = nullptr; // In
-	obs_sceneitem_crop *sceneItemCrop = nullptr;      // In
+	obs_sceneitem_crop *sceneItemCrop = nullptr; // In
-	OBSSceneItem sceneItem;                           // Out
+	OBSSceneItem sceneItem; // Out
 };
 
-static void CreateSceneItemHelper(void *_data, obs_scene_t *scene)
+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)
@@ -41,9 +41,7 @@ static void CreateSceneItemHelper(void *_data, obs_scene_t *scene)
 	obs_sceneitem_set_visible(data->sceneItem, data->sceneItemEnabled);
 }
 
-obs_sceneitem_t *Utils::Obs::ActionHelper::CreateSceneItem(obs_source_t *source, obs_scene_t *scene, bool sceneItemEnabled,
+obs_sceneitem_t *Utils::Obs::ActionHelper::CreateSceneItem(obs_source_t *source, obs_scene_t *scene, bool sceneItemEnabled, obs_transform_info *sceneItemTransform, obs_sceneitem_crop *sceneItemCrop)
-							   obs_transform_info *sceneItemTransform,
-							   obs_sceneitem_crop *sceneItemCrop)
 {
 	// Sanity check for valid scene
 	if (!(source && scene))
@@ -66,8 +64,7 @@ obs_sceneitem_t *Utils::Obs::ActionHelper::CreateSceneItem(obs_source_t *source,
 	return data.sceneItem;
 }
 
-obs_sceneitem_t *Utils::Obs::ActionHelper::CreateInput(std::string inputName, std::string inputKind, obs_data_t *inputSettings,
+obs_sceneitem_t *Utils::Obs::ActionHelper::CreateInput(std::string inputName, std::string inputKind, obs_data_t *inputSettings, obs_scene_t *scene, bool sceneItemEnabled)
-						       obs_scene_t *scene, bool sceneItemEnabled)
 {
 	// Create the input
 	OBSSourceAutoRelease input = obs_source_create(inputKind.c_str(), inputName.c_str(), inputSettings, nullptr);
@@ -90,31 +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--;
-	}
-}

src/utils/Obs_ArrayHelper.cpp

@@ -29,7 +29,7 @@ static std::vector<std::string> ConvertStringArray(char **array)
 		return ret;
 
 	size_t index = 0;
-	char *value = nullptr;
+	char* value = nullptr;
 	do {
 		value = array[index];
 		if (value)
@@ -42,7 +42,7 @@ static std::vector<std::string> ConvertStringArray(char **array)
 
 std::vector<std::string> Utils::Obs::ArrayHelper::GetSceneCollectionList()
 {
-	char **sceneCollections = obs_frontend_get_scene_collections();
+	char** sceneCollections = obs_frontend_get_scene_collections();
 	auto ret = ConvertStringArray(sceneCollections);
 	bfree(sceneCollections);
 	return ret;
@@ -50,7 +50,7 @@ std::vector<std::string> Utils::Obs::ArrayHelper::GetSceneCollectionList()
 
 std::vector<std::string> Utils::Obs::ArrayHelper::GetProfileList()
 {
-	char **profiles = obs_frontend_get_profiles();
+	char** profiles = obs_frontend_get_profiles();
 	auto ret = ConvertStringArray(profiles);
 	bfree(profiles);
 	return ret;
@@ -60,15 +60,13 @@ std::vector<obs_hotkey_t *> Utils::Obs::ArrayHelper::GetHotkeyList()
 {
 	std::vector<obs_hotkey_t *> ret;
 
-	auto cb = [](void *data, obs_hotkey_id, obs_hotkey_t *hotkey) {
+	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);
 
 		return true;
-	};
+	}, &ret);
-
-	obs_enum_hotkeys(cb, &ret);
 
 	return ret;
 }
@@ -90,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;
@@ -109,48 +109,22 @@ 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;
 
-	auto cb = [](obs_scene_t *, obs_sceneitem_t *sceneItem, void *param) {
+	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);
-
-		// TODO: Make ObjectHelper util for scene items
 
 		json item;
 		item["sceneItemId"] = obs_sceneitem_get_id(sceneItem);
-		item["sceneItemIndex"] =
+		// Should be slightly faster than calling obs_sceneitem_get_order_position()
-			enumData->first.size(); // Should be slightly faster than calling obs_sceneitem_get_order_position()
+		item["sceneItemIndex"] = enumData->first.size();
 		if (!enumData->second) {
-			item["sceneItemEnabled"] = obs_sceneitem_visible(sceneItem);
-			item["sceneItemLocked"] = obs_sceneitem_locked(sceneItem);
-			item["sceneItemTransform"] = ObjectHelper::GetSceneItemTransform(sceneItem);
-			item["sceneItemBlendMode"] = obs_sceneitem_get_blending_mode(sceneItem);
 			OBSSource itemSource = obs_sceneitem_get_source(sceneItem);
 			item["sourceName"] = obs_source_get_name(itemSource);
-			item["sourceType"] = obs_source_get_type(itemSource);
+			item["sourceType"] = StringHelper::GetSourceType(itemSource);
 			if (obs_source_get_type(itemSource) == OBS_SOURCE_TYPE_INPUT)
 				item["inputKind"] = obs_source_get_id(itemSource);
 			else
@@ -164,9 +138,7 @@ std::vector<json> Utils::Obs::ArrayHelper::GetSceneItemList(obs_scene_t *scene,
 		enumData->first.push_back(item);
 
 		return true;
-	};
+	}, &enumData);
-
-	obs_scene_enum_items(scene, cb, &enumData);
 
 	return enumData.first;
 }
@@ -181,12 +153,12 @@ std::vector<json> Utils::Obs::ArrayHelper::GetInputList(std::string inputKind)
 	EnumInputInfo inputInfo;
 	inputInfo.inputKind = inputKind;
 
-	auto cb = [](void *param, obs_source_t *input) {
+	auto inputEnumProc = [](void *param, obs_source_t *input) {
 		// Sanity check in case the API changes
 		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);
 
@@ -201,9 +173,8 @@ std::vector<json> Utils::Obs::ArrayHelper::GetInputList(std::string inputKind)
 		inputInfo->inputs.push_back(inputJson);
 		return true;
 	};
-
 	// Actually enumerates only public inputs, despite the name
-	obs_enum_sources(cb, &inputInfo);
+	obs_enum_sources(inputEnumProc, &inputInfo);
 
 	return inputInfo.inputs;
 }
@@ -237,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);
@@ -276,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;
@@ -291,71 +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 cb = [](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, cb, &filters);
-
-	return filters;
-}
-
-std::vector<json> Utils::Obs::ArrayHelper::GetOutputList()
-{
-	std::vector<json> outputs;
-
-	auto cb = [](void *param, obs_output_t *output) {
-		auto outputs = reinterpret_cast<std::vector<json> *>(param);
-
-		auto rawFlags = obs_output_get_flags(output);
-		json flags;
-		flags["OBS_OUTPUT_AUDIO"] = !!(rawFlags & OBS_OUTPUT_AUDIO);
-		flags["OBS_OUTPUT_VIDEO"] = !!(rawFlags & OBS_OUTPUT_VIDEO);
-		flags["OBS_OUTPUT_ENCODED"] = !!(rawFlags & OBS_OUTPUT_ENCODED);
-		flags["OBS_OUTPUT_MULTI_TRACK"] = !!(rawFlags & OBS_OUTPUT_MULTI_TRACK);
-		flags["OBS_OUTPUT_SERVICE"] = !!(rawFlags & OBS_OUTPUT_SERVICE);
-
-		json outputJson;
-		outputJson["outputName"] = obs_output_get_name(output);
-		outputJson["outputKind"] = obs_output_get_id(output);
-		outputJson["outputWidth"] = obs_output_get_width(output);
-		outputJson["outputHeight"] = obs_output_get_height(output);
-		outputJson["outputActive"] = obs_output_active(output);
-		outputJson["outputFlags"] = flags;
-
-		outputs->push_back(outputJson);
-		return true;
-	};
-
-	obs_enum_outputs(cb, &outputs);
-
-	return outputs;
-}

src/utils/Obs_EnumHelper.cpp

@@ -0,0 +1,47 @@
+/*
+obs-websocket
+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 "Obs.h"
+#include "../plugin-macros.generated.h"
+
+#define RET_COMPARE(str, x) if (str == #x) return x;
+
+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);
+
+	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);
+
+	return OBS_WEBSOCKET_MEDIA_INPUT_ACTION_NONE;
+}

src/utils/Obs_NumberHelper.cpp

@@ -28,7 +28,7 @@ uint64_t Utils::Obs::NumberHelper::GetOutputDuration(obs_output_t *output)
 	if (!output || !obs_output_active(output))
 		return 0;
 
-	video_t *video = obs_output_video(output);
+	video_t* video = obs_output_video(output);
 	uint64_t frameTimeNs = video_output_get_frame_time(video);
 	int totalFrames = obs_output_get_total_frames(output);
 
@@ -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;
-}

src/utils/Obs_ObjectHelper.cpp

@@ -29,7 +29,7 @@ json Utils::Obs::ObjectHelper::GetStats()
 
 	std::string outputPath = Utils::Obs::StringHelper::GetCurrentRecordOutputPath();
 
-	video_t *video = obs_get_video();
+	video_t* video = obs_get_video();
 
 	ret["cpuUsage"] = os_cpu_usage_info_query(GetCpuUsageInfo());
 	ret["memoryUsage"] = (double)os_get_proc_resident_size() / (1024.0 * 1024.0);
@@ -54,8 +54,8 @@ json Utils::Obs::ObjectHelper::GetSceneItemTransform(obs_sceneitem_t *item)
 	obs_sceneitem_get_crop(item, &crop);
 
 	OBSSource source = obs_sceneitem_get_source(item);
-	float sourceWidth = (float)obs_source_get_width(source);
+	float sourceWidth = float(obs_source_get_width(source));
-	float sourceHeight = (float)obs_source_get_height(source);
+	float sourceHeight = float(obs_source_get_height(source));
 
 	ret["sourceWidth"] = sourceWidth;
 	ret["sourceHeight"] = sourceHeight;
@@ -73,15 +73,15 @@ json Utils::Obs::ObjectHelper::GetSceneItemTransform(obs_sceneitem_t *item)
 
 	ret["alignment"] = osi.alignment;
 
-	ret["boundsType"] = osi.bounds_type;
+	ret["boundsType"] = StringHelper::GetSceneItemBoundsType(osi.bounds_type);
 	ret["boundsAlignment"] = osi.bounds_alignment;
 	ret["boundsWidth"] = osi.bounds.x;
 	ret["boundsHeight"] = osi.bounds.y;
 
-	ret["cropLeft"] = (int)crop.left;
+	ret["cropLeft"] = int(crop.left);
-	ret["cropRight"] = (int)crop.right;
+	ret["cropRight"] = int(crop.right);
-	ret["cropTop"] = (int)crop.top;
+	ret["cropTop"] = int(crop.top);
-	ret["cropBottom"] = (int)crop.bottom;
+	ret["cropBottom"] = int(crop.bottom);
 
 	return ret;
 }

src/utils/Obs_SearchHelper.cpp

@@ -54,44 +54,15 @@ obs_source_t *Utils::Obs::SearchHelper::GetSceneTransitionByName(std::string nam
 	return ret;
 }
 
-struct SceneItemSearchData {
-	std::string name;
-	int offset;
-	obs_sceneitem_t *ret = nullptr;
-};
-
 // Increments item ref. Use OBSSceneItemAutoRelease
-obs_sceneitem_t *Utils::Obs::SearchHelper::GetSceneItemByName(obs_scene_t *scene, std::string name, int offset)
+obs_sceneitem_t *Utils::Obs::SearchHelper::GetSceneItemByName(obs_scene_t *scene, std::string name)
 {
 	if (name.empty())
 		return nullptr;
 
-	SceneItemSearchData enumData;
+	// Finds first matching scene item in scene, search starts at index 0
-	enumData.name = name;
+	OBSSceneItem ret = obs_scene_find_source(scene, name.c_str());
-	enumData.offset = offset;
+	obs_sceneitem_addref(ret);
 
-	auto cb = [](obs_scene_t *, obs_sceneitem_t *sceneItem, void *param) {
+	return ret;
-		auto enumData = static_cast<SceneItemSearchData *>(param);
-
-		OBSSource itemSource = obs_sceneitem_get_source(sceneItem);
-		std::string sourceName = obs_source_get_name(itemSource);
-		if (sourceName == enumData->name) {
-			if (enumData->offset > 0) {
-				enumData->offset--;
-			} else {
-				if (enumData->ret) // Release existing selection in the case of last match selection
-					obs_sceneitem_release(enumData->ret);
-				obs_sceneitem_addref(sceneItem);
-				enumData->ret = sceneItem;
-				if (enumData->offset == 0) // Only break if in normal selection mode (not offset == -1)
-					return false;
-			}
-		}
-
-		return true;
-	};
-
-	obs_scene_enum_items(scene, cb, &enumData);
-
-	return enumData.ret;
 }

src/utils/Obs_StringHelper.cpp

@@ -23,9 +23,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #include "Obs.h"
 #include "../plugin-macros.generated.h"
 
-#define CASE(x) \
+#define CASE(x) case x: return #x;
-	case x: \
-		return #x;
 
 std::string Utils::Obs::StringHelper::GetObsVersion()
 {
@@ -66,48 +64,84 @@ std::string Utils::Obs::StringHelper::GetCurrentProfilePath()
 
 std::string Utils::Obs::StringHelper::GetCurrentRecordOutputPath()
 {
-	char *recordOutputPath = obs_frontend_get_current_record_output_path();
+	//char *recordOutputPath = obs_frontend_get_current_record_output_path();
-	std::string ret = recordOutputPath;
+	//std::string ret = recordOutputPath;
-	bfree(recordOutputPath);
+	//bfree(recordOutputPath);
-	return ret;
+	//return ret;
+
+	return "";
 }
 
-std::string Utils::Obs::StringHelper::GetLastRecordFileName()
+std::string Utils::Obs::StringHelper::GetSourceType(obs_source_t *source)
 {
-	OBSOutputAutoRelease output = obs_frontend_get_recording_output();
+	obs_source_type sourceType = obs_source_get_type(source);
-	if (!output)
-		return "";
 
-	OBSDataAutoRelease outputSettings = obs_output_get_settings(output);
+	switch (sourceType) {
-
+		default:
-	obs_data_item_t *item = obs_data_item_byname(outputSettings, "url");
+		CASE(OBS_SOURCE_TYPE_INPUT)
-	if (!item) {
+		CASE(OBS_SOURCE_TYPE_FILTER)
-		item = obs_data_item_byname(outputSettings, "path");
+		CASE(OBS_SOURCE_TYPE_TRANSITION)
-		if (!item)
+		CASE(OBS_SOURCE_TYPE_SCENE)
-			return "";
 	}
-
-	std::string ret = obs_data_item_get_string(item);
-	obs_data_item_release(&item);
-	return ret;
 }
 
-std::string Utils::Obs::StringHelper::GetLastReplayBufferFileName()
+std::string Utils::Obs::StringHelper::GetInputMonitorType(enum obs_monitoring_type monitorType)
+{
+	switch (monitorType) {
+		default:
+		CASE(OBS_MONITORING_TYPE_NONE)
+		CASE(OBS_MONITORING_TYPE_MONITOR_ONLY)
+		CASE(OBS_MONITORING_TYPE_MONITOR_AND_OUTPUT)
+	}
+}
+
+std::string Utils::Obs::StringHelper::GetInputMonitorType(obs_source_t *input)
+{
+	obs_monitoring_type monitorType = obs_source_get_monitoring_type(input);
+
+	return GetInputMonitorType(monitorType);
+}
+
+std::string Utils::Obs::StringHelper::GetMediaInputState(obs_source_t *input)
+{
+	obs_media_state mediaState = obs_source_media_get_state(input);
+
+	switch (mediaState) {
+		default:
+		CASE(OBS_MEDIA_STATE_NONE)
+		CASE(OBS_MEDIA_STATE_PLAYING)
+		CASE(OBS_MEDIA_STATE_OPENING)
+		CASE(OBS_MEDIA_STATE_BUFFERING)
+		CASE(OBS_MEDIA_STATE_PAUSED)
+		CASE(OBS_MEDIA_STATE_STOPPED)
+		CASE(OBS_MEDIA_STATE_ENDED)
+		CASE(OBS_MEDIA_STATE_ERROR)
+	}
+}
+
+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);
+	return ret;
+}
 
-	if (!savedReplayPath)
+std::string Utils::Obs::StringHelper::GetSceneItemBoundsType(enum obs_bounds_type type)
-		return "";
+{
-
+	switch (type) {
-	return savedReplayPath;
+		default:
+		CASE(OBS_BOUNDS_NONE)
+		CASE(OBS_BOUNDS_STRETCH)
+		CASE(OBS_BOUNDS_SCALE_INNER)
+		CASE(OBS_BOUNDS_SCALE_OUTER)
+		CASE(OBS_BOUNDS_SCALE_TO_WIDTH)
+		CASE(OBS_BOUNDS_SCALE_TO_HEIGHT)
+		CASE(OBS_BOUNDS_MAX_ONLY)
+	}
 }
 
 std::string Utils::Obs::StringHelper::DurationToTimecode(uint64_t ms)
@@ -120,7 +154,20 @@ std::string Utils::Obs::StringHelper::DurationToTimecode(uint64_t ms)
 	uint64_t secsPart = secs % 60ULL;
 	uint64_t msPart = ms % 1000ULL;
 
-	QString formatted =
+	QString formatted = QString::asprintf("%02" PRIu64 ":%02" PRIu64 ":%02" PRIu64 ".%03" PRIu64, hoursPart, minutesPart, secsPart, msPart);
-		QString::asprintf("%02" PRIu64 ":%02" PRIu64 ":%02" PRIu64 ".%03" PRIu64, hoursPart, minutesPart, secsPart, msPart);
 	return formatted.toStdString();
 }
+
+std::string Utils::Obs::StringHelper::GetOutputState(ObsOutputState state)
+{
+	switch (state) {
+		default:
+		CASE(OBS_WEBSOCKET_OUTPUT_UNKNOWN)
+		CASE(OBS_WEBSOCKET_OUTPUT_STARTING)
+		CASE(OBS_WEBSOCKET_OUTPUT_STARTED)
+		CASE(OBS_WEBSOCKET_OUTPUT_STOPPING)
+		CASE(OBS_WEBSOCKET_OUTPUT_STOPPED)
+		CASE(OBS_WEBSOCKET_OUTPUT_PAUSED)
+		CASE(OBS_WEBSOCKET_OUTPUT_RESUMED)
+	}
+}

src/utils/Obs_VolumeMeter.cpp

@@ -1,354 +1,354 @@
-/*
+/*
-obs-websocket
+obs-websocket
-Copyright (C) 2014 by Leonhard Oelke <leonhard@in-verted.de>
+Copyright (C) 2014 by Leonhard Oelke <leonhard@in-verted.de>
-Copyright (C) 2016-2021 Stephane Lepin <stephane.lepin@gmail.com>
+Copyright (C) 2016-2021 Stephane Lepin <stephane.lepin@gmail.com>
-Copyright (C) 2020-2021 Kyle Manning <tt2468@gmail.com>
+Copyright (C) 2020-2021 Kyle Manning <tt2468@gmail.com>
-
+
-This program is free software; you can redistribute it and/or modify
+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
+it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
+the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+(at your option) any later version.
-
+
-This program is distributed in the hope that it will be useful,
+This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
+but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+GNU General Public License for more details.
-
+
-You should have received a copy of the GNU General Public License along
+You should have received a copy of the GNU General Public License along
-with this program. If not, see <https://www.gnu.org/licenses/>
+with this program. If not, see <https://www.gnu.org/licenses/>
-*/
+*/
-
+
-#include <cmath>
+#include <cmath>
-#include <algorithm>
+#include <algorithm>
-
+
-#include "Obs.h"
+#include "Obs.h"
-#include "Obs_VolumeMeter.h"
+#include "Obs_VolumeMeter.h"
-#include "Obs_VolumeMeter_Helpers.h"
+#include "Obs_VolumeMeter_Helpers.h"
-#include "../obs-websocket.h"
+#include "../obs-websocket.h"
-
+
-Utils::Obs::VolumeMeter::Meter::Meter(obs_source_t *input)
+Utils::Obs::VolumeMeter::Meter::Meter(obs_source_t *input) :
-	: PeakMeterType(SAMPLE_PEAK_METER),
+	PeakMeterType(SAMPLE_PEAK_METER),
-	  _input(obs_source_get_weak_source(input)),
+	_input(obs_source_get_weak_source(input)),
-	  _channels(0),
+	_channels(0),
-	  _lastUpdate(0),
+	_lastUpdate(0),
-	  _volume(obs_source_get_volume(input))
+	_volume(obs_source_get_volume(input))
-{
+{
-	signal_handler_t *sh = obs_source_get_signal_handler(input);
+	signal_handler_t *sh = obs_source_get_signal_handler(input);
-	signal_handler_connect(sh, "volume", Meter::InputVolumeCallback, this);
+	signal_handler_connect(sh, "volume", Meter::InputVolumeCallback, this);
-
+
-	obs_source_add_audio_capture_callback(input, Meter::InputAudioCaptureCallback, this);
+	obs_source_add_audio_capture_callback(input, Meter::InputAudioCaptureCallback, this);
-
+
-	blog_debug("[Utils::Obs::VolumeMeter::Meter::Meter] Meter created for input: %s", obs_source_get_name(input));
+	blog_debug("[Utils::Obs::VolumeMeter::Meter::Meter] Meter created for input: %s", obs_source_get_name(input));
-}
+}
-
+
-Utils::Obs::VolumeMeter::Meter::~Meter()
+Utils::Obs::VolumeMeter::Meter::~Meter()
-{
+{
-	OBSSourceAutoRelease input = obs_weak_source_get_source(_input);
+	OBSSourceAutoRelease input = obs_weak_source_get_source(_input);
-	if (!input) {
+	if (!input) {
-		blog(LOG_WARNING,
+		blog(LOG_WARNING, "[Utils::Obs::VolumeMeter::Meter::~Meter] Failed to get strong reference to input. Has it been destroyed?");
-		     "[Utils::Obs::VolumeMeter::Meter::~Meter] Failed to get strong reference to input. Has it been destroyed?");
+		return;
-		return;
+	}
-	}
+
-
+	signal_handler_t *sh = obs_source_get_signal_handler(input);
-	signal_handler_t *sh = obs_source_get_signal_handler(input);
+	signal_handler_disconnect(sh, "volume", Meter::InputVolumeCallback, this);
-	signal_handler_disconnect(sh, "volume", Meter::InputVolumeCallback, this);
+
-
+	obs_source_remove_audio_capture_callback(input, Meter::InputAudioCaptureCallback, this);
-	obs_source_remove_audio_capture_callback(input, Meter::InputAudioCaptureCallback, this);
+
-
+	blog_debug("[Utils::Obs::VolumeMeter::Meter::~Meter] Meter destroyed for input: %s", obs_source_get_name(input));
-	blog_debug("[Utils::Obs::VolumeMeter::Meter::~Meter] Meter destroyed for input: %s", obs_source_get_name(input));
+}
-}
+
-
+bool Utils::Obs::VolumeMeter::Meter::InputValid()
-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()
+json Utils::Obs::VolumeMeter::Meter::GetMeterData()
-{
+{
-	json ret;
+	json ret;
-
+
-	OBSSourceAutoRelease input = obs_weak_source_get_source(_input);
+	OBSSourceAutoRelease input = obs_weak_source_get_source(_input);
-	if (!input) {
+	if (!input) {
-		blog(LOG_WARNING,
+		blog(LOG_WARNING, "[Utils::Obs::VolumeMeter::Meter::GetMeterData] Failed to get strong reference to input. Has it been destroyed?");
-		     "[Utils::Obs::VolumeMeter::Meter::GetMeterData] Failed to get strong reference to input. Has it been destroyed?");
+		return ret;
-		return ret;
+	}
-	}
+
-
+	std::vector<std::vector<float>> levels;
-	std::vector<std::vector<float>> levels;
+	const float volume = _muted ? 0.0f : _volume.load();
-	const float volume = _muted ? 0.0f : _volume.load();
+
-
+	std::unique_lock<std::mutex> l(_mutex);
-	std::unique_lock<std::mutex> l(_mutex);
+
-
+	if (_lastUpdate != 0 && (os_gettime_ns() - _lastUpdate) * 0.000000001 > 0.3)
-	if (_lastUpdate != 0 && (os_gettime_ns() - _lastUpdate) * 0.000000001 > 0.3)
+		ResetAudioLevels();
-		ResetAudioLevels();
+
-
+	for (int channel = 0; channel < _channels; channel++) {
-	for (int channel = 0; channel < _channels; channel++) {
+		std::vector<float> level;
-		std::vector<float> level;
+		level.push_back(_magnitude[channel] * volume);
-		level.push_back(_magnitude[channel] * volume);
+		level.push_back(_peak[channel] * volume);
-		level.push_back(_peak[channel] * volume);
+		level.push_back(_peak[channel]);
-		level.push_back(_peak[channel]);
+
-
+		levels.push_back(level);
-		levels.push_back(level);
+	}
-	}
+	l.unlock();
-	l.unlock();
+
-
+	ret["inputName"] = obs_source_get_name(input);
-	ret["inputName"] = obs_source_get_name(input);
+	ret["inputLevelsMul"] = levels;
-	ret["inputLevelsMul"] = levels;
+
-
+	return ret;
-	return ret;
+}
-}
+
-
+// MUST HOLD LOCK
-// MUST HOLD LOCK
+void Utils::Obs::VolumeMeter::Meter::ResetAudioLevels()
-void Utils::Obs::VolumeMeter::Meter::ResetAudioLevels()
+{
-{
+	_lastUpdate = 0;
-	_lastUpdate = 0;
+	for (int channelNumber = 0; channelNumber < MAX_AUDIO_CHANNELS; channelNumber++) {
-	for (int channelNumber = 0; channelNumber < MAX_AUDIO_CHANNELS; channelNumber++) {
+		_magnitude[channelNumber] = 0;
-		_magnitude[channelNumber] = 0;
+		_peak[channelNumber] = 0;
-		_peak[channelNumber] = 0;
+	}
-	}
+}
-}
+
-
+// MUST HOLD LOCK
-// MUST HOLD LOCK
+void Utils::Obs::VolumeMeter::Meter::ProcessAudioChannels(const struct audio_data *data)
-void Utils::Obs::VolumeMeter::Meter::ProcessAudioChannels(const struct audio_data *data)
+{
-{
+	int channels = 0;
-	int channels = 0;
+	for (int i = 0; i < MAX_AV_PLANES; i++) {
-	for (int i = 0; i < MAX_AV_PLANES; i++) {
+		if (data->data[i])
-		if (data->data[i])
+			channels++;
-			channels++;
+	}
-	}
+
-
+	bool channelsChanged = _channels != channels;
-	bool channelsChanged = _channels != channels;
+	_channels = std::clamp(channels, 0, MAX_AUDIO_CHANNELS);
-	_channels = std::clamp(channels, 0, MAX_AUDIO_CHANNELS);
+
-
+	if (channelsChanged)
-	if (channelsChanged)
+		ResetAudioLevels();
-		ResetAudioLevels();
+}
-}
+
-
+// MUST HOLD LOCK
-// MUST HOLD LOCK
+void Utils::Obs::VolumeMeter::Meter::ProcessPeak(const struct audio_data *data)
-void Utils::Obs::VolumeMeter::Meter::ProcessPeak(const struct audio_data *data)
+{
-{
+	size_t sampleCount = data->frames;
-	size_t sampleCount = data->frames;
+	int channelNumber = 0;
-	int channelNumber = 0;
+
-
+	for (int planeNumber = 0; channelNumber < _channels; planeNumber++) {
-	for (int planeNumber = 0; channelNumber < _channels; planeNumber++) {
+		float *samples = (float*)data->data[planeNumber];
-		float *samples = (float *)data->data[planeNumber];
+		if (!samples)
-		if (!samples)
+			continue;
-			continue;
+
-
+		if (((uintptr_t)samples & 0xf) > 0) {
-		if (((uintptr_t)samples & 0xf) > 0) {
+			_peak[channelNumber] = 1.0f;
-			_peak[channelNumber] = 1.0f;
+			channelNumber++;
-			channelNumber++;
+			continue;
-			continue;
+		}
-		}
+
-
+		__m128 previousSamples = _mm_loadu_ps(_previousSamples[channelNumber]);
-		__m128 previousSamples = _mm_loadu_ps(_previousSamples[channelNumber]);
+
-
+		float peak;
-		float peak;
+		switch (PeakMeterType) {
-		switch (PeakMeterType) {
+			default:
-		default:
+			case SAMPLE_PEAK_METER:
-		case SAMPLE_PEAK_METER:
+				peak = GetSamplePeak(previousSamples, samples, sampleCount);
-			peak = GetSamplePeak(previousSamples, samples, sampleCount);
+				break;
-			break;
+			case TRUE_PEAK_METER:
-		case TRUE_PEAK_METER:
+				peak = GetTruePeak(previousSamples, samples, sampleCount);
-			peak = GetTruePeak(previousSamples, samples, sampleCount);
+				break;
-			break;
+		}
-		}
+
-
+		switch (sampleCount) {
-		switch (sampleCount) {
+			case 0:
-		case 0:
+				break;
-			break;
+			case 1:
-		case 1:
+				_previousSamples[channelNumber][0] = _previousSamples[channelNumber][1];
-			_previousSamples[channelNumber][0] = _previousSamples[channelNumber][1];
+				_previousSamples[channelNumber][1] = _previousSamples[channelNumber][2];
-			_previousSamples[channelNumber][1] = _previousSamples[channelNumber][2];
+				_previousSamples[channelNumber][2] = _previousSamples[channelNumber][3];
-			_previousSamples[channelNumber][2] = _previousSamples[channelNumber][3];
+				_previousSamples[channelNumber][3] = samples[sampleCount - 1];
-			_previousSamples[channelNumber][3] = samples[sampleCount - 1];
+				break;
-			break;
+			case 2:
-		case 2:
+				_previousSamples[channelNumber][0] = _previousSamples[channelNumber][2];
-			_previousSamples[channelNumber][0] = _previousSamples[channelNumber][2];
+				_previousSamples[channelNumber][1] = _previousSamples[channelNumber][3];
-			_previousSamples[channelNumber][1] = _previousSamples[channelNumber][3];
+				_previousSamples[channelNumber][2] = samples[sampleCount - 2];
-			_previousSamples[channelNumber][2] = samples[sampleCount - 2];
+				_previousSamples[channelNumber][3] = samples[sampleCount - 1];
-			_previousSamples[channelNumber][3] = samples[sampleCount - 1];
+				break;
-			break;
+			case 3:
-		case 3:
+				_previousSamples[channelNumber][0] = _previousSamples[channelNumber][3];
-			_previousSamples[channelNumber][0] = _previousSamples[channelNumber][3];
+				_previousSamples[channelNumber][1] = samples[sampleCount - 3];
-			_previousSamples[channelNumber][1] = samples[sampleCount - 3];
+				_previousSamples[channelNumber][2] = samples[sampleCount - 2];
-			_previousSamples[channelNumber][2] = samples[sampleCount - 2];
+				_previousSamples[channelNumber][3] = samples[sampleCount - 1];
-			_previousSamples[channelNumber][3] = samples[sampleCount - 1];
+				break;
-			break;
+			default:
-		default:
+				_previousSamples[channelNumber][0] = samples[sampleCount - 4];
-			_previousSamples[channelNumber][0] = samples[sampleCount - 4];
+				_previousSamples[channelNumber][1] = samples[sampleCount - 3];
-			_previousSamples[channelNumber][1] = samples[sampleCount - 3];
+				_previousSamples[channelNumber][2] = samples[sampleCount - 2];
-			_previousSamples[channelNumber][2] = samples[sampleCount - 2];
+				_previousSamples[channelNumber][3] = samples[sampleCount - 1];
-			_previousSamples[channelNumber][3] = samples[sampleCount - 1];
+		}
-		}
+
-
+		_peak[channelNumber] = peak;
-		_peak[channelNumber] = peak;
+
-
+		channelNumber++;
-		channelNumber++;
+	}
-	}
+
-
+	for (; channelNumber < MAX_AUDIO_CHANNELS; channelNumber++)
-	for (; channelNumber < MAX_AUDIO_CHANNELS; channelNumber++)
+		_peak[channelNumber] = 0.0;
-		_peak[channelNumber] = 0.0;
+}
-}
+
-
+// MUST HOLD LOCK
-// MUST HOLD LOCK
+void Utils::Obs::VolumeMeter::Meter::ProcessMagnitude(const struct audio_data *data)
-void Utils::Obs::VolumeMeter::Meter::ProcessMagnitude(const struct audio_data *data)
+{
-{
+	size_t sampleCount = data->frames;
-	size_t sampleCount = data->frames;
+
-
+	int channelNumber = 0;
-	int channelNumber = 0;
+	for (int planeNumber = 0; channelNumber < _channels; planeNumber++) {
-	for (int planeNumber = 0; channelNumber < _channels; planeNumber++) {
+		float *samples = (float*)data->data[planeNumber];
-		float *samples = (float *)data->data[planeNumber];
+		if (!samples)
-		if (!samples)
+			continue;
-			continue;
+
-
+		float sum = 0.0;
-		float sum = 0.0;
+		for (size_t i = 0; i < sampleCount; i++) {
-		for (size_t i = 0; i < sampleCount; i++) {
+			float sample = samples[i];
-			float sample = samples[i];
+			sum += sample * sample;
-			sum += sample * sample;
+		}
-		}
+
-
+		_magnitude[channelNumber] = std::sqrt(sum / sampleCount);
-		_magnitude[channelNumber] = std::sqrt(sum / sampleCount);
+
-
+		channelNumber++;
-		channelNumber++;
+	}
-	}
+}
-}
+
-
+void Utils::Obs::VolumeMeter::Meter::InputAudioCaptureCallback(void *priv_data, obs_source_t *, const struct audio_data *data, bool muted)
-void Utils::Obs::VolumeMeter::Meter::InputAudioCaptureCallback(void *priv_data, obs_source_t *, const struct audio_data *data,
+{
-							       bool muted)
+	auto c = static_cast<Meter*>(priv_data);
-{
+
-	auto c = static_cast<Meter *>(priv_data);
+	std::unique_lock<std::mutex> l(c->_mutex);
-
+
-	std::unique_lock<std::mutex> l(c->_mutex);
+	c->_muted = muted;
-
+	c->ProcessAudioChannels(data);
-	c->_muted = muted;
+	c->ProcessPeak(data);
-	c->ProcessAudioChannels(data);
+	c->ProcessMagnitude(data);
-	c->ProcessPeak(data);
+
-	c->ProcessMagnitude(data);
+	c->_lastUpdate = os_gettime_ns();
-
+}
-	c->_lastUpdate = os_gettime_ns();
+
-}
+void Utils::Obs::VolumeMeter::Meter::InputVolumeCallback(void *priv_data, calldata_t *cd)
-
+{
-void Utils::Obs::VolumeMeter::Meter::InputVolumeCallback(void *priv_data, calldata_t *cd)
+	auto c = static_cast<Meter*>(priv_data);
-{
+
-	auto c = static_cast<Meter *>(priv_data);
+	c->_volume = (float)calldata_float(cd, "volume");
-
+}
-	c->_volume = (float)calldata_float(cd, "volume");
+
-}
+Utils::Obs::VolumeMeter::Handler::Handler(UpdateCallback cb, uint64_t updatePeriod) :
-
+	_updateCallback(cb),
-Utils::Obs::VolumeMeter::Handler::Handler(UpdateCallback cb, uint64_t updatePeriod)
+	_updatePeriod(updatePeriod),
-	: _updateCallback(cb), _updatePeriod(updatePeriod), _running(false)
+	_running(false)
-{
+{
-	signal_handler_t *sh = obs_get_signal_handler();
+	signal_handler_t *sh = obs_get_signal_handler();
-	if (!sh)
+	if (!sh)
-		return;
+		return;
-
+
-	auto enumProc = [](void *priv_data, obs_source_t *input) {
+	auto enumProc = [](void *priv_data, obs_source_t *input) {
-		auto c = static_cast<Handler *>(priv_data);
+		auto c = static_cast<Handler*>(priv_data);
-
+
-		if (!obs_source_active(input))
+		if (!obs_source_active(input))
-			return true;
+			return true;
-
+
-		uint32_t flags = obs_source_get_output_flags(input);
+		uint32_t flags = obs_source_get_output_flags(input);
-		if ((flags & OBS_SOURCE_AUDIO) == 0)
+		if ((flags & OBS_SOURCE_AUDIO) == 0)
-			return true;
+			return true;
-
+
-		c->_meters.emplace_back(std::move(new Meter(input)));
+		c->_meters.emplace_back(std::move(new Meter(input)));
-
+
-		return true;
+		return true;
-	};
+	};
-	obs_enum_sources(enumProc, this);
+	obs_enum_sources(enumProc, this);
-
+
-	signal_handler_connect(sh, "source_activate", Handler::InputActivateCallback, this);
+	signal_handler_connect(sh, "source_activate", Handler::InputActivateCallback, this);
-	signal_handler_connect(sh, "source_deactivate", Handler::InputDeactivateCallback, this);
+	signal_handler_connect(sh, "source_deactivate", Handler::InputDeactivateCallback, this);
-
+
-	_running = true;
+	_running = true;
-	_updateThread = std::thread(&Handler::UpdateThread, this);
+	_updateThread = std::thread(&Handler::UpdateThread, this);
-
+
-	blog_debug("[Utils::Obs::VolumeMeter::Handler::Handler] Handler created.");
+	blog_debug("[Utils::Obs::VolumeMeter::Handler::Handler] Handler created.");
-}
+}
-
+
-Utils::Obs::VolumeMeter::Handler::~Handler()
+Utils::Obs::VolumeMeter::Handler::~Handler()
-{
+{
-	signal_handler_t *sh = obs_get_signal_handler();
+	signal_handler_t *sh = obs_get_signal_handler();
-	if (!sh)
+	if (!sh)
-		return;
+		return;
-
+
-	signal_handler_disconnect(sh, "source_activate", Handler::InputActivateCallback, this);
+	signal_handler_disconnect(sh, "source_activate", Handler::InputActivateCallback, this);
-	signal_handler_disconnect(sh, "source_deactivate", Handler::InputDeactivateCallback, this);
+	signal_handler_disconnect(sh, "source_deactivate", Handler::InputDeactivateCallback, this);
-
+
-	if (_running) {
+	if (_running) {
-		_running = false;
+		_running = false;
-		_cond.notify_all();
+		_cond.notify_all();
-	}
+	}
-
+
-	if (_updateThread.joinable())
+	if (_updateThread.joinable())
-		_updateThread.join();
+		_updateThread.join();
-
+
-	blog_debug("[Utils::Obs::VolumeMeter::Handler::~Handler] Handler destroyed.");
+	blog_debug("[Utils::Obs::VolumeMeter::Handler::~Handler] Handler destroyed.");
-}
+}
-
+
-void Utils::Obs::VolumeMeter::Handler::UpdateThread()
+void Utils::Obs::VolumeMeter::Handler::UpdateThread()
-{
+{
-	blog_debug("[Utils::Obs::VolumeMeter::Handler::UpdateThread] Thread started.");
+	blog_debug("[Utils::Obs::VolumeMeter::Handler::UpdateThread] Thread started.");
-	while (_running) {
+	while (_running) {
-		{
+		{
-			std::unique_lock<std::mutex> l(_mutex);
+			std::unique_lock<std::mutex> l(_mutex);
-			if (_cond.wait_for(l, std::chrono::milliseconds(_updatePeriod), [this] { return !_running; }))
+			if (_cond.wait_for(l, std::chrono::milliseconds(_updatePeriod), [this]{ return !_running; }))
-				break;
+				break;
-		}
+		}
-
+
-		std::vector<json> inputs;
+		std::vector<json> inputs;
-		std::unique_lock<std::mutex> l(_meterMutex);
+		std::unique_lock<std::mutex> l(_meterMutex);
-		for (auto &meter : _meters) {
+		for (auto &meter : _meters) {
-			if (meter->InputValid())
+			if (meter->InputValid())
-				inputs.push_back(meter->GetMeterData());
+				inputs.push_back(meter->GetMeterData());
-		}
+		}
-		l.unlock();
+		l.unlock();
-
+
-		if (_updateCallback)
+		if (_updateCallback)
-			_updateCallback(inputs);
+			_updateCallback(inputs);
-	}
+	}
-	blog_debug("[Utils::Obs::VolumeMeter::Handler::UpdateThread] Thread stopped.");
+	blog_debug("[Utils::Obs::VolumeMeter::Handler::UpdateThread] Thread stopped.");
-}
+}
-
+
-void Utils::Obs::VolumeMeter::Handler::InputActivateCallback(void *priv_data, calldata_t *cd)
+void Utils::Obs::VolumeMeter::Handler::InputActivateCallback(void *priv_data, calldata_t *cd)
-{
+{
-	auto c = static_cast<Handler *>(priv_data);
+	auto c = static_cast<Handler*>(priv_data);
-
+
-	obs_source_t *input = GetCalldataPointer<obs_source_t>(cd, "source");
+	obs_source_t *input = GetCalldataPointer<obs_source_t>(cd, "source");
-	if (!input)
+	if (!input)
-		return;
+		return;
-
+
-	if (obs_source_get_type(input) != OBS_SOURCE_TYPE_INPUT)
+	if (obs_source_get_type(input) != OBS_SOURCE_TYPE_INPUT)
-		return;
+		return;
-
+
-	uint32_t flags = obs_source_get_output_flags(input);
+	uint32_t flags = obs_source_get_output_flags(input);
-	if ((flags & OBS_SOURCE_AUDIO) == 0)
+	if ((flags & OBS_SOURCE_AUDIO) == 0)
-		return;
+		return;
-
+
-	std::unique_lock<std::mutex> l(c->_meterMutex);
+	std::unique_lock<std::mutex> l(c->_meterMutex);
-	c->_meters.emplace_back(std::move(new Meter(input)));
+	c->_meters.emplace_back(std::move(new Meter(input)));
-}
+}
-
+
-void Utils::Obs::VolumeMeter::Handler::InputDeactivateCallback(void *priv_data, calldata_t *cd)
+void Utils::Obs::VolumeMeter::Handler::InputDeactivateCallback(void *priv_data, calldata_t *cd)
-{
+{
-	auto c = static_cast<Handler *>(priv_data);
+	auto c = static_cast<Handler*>(priv_data);
-
+
-	obs_source_t *input = GetCalldataPointer<obs_source_t>(cd, "source");
+	obs_source_t *input = GetCalldataPointer<obs_source_t>(cd, "source");
-	if (!input)
+	if (!input)
-		return;
+		return;
-
+
-	if (obs_source_get_type(input) != OBS_SOURCE_TYPE_INPUT)
+	if (obs_source_get_type(input) != OBS_SOURCE_TYPE_INPUT)
-		return;
+		return;
-
+
-	// Don't ask me why, but using std::remove_if segfaults trying this.
+	// Don't ask me why, but using std::remove_if segfaults trying this.
-	std::unique_lock<std::mutex> l(c->_meterMutex);
+	std::unique_lock<std::mutex> l(c->_meterMutex);
-	std::vector<MeterPtr>::iterator iter;
+	std::vector<MeterPtr>::iterator iter;
-	for (iter = c->_meters.begin(); iter != c->_meters.end();) {
+	for (iter = c->_meters.begin(); iter != c->_meters.end();) {
-		if (obs_weak_source_references_source(iter->get()->GetWeakInput(), input))
+		if (obs_weak_source_references_source(iter->get()->GetWeakInput(), input))
-			iter = c->_meters.erase(iter);
+			iter = c->_meters.erase(iter);
-		else
+		else
-			++iter;
+			++iter;
-	}
+	}
-}
+}

src/utils/Obs_VolumeMeter.h

@@ -1,100 +1,99 @@
-/*
+/*
-obs-websocket
+obs-websocket
-Copyright (C) 2016-2021 Stephane Lepin <stephane.lepin@gmail.com>
+Copyright (C) 2016-2021 Stephane Lepin <stephane.lepin@gmail.com>
-Copyright (C) 2020-2021 Kyle Manning <tt2468@gmail.com>
+Copyright (C) 2020-2021 Kyle Manning <tt2468@gmail.com>
-
+
-This program is free software; you can redistribute it and/or modify
+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
+it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
+the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+(at your option) any later version.
-
+
-This program is distributed in the hope that it will be useful,
+This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
+but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+GNU General Public License for more details.
-
+
-You should have received a copy of the GNU General Public License along
+You should have received a copy of the GNU General Public License along
-with this program. If not, see <https://www.gnu.org/licenses/>
+with this program. If not, see <https://www.gnu.org/licenses/>
-*/
+*/
-
+
-#pragma once
+#pragma once
-
+
-#include <string>
+#include <string>
-#include <atomic>
+#include <atomic>
-#include <mutex>
+#include <mutex>
-#include <condition_variable>
+#include <condition_variable>
-#include <memory>
+#include <memory>
-#include <thread>
+#include <thread>
-#include <obs.hpp>
+#include <obs.hpp>
-
+
-#include "Obs.h"
+#include "Obs.h"
-#include "Json.h"
+#include "Json.h"
-
+
-namespace Utils {
+namespace Utils {
-	namespace Obs {
+	namespace Obs {
-		namespace VolumeMeter {
+		namespace VolumeMeter {
-			// Some code copied from https://github.com/obsproject/obs-studio/blob/master/libobs/obs-audio-controls.c
+			// Some code copied from https://github.com/obsproject/obs-studio/blob/master/libobs/obs-audio-controls.c
-			// Keeps a running tally of the current audio levels, for a specific input
+			// Keeps a running tally of the current audio levels, for a specific input
-			class Meter {
+			class Meter {
-			public:
+				public:
-				Meter(obs_source_t *input);
+					Meter(obs_source_t *input);
-				~Meter();
+					~Meter();
-
+
-				bool InputValid();
+					bool InputValid();
-				obs_weak_source_t *GetWeakInput() { return _input; }
+					obs_weak_source_t *GetWeakInput() { return _input; }
-				json GetMeterData();
+					json GetMeterData();
-
+
-				std::atomic<enum obs_peak_meter_type> PeakMeterType;
+					std::atomic<enum obs_peak_meter_type> PeakMeterType;
-
+
-			private:
+				private:
-				OBSWeakSourceAutoRelease _input;
+					OBSWeakSourceAutoRelease _input;
-
+
-				// All values in mul
+					// All values in mul
-				std::mutex _mutex;
+					std::mutex _mutex;
-				bool _muted;
+					bool _muted;
-				int _channels;
+					int _channels;
-				float _magnitude[MAX_AUDIO_CHANNELS];
+					float _magnitude[MAX_AUDIO_CHANNELS];
-				float _peak[MAX_AUDIO_CHANNELS];
+					float _peak[MAX_AUDIO_CHANNELS];
-				float _previousSamples[MAX_AUDIO_CHANNELS][4];
+					float _previousSamples[MAX_AUDIO_CHANNELS][4];
-
+
-				std::atomic<uint64_t> _lastUpdate;
+					std::atomic<uint64_t> _lastUpdate;
-				std::atomic<float> _volume;
+					std::atomic<float> _volume;
-
+
-				void ResetAudioLevels();
+					void ResetAudioLevels();
-				void ProcessAudioChannels(const struct audio_data *data);
+					void ProcessAudioChannels(const struct audio_data *data);
-				void ProcessPeak(const struct audio_data *data);
+					void ProcessPeak(const struct audio_data *data);
-				void ProcessMagnitude(const struct audio_data *data);
+					void ProcessMagnitude(const struct audio_data *data);
-
+
-				static void InputAudioCaptureCallback(void *priv_data, obs_source_t *source,
+					static void InputAudioCaptureCallback(void *priv_data, obs_source_t *source, const struct audio_data *data, bool muted);
-								      const struct audio_data *data, bool muted);
+					static void InputVolumeCallback(void *priv_data, calldata_t *cd);
-				static void InputVolumeCallback(void *priv_data, calldata_t *cd);
+			};
-			};
+
-
+			// Maintains an array of active inputs
-			// Maintains an array of active inputs
+			class Handler {
-			class Handler {
+				typedef std::function<void(std::vector<json>)> UpdateCallback;
-				typedef std::function<void(std::vector<json>)> UpdateCallback;
+				typedef std::unique_ptr<Meter> MeterPtr;
-				typedef std::unique_ptr<Meter> MeterPtr;
+
-
+				public:
-			public:
+					Handler(UpdateCallback cb, uint64_t updatePeriod = 50);
-				Handler(UpdateCallback cb, uint64_t updatePeriod = 50);
+					~Handler();
-				~Handler();
+
-
+				private:
-			private:
+					UpdateCallback _updateCallback;
-				UpdateCallback _updateCallback;
+
-
+					std::mutex _meterMutex;
-				std::mutex _meterMutex;
+					std::vector<MeterPtr> _meters;
-				std::vector<MeterPtr> _meters;
+					uint64_t _updatePeriod;
-				uint64_t _updatePeriod;
+
-
+					std::mutex _mutex;
-				std::mutex _mutex;
+					std::condition_variable _cond;
-				std::condition_variable _cond;
+					std::atomic<bool> _running;
-				std::atomic<bool> _running;
+					std::thread _updateThread;
-				std::thread _updateThread;
+
-
+					void UpdateThread();
-				void UpdateThread();
+					static void InputActivateCallback(void *priv_data, calldata_t *cd);
-				static void InputActivateCallback(void *priv_data, calldata_t *cd);
+					static void InputDeactivateCallback(void *priv_data, calldata_t *cd);
-				static void InputDeactivateCallback(void *priv_data, calldata_t *cd);
+			};
-			};
+		}
-		}
+	}
-	}
+}
-}

src/utils/Obs_VolumeMeter_Helpers.h

@@ -22,11 +22,12 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 
 // It should probably be imported as a libobs util someday though.
 
-#define SHIFT_RIGHT_2PS(msb, lsb)                                               \
+#define SHIFT_RIGHT_2PS(msb, lsb)                                          \
-	{                                                                       \
+	{                                                                  \
-		__m128 tmp = _mm_shuffle_ps(lsb, msb, _MM_SHUFFLE(0, 0, 3, 3)); \
+		__m128 tmp =                                               \
-		lsb = _mm_shuffle_ps(lsb, tmp, _MM_SHUFFLE(2, 1, 2, 1));        \
+			_mm_shuffle_ps(lsb, msb, _MM_SHUFFLE(0, 0, 3, 3)); \
-		msb = _mm_shuffle_ps(msb, msb, _MM_SHUFFLE(3, 3, 2, 1));        \
+		lsb = _mm_shuffle_ps(lsb, tmp, _MM_SHUFFLE(2, 1, 2, 1));   \
+		msb = _mm_shuffle_ps(msb, msb, _MM_SHUFFLE(3, 3, 2, 1));   \
 	}
 
 #define abs_ps(v) _mm_andnot_ps(_mm_set1_ps(-0.f), v)
@@ -55,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) {
@@ -68,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);

src/utils/Platform.cpp

@@ -53,12 +53,8 @@ std::string Utils::Platform::GetLocalAddress()
 	std::vector<std::pair<QString, uint8_t>> preferredAddresses;
 	for (auto address : validAddresses) {
 		// Attribute a priority (0 is best) to the address to choose the best picks
-		if (address.startsWith("192.168.1.") ||
+		if (address.startsWith("192.168.1.") || address.startsWith("192.168.0.")) { // Prefer common consumer router network prefixes
-		    address.startsWith("192.168.0.")) { // Prefer common consumer router network prefixes
+			preferredAddresses.push_back(std::make_pair(address, 0));
-			if (address.startsWith("192.168.56."))
-				preferredAddresses.push_back(std::make_pair(address, 255)); // Ignore virtualbox default
-			else
-				preferredAddresses.push_back(std::make_pair(address, 0));
 		} else if (address.startsWith("172.16.")) { // Slightly less common consumer router network prefixes
 			preferredAddresses.push_back(std::make_pair(address, 1));
 		} else if (address.startsWith("10.")) { // Even less common consumer router network prefixes
@@ -69,8 +65,9 @@ std::string Utils::Platform::GetLocalAddress()
 	}
 
 	// Sort by priority
-	std::sort(preferredAddresses.begin(), preferredAddresses.end(),
+	std::sort(preferredAddresses.begin(), preferredAddresses.end(), [=](std::pair<QString, uint8_t> a, std::pair<QString, uint8_t> b) {
-		  [=](std::pair<QString, uint8_t> a, std::pair<QString, uint8_t> b) { return a.second < b.second; });
+		return a.second < b.second;
+	});
 
 	// Return highest priority address
 	return preferredAddresses[0].first.toStdString();
@@ -112,17 +109,14 @@ void Utils::Platform::SendTrayNotification(QSystemTrayIcon::MessageIcon icon, QS
 
 	SystemTrayNotification *notification = new SystemTrayNotification{icon, title, body};
 
-	obs_queue_task(
+	obs_queue_task(OBS_TASK_UI, [](void* param) {
-		OBS_TASK_UI,
+		void *systemTrayPtr = obs_frontend_get_system_tray();
-		[](void *param) {
+		auto systemTray = reinterpret_cast<QSystemTrayIcon*>(systemTrayPtr);
-			void *systemTrayPtr = obs_frontend_get_system_tray();
-			auto systemTray = static_cast<QSystemTrayIcon *>(systemTrayPtr);
 
-			auto notification = static_cast<SystemTrayNotification *>(param);
+		auto notification = reinterpret_cast<SystemTrayNotification*>(param);
-			systemTray->showMessage(notification->title, notification->body, notification->icon);
+		systemTray->showMessage(notification->title, notification->body, notification->icon);
-			delete notification;
+		delete notification;
-		},
+	}, (void*)notification, false);
-		(void *)notification, false);
 }
 
 bool Utils::Platform::GetTextFileContent(std::string fileName, std::string &content)

src/websocketserver/WebSocketServer.cpp

@@ -31,7 +31,9 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #include "../utils/Platform.h"
 #include "../utils/Compat.h"
 
-WebSocketServer::WebSocketServer() : QObject(nullptr), _sessions()
+WebSocketServer::WebSocketServer() :
+	QObject(nullptr),
+	_sessions()
 {
 	_server.get_alog().clear_channels(websocketpp::log::alevel::all);
 	_server.get_elog().clear_channels(websocketpp::log::elevel::all);
@@ -42,17 +44,38 @@ WebSocketServer::WebSocketServer() : QObject(nullptr), _sessions()
 #endif
 
 	_server.set_validate_handler(
-		websocketpp::lib::bind(&WebSocketServer::onValidate, this, websocketpp::lib::placeholders::_1));
+		websocketpp::lib::bind(
-	_server.set_open_handler(websocketpp::lib::bind(&WebSocketServer::onOpen, this, websocketpp::lib::placeholders::_1));
+			&WebSocketServer::onValidate, this, websocketpp::lib::placeholders::_1
-	_server.set_close_handler(websocketpp::lib::bind(&WebSocketServer::onClose, this, websocketpp::lib::placeholders::_1));
+		)
-	_server.set_message_handler(websocketpp::lib::bind(&WebSocketServer::onMessage, this, websocketpp::lib::placeholders::_1,
+	);
-							   websocketpp::lib::placeholders::_2));
+	_server.set_open_handler(
+		websocketpp::lib::bind(
+			&WebSocketServer::onOpen, this, websocketpp::lib::placeholders::_1
+		)
+	);
+	_server.set_close_handler(
+		websocketpp::lib::bind(
+			&WebSocketServer::onClose, this, websocketpp::lib::placeholders::_1
+		)
+	);
+	_server.set_message_handler(
+		websocketpp::lib::bind(
+			&WebSocketServer::onMessage, this, websocketpp::lib::placeholders::_1, websocketpp::lib::placeholders::_2
+		)
+	);
 
 	auto eventHandler = GetEventHandler();
-	eventHandler->SetBroadcastCallback(std::bind(&WebSocketServer::BroadcastEvent, this, std::placeholders::_1,
+	eventHandler->SetBroadcastCallback(
-						     std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
+		std::bind(
+			&WebSocketServer::BroadcastEvent, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4
+		)
+	);
 
-	eventHandler->SetObsLoadedCallback(std::bind(&WebSocketServer::onObsLoaded, this));
+	eventHandler->SetObsLoadedCallback(
+		std::bind(
+			&WebSocketServer::onObsLoaded, this
+		)
+	);
 }
 
 WebSocketServer::~WebSocketServer()
@@ -66,9 +89,9 @@ void WebSocketServer::ServerRunner()
 	blog(LOG_INFO, "[WebSocketServer::ServerRunner] IO thread started.");
 	try {
 		_server.run();
-	} catch (websocketpp::exception const &e) {
+	} catch (websocketpp::exception const & e) {
 		blog(LOG_ERROR, "[WebSocketServer::ServerRunner] websocketpp instance returned an error: %s", e.what());
-	} catch (const std::exception &e) {
+	} catch (const std::exception & e) {
 		blog(LOG_ERROR, "[WebSocketServer::ServerRunner] websocketpp instance returned an error: %s", e.what());
 	} catch (...) {
 		blog(LOG_ERROR, "[WebSocketServer::ServerRunner] websocketpp instance returned an error");
@@ -95,8 +118,7 @@ void WebSocketServer::Start()
 	// Set log levels if debug is enabled
 	if (IsDebugEnabled()) {
 		_server.get_alog().set_channels(websocketpp::log::alevel::all);
-		_server.get_alog().clear_channels(websocketpp::log::alevel::frame_header | websocketpp::log::alevel::frame_payload |
+		_server.get_alog().clear_channels(websocketpp::log::alevel::frame_header | websocketpp::log::alevel::frame_payload | websocketpp::log::alevel::control);
-						  websocketpp::log::alevel::control);
 		_server.get_elog().set_channels(websocketpp::log::elevel::all);
 		_server.get_alog().clear_channels(websocketpp::log::elevel::devel | websocketpp::log::elevel::library);
 	} else {
@@ -107,13 +129,7 @@ void WebSocketServer::Start()
 	_server.reset();
 
 	websocketpp::lib::error_code errorCode;
-	if (conf->Ipv4Only) {
+	_server.listen(websocketpp::lib::asio::ip::tcp::v4(), conf->ServerPort, errorCode);
-		blog(LOG_INFO, "[WebSocketServer::Start] Locked to IPv4 bindings");
-		_server.listen(websocketpp::lib::asio::ip::tcp::v4(), conf->ServerPort, errorCode);
-	} else {
-		blog(LOG_INFO, "[WebSocketServer::Start] Not locked to IPv4 bindings");
-		_server.listen(conf->ServerPort, errorCode);
-	}
 
 	if (errorCode) {
 		std::string errorCodeMessage = errorCode.message();
@@ -125,8 +141,7 @@ void WebSocketServer::Start()
 
 	_serverThread = std::thread(&WebSocketServer::ServerRunner, this);
 
-	blog(LOG_INFO, "[WebSocketServer::Start] Server started successfully on port %d. Possible connect address: %s",
+	blog(LOG_INFO, "[WebSocketServer::Start] Server started successfully on port %d. Possible connect address: %s", conf->ServerPort.load(), Utils::Platform::GetLocalAddress().c_str());
-	     conf->ServerPort.load(), Utils::Platform::GetLocalAddress().c_str());
 }
 
 void WebSocketServer::Stop()
@@ -139,7 +154,7 @@ void WebSocketServer::Stop()
 	_server.stop_listening();
 
 	std::unique_lock<std::mutex> lock(_sessionMutex);
-	for (auto const &[hdl, session] : _sessions) {
+	for (auto const& [hdl, session] : _sessions) {
 		websocketpp::lib::error_code errorCode;
 		_server.pause_reading(hdl, errorCode);
 		if (errorCode) {
@@ -190,15 +205,14 @@ std::vector<WebSocketServer::WebSocketSessionState> WebSocketServer::GetWebSocke
 	std::vector<WebSocketServer::WebSocketSessionState> webSocketSessions;
 
 	std::unique_lock<std::mutex> lock(_sessionMutex);
-	for (auto &[hdl, session] : _sessions) {
+	for (auto & [hdl, session] : _sessions) {
 		uint64_t connectedAt = session->ConnectedAt();
 		uint64_t incomingMessages = session->IncomingMessages();
 		uint64_t outgoingMessages = session->OutgoingMessages();
 		std::string remoteAddress = session->RemoteAddress();
 		bool isIdentified = session->IsIdentified();
-
+		
-		webSocketSessions.emplace_back(
+		webSocketSessions.emplace_back(WebSocketSessionState{hdl, remoteAddress, connectedAt, incomingMessages, outgoingMessages, isIdentified});
-			WebSocketSessionState{hdl, remoteAddress, connectedAt, incomingMessages, outgoingMessages, isIdentified});
 	}
 	lock.unlock();
 
@@ -344,8 +358,7 @@ void WebSocketServer::onClose(websocketpp::connection_hdl hdl)
 	emit ClientDisconnected(state, conn->get_local_close_code());
 
 	// Log disconnection
-	blog(LOG_INFO, "[WebSocketServer::onClose] WebSocket client `%s` has disconnected with code `%d` and reason: %s",
+	blog(LOG_INFO, "[WebSocketServer::onClose] WebSocket client %s has disconnected", remoteAddress.c_str());
-	     remoteAddress.c_str(), conn->get_local_close_code(), conn->get_local_close_reason().c_str());
 
 	// Get config for tray notification
 	auto conf = GetConfig();
@@ -357,14 +370,12 @@ void WebSocketServer::onClose(websocketpp::connection_hdl hdl)
 	// If previously identified, not going away, and notifications enabled, send a tray notification
 	if (isIdentified && (conn->get_local_close_code() != websocketpp::close::status::going_away) && conf->AlertsEnabled) {
 		QString title = obs_module_text("OBSWebSocket.TrayNotification.Disconnected.Title");
-		QString body = QString(obs_module_text("OBSWebSocket.TrayNotification.Disconnected.Body"))
+		QString body = QString(obs_module_text("OBSWebSocket.TrayNotification.Disconnected.Body")).arg(QString::fromStdString(remoteAddress));
-				       .arg(QString::fromStdString(remoteAddress));
 		Utils::Platform::SendTrayNotification(QSystemTrayIcon::Information, title, body);
 	}
 }
 
-void WebSocketServer::onMessage(websocketpp::connection_hdl hdl,
+void WebSocketServer::onMessage(websocketpp::connection_hdl hdl, websocketpp::server<websocketpp::config::asio>::message_ptr message)
-				websocketpp::server<websocketpp::config::asio>::message_ptr message)
 {
 	auto opCode = message->get_opcode();
 	std::string payload = message->get_payload();
@@ -373,7 +384,7 @@ void WebSocketServer::onMessage(websocketpp::connection_hdl hdl,
 		SessionPtr session;
 		try {
 			session = _sessions.at(hdl);
-		} catch (const std::out_of_range &oor) {
+		} catch (const std::out_of_range& oor) {
 			return;
 		}
 		lock.unlock();
@@ -387,32 +398,26 @@ void WebSocketServer::onMessage(websocketpp::connection_hdl hdl,
 		uint8_t sessionEncoding = session->Encoding();
 		if (sessionEncoding == WebSocketEncoding::Json) {
 			if (opCode != websocketpp::frame::opcode::text) {
-				_server.close(hdl, WebSocketCloseCode::MessageDecodeError,
+				_server.close(hdl, WebSocketCloseCode::MessageDecodeError, "Your session encoding is set to Json, but a binary message was received.", errorCode);
-					      "Your session encoding is set to Json, but a binary message was received.",
-					      errorCode);
 				return;
 			}
 
 			try {
 				incomingMessage = json::parse(payload);
-			} catch (json::parse_error &e) {
+			} catch (json::parse_error& e) {
-				_server.close(hdl, WebSocketCloseCode::MessageDecodeError,
+				_server.close(hdl, WebSocketCloseCode::MessageDecodeError, std::string("Unable to decode Json: ") + e.what(), errorCode);
-					      std::string("Unable to decode Json: ") + e.what(), errorCode);
 				return;
 			}
 		} else if (sessionEncoding == WebSocketEncoding::MsgPack) {
 			if (opCode != websocketpp::frame::opcode::binary) {
-				_server.close(hdl, WebSocketCloseCode::MessageDecodeError,
+				_server.close(hdl, WebSocketCloseCode::MessageDecodeError, "Your session encoding is set to MsgPack, but a text message was received.", errorCode);
-					      "Your session encoding is set to MsgPack, but a text message was received.",
-					      errorCode);
 				return;
 			}
 
 			try {
 				incomingMessage = json::from_msgpack(payload);
-			} catch (json::parse_error &e) {
+			} catch (json::parse_error& e) {
-				_server.close(hdl, WebSocketCloseCode::MessageDecodeError,
+				_server.close(hdl, WebSocketCloseCode::MessageDecodeError, std::string("Unable to decode MsgPack: ") + e.what(), errorCode);
-					      std::string("Unable to decode MsgPack: ") + e.what(), errorCode);
 				return;
 			}
 		}
@@ -430,11 +435,9 @@ void WebSocketServer::onMessage(websocketpp::connection_hdl hdl,
 
 		// Disconnect client if 4.x protocol is detected
 		if (!session->IsIdentified() && incomingMessage.contains("request-type")) {
-			blog(LOG_WARNING, "[WebSocketServer::onMessage] Client %s appears to be running a pre-5.0.0 protocol.",
+			blog(LOG_WARNING, "[WebSocketServer::onMessage] Client %s appears to be running a pre-5.0.0 protocol.", session->RemoteAddress().c_str());
-			     session->RemoteAddress().c_str());
 			ret.closeCode = WebSocketCloseCode::UnsupportedRpcVersion;
-			ret.closeReason =
+			ret.closeReason = "You appear to be attempting to connect with the pre-5.0.0 plugin protocol. Check to make sure your client is updated.";
-				"You appear to be attempting to connect with the pre-5.0.0 plugin protocol. Check to make sure your client is updated.";
 			goto skipProcessing;
 		}
 
@@ -445,15 +448,9 @@ void WebSocketServer::onMessage(websocketpp::connection_hdl hdl,
 			goto skipProcessing;
 		}
 
-		if (!incomingMessage["op"].is_number()) {
-			ret.closeCode = WebSocketCloseCode::UnknownOpCode;
-			ret.closeReason = "Your `op` is not a number.";
-			goto skipProcessing;
-		}
-
 		ProcessMessage(session, ret, incomingMessage["op"], incomingMessage["d"]);
 
-	skipProcessing:
+skipProcessing:
 		if (ret.closeCode != WebSocketCloseCode::DontClose) {
 			websocketpp::lib::error_code errorCode;
 			_server.close(hdl, ret.closeCode, ret.closeReason, errorCode);
@@ -475,8 +472,7 @@ void WebSocketServer::onMessage(websocketpp::connection_hdl hdl,
 			blog_debug("[WebSocketServer::onMessage] Outgoing message:\n%s", ret.result.dump(2).c_str());
 
 			if (errorCode)
-				blog(LOG_WARNING, "[WebSocketServer::onMessage] Sending message to client failed: %s",
+				blog(LOG_WARNING, "[WebSocketServer::onMessage] Sending message to client failed: %s", errorCode.message().c_str());
-				     errorCode.message().c_str());
 		}
 	}));
 }

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>
 
@@ -34,66 +33,73 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #include "../requesthandler/rpc/Request.h"
 #include "../plugin-macros.generated.h"
 
-class WebSocketServer : QObject {
+class WebSocketServer : QObject
+{
 	Q_OBJECT
 
-public:
+	public:
-	enum WebSocketEncoding { Json, MsgPack };
+		enum WebSocketEncoding {
+			Json,
+			MsgPack
+		};
 
-	struct WebSocketSessionState {
+		struct WebSocketSessionState {
-		websocketpp::connection_hdl hdl;
+			websocketpp::connection_hdl hdl;
-		std::string remoteAddress;
+			std::string remoteAddress;
-		uint64_t connectedAt;
+			uint64_t connectedAt;
-		uint64_t incomingMessages;
+			uint64_t incomingMessages;
-		uint64_t outgoingMessages;
+			uint64_t outgoingMessages;
-		bool isIdentified;
+			bool isIdentified;
-	};
+		};
 
-	WebSocketServer();
+		WebSocketServer();
-	~WebSocketServer();
+		~WebSocketServer();
 
-	void Start();
+		void Start();
-	void Stop();
+		void Stop();
-	void InvalidateSession(websocketpp::connection_hdl hdl);
+		void InvalidateSession(websocketpp::connection_hdl hdl);
-	void BroadcastEvent(uint64_t requiredIntent, const std::string &eventType, const json &eventData = nullptr,
+		void BroadcastEvent(uint64_t requiredIntent, const std::string &eventType, const json &eventData = nullptr, uint8_t rpcVersion = 0);
-			    uint8_t rpcVersion = 0);
 
-	bool IsListening() { return _server.is_listening(); }
+		bool IsListening() {
+			return _server.is_listening();
+		}
 
-	std::vector<WebSocketSessionState> GetWebSocketSessions();
+		std::vector<WebSocketSessionState> GetWebSocketSessions();
 
-	QThreadPool *GetThreadPool() { return &_threadPool; }
+		QThreadPool *GetThreadPool() {
+			return &_threadPool;
+		}
 
-signals:
+	signals:
-	void ClientConnected(WebSocketSessionState state);
+		void ClientConnected(WebSocketSessionState state);
-	void ClientDisconnected(WebSocketSessionState state, uint16_t closeCode);
+		void ClientDisconnected(WebSocketSessionState state, uint16_t closeCode);
 
-private:
+	private:
-	struct ProcessResult {
+		struct ProcessResult {
-		WebSocketCloseCode::WebSocketCloseCode closeCode = WebSocketCloseCode::DontClose;
+			WebSocketCloseCode::WebSocketCloseCode closeCode = WebSocketCloseCode::DontClose;
-		std::string closeReason;
+			std::string closeReason;
-		json result;
+			json result;
-	};
+		};
 
-	void ServerRunner();
+		void ServerRunner();
 
-	void onObsLoaded();
+		void onObsLoaded();
-	bool onValidate(websocketpp::connection_hdl hdl);
+		bool onValidate(websocketpp::connection_hdl hdl);
-	void onOpen(websocketpp::connection_hdl hdl);
+		void onOpen(websocketpp::connection_hdl hdl);
-	void onClose(websocketpp::connection_hdl hdl);
+		void onClose(websocketpp::connection_hdl hdl);
-	void onMessage(websocketpp::connection_hdl hdl, websocketpp::server<websocketpp::config::asio>::message_ptr message);
+		void onMessage(websocketpp::connection_hdl hdl, websocketpp::server<websocketpp::config::asio>::message_ptr message);
 
-	static void SetSessionParameters(SessionPtr session, WebSocketServer::ProcessResult &ret, const json &payloadData);
+		static void SetSessionParameters(SessionPtr session, WebSocketServer::ProcessResult &ret, const json &payloadData);
-	void ProcessMessage(SessionPtr session, ProcessResult &ret, WebSocketOpCode::WebSocketOpCode opCode, json &payloadData);
+		void ProcessMessage(SessionPtr session, ProcessResult &ret, WebSocketOpCode::WebSocketOpCode opCode, json &payloadData);
 
-	QThreadPool _threadPool;
+		QThreadPool _threadPool;
 
-	std::thread _serverThread;
+		std::thread _serverThread;
-	websocketpp::server<websocketpp::config::asio> _server;
+		websocketpp::server<websocketpp::config::asio> _server;
 
-	std::string _authenticationSecret;
+		std::string _authenticationSecret;
-	std::string _authenticationSalt;
+		std::string _authenticationSalt;
 
-	std::mutex _sessionMutex;
+		std::mutex _sessionMutex;
-	std::map<websocketpp::connection_hdl, SessionPtr, std::owner_less<websocketpp::connection_hdl>> _sessions;
+		std::map<websocketpp::connection_hdl, SessionPtr, std::owner_less<websocketpp::connection_hdl>> _sessions;
 };

src/websocketserver/WebSocketServer_Protocol.cpp

@@ -44,7 +44,10 @@ static json ConstructRequestResult(RequestResult requestResult, const json &requ
 	if (requestJson.contains("requestId") && !requestJson["requestId"].is_null())
 		ret["requestId"] = requestJson["requestId"];
 
-	ret["requestStatus"] = {{"result", requestResult.StatusCode == RequestStatus::Success}, {"code", requestResult.StatusCode}};
+	ret["requestStatus"] = {
+		{"result", requestResult.StatusCode == RequestStatus::Success},
+		{"code", requestResult.StatusCode}
+	};
 
 	if (!requestResult.Comment.empty())
 		ret["requestStatus"]["comment"] = requestResult.Comment;
@@ -67,8 +70,7 @@ void WebSocketServer::SetSessionParameters(SessionPtr session, ProcessResult &re
 	}
 }
 
-void WebSocketServer::ProcessMessage(SessionPtr session, WebSocketServer::ProcessResult &ret,
+void WebSocketServer::ProcessMessage(SessionPtr session, WebSocketServer::ProcessResult &ret, WebSocketOpCode::WebSocketOpCode opCode, json &payloadData)
-				     WebSocketOpCode::WebSocketOpCode opCode, json &payloadData)
 {
 	if (!payloadData.is_object()) {
 		if (payloadData.is_null()) {
@@ -89,253 +91,218 @@ void WebSocketServer::ProcessMessage(SessionPtr session, WebSocketServer::Proces
 	}
 
 	switch (opCode) {
-	case WebSocketOpCode::Identify: { // Identify
+		case WebSocketOpCode::Identify: { // Identify
-		std::unique_lock<std::mutex> sessionLock(session->OperationMutex);
+			std::unique_lock<std::mutex> sessionLock(session->OperationMutex);
-		if (session->IsIdentified()) {
+			if (session->IsIdentified()) {
-			ret.closeCode = WebSocketCloseCode::AlreadyIdentified;
+				ret.closeCode = WebSocketCloseCode::AlreadyIdentified;
-			ret.closeReason = "You are already Identified with the obs-websocket server.";
+				ret.closeReason = "You are already Identified with the obs-websocket server.";
-			return;
-		}
-
-		if (session->AuthenticationRequired()) {
-			if (!payloadData.contains("authentication")) {
-				ret.closeCode = WebSocketCloseCode::AuthenticationFailed;
-				ret.closeReason =
-					"Your payload's data is missing an `authentication` string, however authentication is required.";
 				return;
 			}
-			if (!Utils::Crypto::CheckAuthenticationString(session->Secret(), session->Challenge(),
+
-								      payloadData["authentication"])) {
+			if (session->AuthenticationRequired()) {
-				auto conf = GetConfig();
+				if (!payloadData.contains("authentication")) {
-				if (conf && conf->AlertsEnabled) {
+					ret.closeCode = WebSocketCloseCode::AuthenticationFailed;
-					QString title = obs_module_text("OBSWebSocket.TrayNotification.AuthenticationFailed.Title");
+					ret.closeReason = "Your payload's data is missing an `authentication` string, however authentication is required.";
-					QString body =
+					return;
-						QString(obs_module_text("OBSWebSocket.TrayNotification.AuthenticationFailed.Body"))
-							.arg(QString::fromStdString(session->RemoteAddress()));
-					Utils::Platform::SendTrayNotification(QSystemTrayIcon::Warning, title, body);
 				}
-				ret.closeCode = WebSocketCloseCode::AuthenticationFailed;
+				if (!Utils::Crypto::CheckAuthenticationString(session->Secret(), session->Challenge(), payloadData["authentication"])) {
-				ret.closeReason = "Authentication failed.";
+					auto conf = GetConfig();
+					if (conf && conf->AlertsEnabled) {
+						QString title = obs_module_text("OBSWebSocket.TrayNotification.AuthenticationFailed.Title");
+						QString body = QString(obs_module_text("OBSWebSocket.TrayNotification.AuthenticationFailed.Body")).arg(QString::fromStdString(session->RemoteAddress()));
+						Utils::Platform::SendTrayNotification(QSystemTrayIcon::Warning, title, body);
+					}
+					ret.closeCode = WebSocketCloseCode::AuthenticationFailed;
+					ret.closeReason = "Authentication failed.";
+					return;
+				}
+			}
+
+			if (!payloadData.contains("rpcVersion")) {
+				ret.closeCode = WebSocketCloseCode::MissingDataField;
+				ret.closeReason = "Your payload's data is missing an `rpcVersion`.";
 				return;
 			}
-		}
 
-		if (!payloadData.contains("rpcVersion")) {
+			if (!payloadData["rpcVersion"].is_number_unsigned()) {
-			ret.closeCode = WebSocketCloseCode::MissingDataField;
-			ret.closeReason = "Your payload's data is missing an `rpcVersion`.";
-			return;
-		}
-
-		if (!payloadData["rpcVersion"].is_number_unsigned()) {
-			ret.closeCode = WebSocketCloseCode::InvalidDataFieldType;
-			ret.closeReason = "Your `rpcVersion` is not an unsigned number.";
-			return;
-		}
-
-		uint8_t requestedRpcVersion = payloadData["rpcVersion"];
-		if (!IsSupportedRpcVersion(requestedRpcVersion)) {
-			ret.closeCode = WebSocketCloseCode::UnsupportedRpcVersion;
-			ret.closeReason = "Your requested RPC version is not supported by this server.";
-			return;
-		}
-		session->SetRpcVersion(requestedRpcVersion);
-
-		SetSessionParameters(session, ret, payloadData);
-		if (ret.closeCode != WebSocketCloseCode::DontClose) {
-			return;
-		}
-
-		// Increment refs for event subscriptions
-		auto eventHandler = GetEventHandler();
-		eventHandler->ProcessSubscription(session->EventSubscriptions());
-
-		// Mark session as identified
-		session->SetIsIdentified(true);
-
-		// Send desktop notification. TODO: Move to UI code
-		auto conf = GetConfig();
-		if (conf && conf->AlertsEnabled) {
-			QString title = obs_module_text("OBSWebSocket.TrayNotification.Identified.Title");
-			QString body = QString(obs_module_text("OBSWebSocket.TrayNotification.Identified.Body"))
-					       .arg(QString::fromStdString(session->RemoteAddress()));
-			Utils::Platform::SendTrayNotification(QSystemTrayIcon::Information, title, body);
-		}
-
-		ret.result["op"] = WebSocketOpCode::Identified;
-		ret.result["d"]["negotiatedRpcVersion"] = session->RpcVersion();
-	}
-		return;
-	case WebSocketOpCode::Reidentify: { // Reidentify
-		std::unique_lock<std::mutex> sessionLock(session->OperationMutex);
-
-		// Decrement refs for current subscriptions
-		auto eventHandler = GetEventHandler();
-		eventHandler->ProcessUnsubscription(session->EventSubscriptions());
-
-		SetSessionParameters(session, ret, payloadData);
-		if (ret.closeCode != WebSocketCloseCode::DontClose) {
-			return;
-		}
-
-		// Increment refs for new subscriptions
-		eventHandler->ProcessSubscription(session->EventSubscriptions());
-
-		ret.result["op"] = WebSocketOpCode::Identified;
-		ret.result["d"]["negotiatedRpcVersion"] = session->RpcVersion();
-	}
-		return;
-	case WebSocketOpCode::Request: { // Request
-		// RequestID checking has to be done here where we are able to close the connection.
-		if (!payloadData.contains("requestId")) {
-			ret.closeCode = WebSocketCloseCode::MissingDataField;
-			ret.closeReason = "Your payload data is missing a `requestId`.";
-			return;
-		}
-
-		if (!payloadData.contains("requestType")) {
-			ret.closeCode = WebSocketCloseCode::MissingDataField;
-			ret.closeReason = "Your payload's data is missing an `requestType`.";
-			return;
-		}
-
-		if (!payloadData["requestType"].is_string()) {
-			ret.closeCode = WebSocketCloseCode::InvalidDataFieldType;
-			ret.closeReason = "Your `requestType` is not a string.";
-			return;
-		}
-
-		RequestHandler requestHandler(session);
-
-		std::string requestType = payloadData["requestType"];
-		json requestData = payloadData["requestData"];
-		Request request(requestType, requestData);
-
-		RequestResult requestResult = requestHandler.ProcessRequest(request);
-
-		json resultPayloadData;
-		resultPayloadData["requestType"] = requestType;
-		resultPayloadData["requestId"] = payloadData["requestId"];
-		resultPayloadData["requestStatus"] = {{"result", requestResult.StatusCode == RequestStatus::Success},
-						      {"code", requestResult.StatusCode}};
-		if (!requestResult.Comment.empty())
-			resultPayloadData["requestStatus"]["comment"] = requestResult.Comment;
-		if (requestResult.ResponseData.is_object())
-			resultPayloadData["responseData"] = requestResult.ResponseData;
-		ret.result["op"] = WebSocketOpCode::RequestResponse;
-		ret.result["d"] = resultPayloadData;
-	}
-		return;
-	case WebSocketOpCode::RequestBatch: { // RequestBatch
-		// RequestID checking has to be done here where we are able to close the connection.
-		if (!payloadData.contains("requestId")) {
-			ret.closeCode = WebSocketCloseCode::MissingDataField;
-			ret.closeReason = "Your payload data is missing a `requestId`.";
-			return;
-		}
-
-		RequestBatchExecutionType::RequestBatchExecutionType executionType = RequestBatchExecutionType::SerialRealtime;
-		if (payloadData.contains("executionType") && !payloadData["executionType"].is_null()) {
-			if (!payloadData["executionType"].is_number_unsigned()) {
 				ret.closeCode = WebSocketCloseCode::InvalidDataFieldType;
-				ret.closeReason = "Your `executionType` is not a number.";
+				ret.closeReason = "Your `rpcVersion` is not an unsigned number.";
+			}
+
+			uint8_t requestedRpcVersion = payloadData["rpcVersion"];
+			if (!IsSupportedRpcVersion(requestedRpcVersion)) {
+				ret.closeCode = WebSocketCloseCode::UnsupportedRpcVersion;
+				ret.closeReason = "Your requested RPC version is not supported by this server.";
+				return;
+			}
+			session->SetRpcVersion(requestedRpcVersion);
+
+			SetSessionParameters(session, ret, payloadData);
+			if (ret.closeCode != WebSocketCloseCode::DontClose) {
 				return;
 			}
 
-			int8_t requestedExecutionType = payloadData["executionType"];
+			// Increment refs for event subscriptions
-			if (!RequestBatchExecutionType::IsValid(requestedExecutionType) ||
+			auto eventHandler = GetEventHandler();
-			    requestedExecutionType == RequestBatchExecutionType::None) {
+			eventHandler->ProcessSubscription(session->EventSubscriptions());
-				ret.closeCode = WebSocketCloseCode::InvalidDataFieldValue;
+
-				ret.closeReason = "Your `executionType` has an invalid value.";
+			// Mark session as identified
+			session->SetIsIdentified(true);
+
+			// Send desktop notification. TODO: Move to UI code
+			auto conf = GetConfig();
+			if (conf && conf->AlertsEnabled) {
+				QString title = obs_module_text("OBSWebSocket.TrayNotification.Identified.Title");
+				QString body = QString(obs_module_text("OBSWebSocket.TrayNotification.Identified.Body")).arg(QString::fromStdString(session->RemoteAddress()));
+				Utils::Platform::SendTrayNotification(QSystemTrayIcon::Information, title, body);
+			}
+
+			ret.result["op"] = WebSocketOpCode::Identified;
+			ret.result["d"]["negotiatedRpcVersion"] = session->RpcVersion();
+			} return;
+		case WebSocketOpCode::Reidentify: { // Reidentify
+			std::unique_lock<std::mutex> sessionLock(session->OperationMutex);
+
+			// Decrement refs for current subscriptions
+			auto eventHandler = GetEventHandler();
+			eventHandler->ProcessUnsubscription(session->EventSubscriptions());
+
+			SetSessionParameters(session, ret, payloadData);
+			if (ret.closeCode != WebSocketCloseCode::DontClose) {
 				return;
 			}
 
-			// The thread pool must support 2 or more threads else parallel requests will deadlock.
+			// Increment refs for new subscriptions
-			if (requestedExecutionType == RequestBatchExecutionType::Parallel && _threadPool.maxThreadCount() < 2) {
+			eventHandler->ProcessSubscription(session->EventSubscriptions());
-				ret.closeCode = WebSocketCloseCode::UnsupportedFeature;
+
-				ret.closeReason =
+			ret.result["op"] = WebSocketOpCode::Identified;
-					"Parallel request batch processing is not available on this system due to limited core count.";
+			ret.result["d"]["negotiatedRpcVersion"] = session->RpcVersion();
+			} return;
+		case WebSocketOpCode::Request: { // Request
+			// RequestID checking has to be done here where we are able to close the connection.
+			if (!payloadData.contains("requestId")) {
+				ret.closeCode = WebSocketCloseCode::MissingDataField;
+				ret.closeReason = "Your payload data is missing a `requestId`.";
 				return;
 			}
 
-			executionType = (RequestBatchExecutionType::RequestBatchExecutionType)requestedExecutionType;
+			RequestHandler requestHandler(session);
-		}
+			Request request(payloadData["requestType"], payloadData["requestData"]);
 
-		if (payloadData.contains("variables") && !payloadData["variables"].is_null()) {
+			RequestResult requestResult = requestHandler.ProcessRequest(request);
-			if (!payloadData.is_object()) {
+
+			json resultPayloadData;
+			resultPayloadData["requestType"] = payloadData["requestType"];
+			resultPayloadData["requestId"] = payloadData["requestId"];
+			resultPayloadData["requestStatus"] = {
+				{"result", requestResult.StatusCode == RequestStatus::Success},
+				{"code", requestResult.StatusCode}
+			};
+			if (!requestResult.Comment.empty())
+				resultPayloadData["requestStatus"]["comment"] = requestResult.Comment;
+			if (requestResult.ResponseData.is_object())
+				resultPayloadData["responseData"] = requestResult.ResponseData;
+			ret.result["op"] = WebSocketOpCode::RequestResponse;
+			ret.result["d"] = resultPayloadData;
+			} return;
+		case WebSocketOpCode::RequestBatch: { // RequestBatch
+			// RequestID checking has to be done here where we are able to close the connection.
+			if (!payloadData.contains("requestId")) {
+				ret.closeCode = WebSocketCloseCode::MissingDataField;
+				ret.closeReason = "Your payload data is missing a `requestId`.";
+				return;
+			}
+
+			if (!payloadData.contains("requests")) {
+				ret.closeCode = WebSocketCloseCode::MissingDataField;
+				ret.closeReason = "Your payload data is missing a `requests`.";
+				return;
+			}
+
+			if (!payloadData["requests"].is_array()) {
 				ret.closeCode = WebSocketCloseCode::InvalidDataFieldType;
-				ret.closeReason = "Your `variables` is not an object.";
+				ret.closeReason = "Your `requests` is not an array.";
 				return;
 			}
 
-			if (executionType == RequestBatchExecutionType::Parallel) {
+			RequestBatchExecutionType::RequestBatchExecutionType executionType = RequestBatchExecutionType::SerialRealtime;
-				ret.closeCode = WebSocketCloseCode::UnsupportedFeature;
+			if (payloadData.contains("executionType") && !payloadData["executionType"].is_null()) {
-				ret.closeReason = "Variables are not supported in Parallel mode.";
+				if (!payloadData["executionType"].is_number_unsigned()) {
-				return;
+					ret.closeCode = WebSocketCloseCode::InvalidDataFieldType;
-			}
+					ret.closeReason = "Your `executionType` is not a number.";
-		}
+					return;
+				}
 
-		bool haltOnFailure = false;
+				uint8_t requestedExecutionType = payloadData["executionType"];
-		if (payloadData.contains("haltOnFailure") && !payloadData["haltOnFailure"].is_null()) {
+				if (!RequestBatchExecutionType::IsValid(requestedExecutionType) || requestedExecutionType == RequestBatchExecutionType::None) {
-			if (!payloadData["haltOnFailure"].is_boolean()) {
+					ret.closeCode = WebSocketCloseCode::InvalidDataFieldValue;
-				ret.closeCode = WebSocketCloseCode::InvalidDataFieldType;
+					ret.closeReason = "Your `executionType` has an invalid value.";
-				ret.closeReason = "Your `haltOnFailure` is not a boolean.";
+					return;
-				return;
+				}
+
+				// The thread pool must support 2 or more threads else parallel requests will deadlock.
+				if (requestedExecutionType == RequestBatchExecutionType::Parallel && _threadPool.maxThreadCount() < 2) {
+					ret.closeCode = WebSocketCloseCode::UnsupportedFeature;
+					ret.closeReason = "Parallel request batch processing is not available on this system due to limited core count.";
+					return;
+				}
+
+				executionType = (RequestBatchExecutionType::RequestBatchExecutionType)requestedExecutionType;
 			}
 
-			haltOnFailure = payloadData["haltOnFailure"];
+			if (payloadData.contains("variables") && !payloadData["variables"].is_null()) {
-		}
+				if (!payloadData.is_object()) {
+					ret.closeCode = WebSocketCloseCode::InvalidDataFieldType;
+					ret.closeReason = "Your `variables` is not an object.";
+					return;
+				}
 
-		if (!payloadData.contains("requests")) {
+				if (executionType == RequestBatchExecutionType::Parallel) {
-			ret.closeCode = WebSocketCloseCode::MissingDataField;
+					ret.closeCode = WebSocketCloseCode::UnsupportedFeature;
-			ret.closeReason = "Your payload data is missing a `requests`.";
+					ret.closeReason = "Variables are not supported in Parallel mode.";
+					return;
+				}
+			}
+
+			bool haltOnFailure = false;
+			if (payloadData.contains("haltOnFailure") && !payloadData["haltOnFailure"].is_null()) {
+				if (!payloadData["haltOnFailure"].is_boolean()) {
+					ret.closeCode = WebSocketCloseCode::InvalidDataFieldType;
+					ret.closeReason = "Your `haltOnFailure` is not a boolean.";
+					return;
+				}
+
+				haltOnFailure = payloadData["haltOnFailure"];
+			}
+
+			std::vector<json> requests = payloadData["requests"];
+
+			std::vector<RequestBatchRequest> requestsVector;
+			for (auto &requestJson : requests)
+				requestsVector.emplace_back(requestJson["requestType"], requestJson["requestData"], executionType, requestJson["inputVariables"], requestJson["outputVariables"]);
+
+			auto resultsVector = RequestBatchHandler::ProcessRequestBatch(_threadPool, session, executionType, requestsVector, payloadData["variables"], haltOnFailure);
+
+			size_t i = 0;
+			std::vector<json> results;
+			for (auto &requestResult : resultsVector) {
+				results.push_back(ConstructRequestResult(requestResult, requests[i]));
+				i++;
+			}
+
+			ret.result["op"] = WebSocketOpCode::RequestBatchResponse;
+			ret.result["d"]["requestId"] = payloadData["requestId"];
+			ret.result["d"]["results"] = results;
+			} return;
+		default:
+			ret.closeCode = WebSocketCloseCode::UnknownOpCode;
+			ret.closeReason = std::string("Unknown OpCode: ") + std::to_string(opCode);
 			return;
-		}
-
-		if (!payloadData["requests"].is_array()) {
-			ret.closeCode = WebSocketCloseCode::InvalidDataFieldType;
-			ret.closeReason = "Your `requests` is not an array.";
-			return;
-		}
-
-		std::vector<json> requests = payloadData["requests"];
-
-		std::vector<RequestBatchRequest> requestsVector;
-		for (auto &requestJson : requests) {
-			if (!requestJson["requestType"].is_string())
-				requestJson["requestType"] =
-					""; // Workaround for what would otherwise be extensive additional logic for a rare edge case
-			std::string requestType = requestJson["requestType"];
-			json requestData = requestJson["requestData"];
-			json inputVariables = requestJson["inputVariables"];
-			json outputVariables = requestJson["outputVariables"];
-			requestsVector.emplace_back(requestType, requestData, executionType, inputVariables, outputVariables);
-		}
-
-		auto resultsVector = RequestBatchHandler::ProcessRequestBatch(_threadPool, session, executionType, requestsVector,
-									      payloadData["variables"], haltOnFailure);
-
-		size_t i = 0;
-		std::vector<json> results;
-		for (auto &requestResult : resultsVector) {
-			results.push_back(ConstructRequestResult(requestResult, requests[i]));
-			i++;
-		}
-
-		ret.result["op"] = WebSocketOpCode::RequestBatchResponse;
-		ret.result["d"]["requestId"] = payloadData["requestId"];
-		ret.result["d"]["results"] = results;
-	}
-		return;
-	default:
-		ret.closeCode = WebSocketCloseCode::UnknownOpCode;
-		ret.closeReason = std::string("Unknown OpCode: ") + std::to_string(opCode);
-		return;
 	}
 }
 
 // It isn't consistent to directly call the WebSocketServer from the events system, but it would also be dumb to make it unnecessarily complicated.
-void WebSocketServer::BroadcastEvent(uint64_t requiredIntent, const std::string &eventType, const json &eventData,
+void WebSocketServer::BroadcastEvent(uint64_t requiredIntent, const std::string &eventType, const json &eventData, uint8_t rpcVersion)
-				     uint8_t rpcVersion)
 {
 	if (!_server.is_listening())
 		return;
@@ -355,7 +322,7 @@ void WebSocketServer::BroadcastEvent(uint64_t requiredIntent, const std::string
 
 		// Recurse connected sessions and send the event to suitable sessions.
 		std::unique_lock<std::mutex> lock(_sessionMutex);
-		for (auto &it : _sessions) {
+		for (auto & it : _sessions) {
 			if (!it.second->IsIdentified()) {
 				continue;
 			}
@@ -365,27 +332,24 @@ void WebSocketServer::BroadcastEvent(uint64_t requiredIntent, const std::string
 			if ((it.second->EventSubscriptions() & requiredIntent) != 0) {
 				websocketpp::lib::error_code errorCode;
 				switch (it.second->Encoding()) {
-				case WebSocketEncoding::Json:
+					case WebSocketEncoding::Json:
-					if (messageJson.empty()) {
+						if (messageJson.empty()) {
-						messageJson = eventMessage.dump();
+							messageJson = eventMessage.dump();
-					}
+						}
-					_server.send((websocketpp::connection_hdl)it.first, messageJson,
+						_server.send((websocketpp::connection_hdl)it.first, messageJson, websocketpp::frame::opcode::text, errorCode);
-						     websocketpp::frame::opcode::text, errorCode);
+						it.second->IncrementOutgoingMessages();
-					it.second->IncrementOutgoingMessages();
+						break;
-					break;
+					case WebSocketEncoding::MsgPack:
-				case WebSocketEncoding::MsgPack:
+						if (messageMsgPack.empty()) {
-					if (messageMsgPack.empty()) {
+							auto msgPackData = json::to_msgpack(eventMessage);
-						auto msgPackData = json::to_msgpack(eventMessage);
+							messageMsgPack = std::string(msgPackData.begin(), msgPackData.end());
-						messageMsgPack = std::string(msgPackData.begin(), msgPackData.end());
+						}
-					}
+						_server.send((websocketpp::connection_hdl)it.first, messageMsgPack, websocketpp::frame::opcode::binary, errorCode);
-					_server.send((websocketpp::connection_hdl)it.first, messageMsgPack,
+						it.second->IncrementOutgoingMessages();
-						     websocketpp::frame::opcode::binary, errorCode);
+						break;
-					it.second->IncrementOutgoingMessages();
-					break;
 				}
 				if (errorCode)
-					blog(LOG_ERROR, "[WebSocketServer::BroadcastEvent] Error sending event message: %s",
+					blog(LOG_ERROR, "[WebSocketServer::BroadcastEvent] Error sending event message: %s", errorCode.message().c_str());
-					     errorCode.message().c_str());
 			}
 		}
 		lock.unlock();

src/websocketserver/rpc/WebSocketSession.cpp

@@ -20,16 +20,16 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #include "WebSocketSession.h"
 #include "../../eventhandler/types/EventSubscription.h"
 
-WebSocketSession::WebSocketSession()
+WebSocketSession::WebSocketSession() :
-	: _remoteAddress(""),
+	_remoteAddress(""),
-	  _connectedAt(0),
+	_connectedAt(0),
-	  _incomingMessages(0),
+	_incomingMessages(0),
-	  _outgoingMessages(0),
+	_outgoingMessages(0),
-	  _encoding(0),
+	_encoding(0),
-	  _challenge(""),
+	_challenge(""),
-	  _rpcVersion(OBS_WEBSOCKET_RPC_VERSION),
+	_rpcVersion(OBS_WEBSOCKET_RPC_VERSION),
-	  _isIdentified(false),
+	_isIdentified(false),
-	  _eventSubscriptions(EventSubscription::All)
+	_eventSubscriptions(EventSubscription::All)
 {
 }
 

src/websocketserver/rpc/WebSocketSession.h

@@ -29,58 +29,59 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 class WebSocketSession;
 typedef std::shared_ptr<WebSocketSession> SessionPtr;
 
-class WebSocketSession {
+class WebSocketSession
-public:
+{
-	WebSocketSession();
+	public:
+		WebSocketSession();
 
-	std::string RemoteAddress();
+		std::string RemoteAddress();
-	void SetRemoteAddress(std::string address);
+		void SetRemoteAddress(std::string address);
 
-	uint64_t ConnectedAt();
+		uint64_t ConnectedAt();
-	void SetConnectedAt(uint64_t at);
+		void SetConnectedAt(uint64_t at);
 
-	uint64_t IncomingMessages();
+		uint64_t IncomingMessages();
-	void IncrementIncomingMessages();
+		void IncrementIncomingMessages();
 
-	uint64_t OutgoingMessages();
+		uint64_t OutgoingMessages();
-	void IncrementOutgoingMessages();
+		void IncrementOutgoingMessages();
 
-	uint8_t Encoding();
+		uint8_t Encoding();
-	void SetEncoding(uint8_t encoding);
+		void SetEncoding(uint8_t encoding);
 
-	bool AuthenticationRequired();
+		bool AuthenticationRequired();
-	void SetAuthenticationRequired(bool required);
+		void SetAuthenticationRequired(bool required);
 
-	std::string Secret();
+		std::string Secret();
-	void SetSecret(std::string secret);
+		void SetSecret(std::string secret);
 
-	std::string Challenge();
+		std::string Challenge();
-	void SetChallenge(std::string challenge);
+		void SetChallenge(std::string challenge);
 
-	uint8_t RpcVersion();
+		uint8_t RpcVersion();
-	void SetRpcVersion(uint8_t version);
+		void SetRpcVersion(uint8_t version);
 
-	bool IsIdentified();
+		bool IsIdentified();
-	void SetIsIdentified(bool identified);
+		void SetIsIdentified(bool identified);
 
-	uint64_t EventSubscriptions();
+		uint64_t EventSubscriptions();
-	void SetEventSubscriptions(uint64_t subscriptions);
+		void SetEventSubscriptions(uint64_t subscriptions);
 
-	std::mutex OperationMutex;
+		std::mutex OperationMutex;
 
-private:
+	private:
-	std::mutex _remoteAddressMutex;
+		std::mutex _remoteAddressMutex;
-	std::string _remoteAddress;
+		std::string _remoteAddress;
-	std::atomic<uint64_t> _connectedAt;
+		std::atomic<uint64_t> _connectedAt;
-	std::atomic<uint64_t> _incomingMessages;
+		std::atomic<uint64_t> _incomingMessages;
-	std::atomic<uint64_t> _outgoingMessages;
+		std::atomic<uint64_t> _outgoingMessages;
-	std::atomic<uint8_t> _encoding;
+		std::atomic<uint8_t> _encoding;
-	std::atomic<bool> _authenticationRequired;
+		std::atomic<bool> _authenticationRequired;
-	std::mutex _secretMutex;
+		std::mutex _secretMutex;
-	std::string _secret;
+		std::string _secret;
-	std::mutex _challengeMutex;
+		std::mutex _challengeMutex;
-	std::string _challenge;
+		std::string _challenge;
-	std::atomic<uint8_t> _rpcVersion;
+		std::atomic<uint8_t> _rpcVersion;
-	std::atomic<bool> _isIdentified;
+		std::atomic<bool> _isIdentified;
-	std::atomic<uint64_t> _eventSubscriptions;
+		std::atomic<uint64_t> _eventSubscriptions;
 };

src/websocketserver/types/WebSocketOpCode.h

@@ -20,7 +20,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 #pragma once
 
 namespace WebSocketOpCode {
-	enum WebSocketOpCode : uint8_t {
+	enum WebSocketOpCode: uint8_t {
 		/**
 		* The initial message sent by obs-websocket to newly connected clients.
 		*
@@ -122,5 +122,8 @@ namespace WebSocketOpCode {
 		RequestBatchResponse = 9,
 	};
 
-	inline bool IsValid(uint8_t opCode) { return opCode >= Hello && opCode <= RequestBatchResponse; }
+	inline bool IsValid(uint8_t opCode)
+	{
+		return opCode >= Hello && opCode <= RequestBatchResponse;
+	}
 }