[SAVEVERSION+] Reimplement PAD system

Force pushed because git hates me

[SAVEVERSION+] Bump savestate version

CI: Update locations of pad/memcard sources

Discard leftover old PAD code

Fix additional merge oddities

Add translations for OSD messages

Copyright headers

Version bump

Fix a whole boatload of concurrency problems from file moves and other miscellaneous update problems

Partial redo of PS1 pad support

Fix incorrect mode due to analog behavior at startup

Mostly reimplement SIO0 memory card logic

Still needs pocketstation

Use new runtime wrapped translate function

Dead code

Fix multiple port/slot/presence issues for PS1

Save State version bump

Clean up some duplicate/unused headers

More header consistency

Remove old stray files

Fix incorrect return

Fix uninitialized array

Add missing overrides

Switch to init/close model used by other subsystems

Remove old input recording references

Rename SIO globals

Rename SIO2 FIFO globals

Remove commented SIO0 code for illegal write

Add guitar icon

.codacy.yaml

@@ -1,3 +1,5 @@
 ---
 exclude_paths:
   - '3rdparty/**'
+  - '*.md'
+  - '**/*.md'

.github/CONTRIBUTING.md

@@ -26,13 +26,17 @@ The following is a list of *general* style recommendations that will make review
     *   Please try to prefix your commit message, indicating what area of the project was modified.
         *   For example `gs: message...`.
         *   Looking at the project's commit history will help with keeping prefixes consistent overtime, *there is no strictly enforced list*.
+
     *   Try to keep messages brief and informative
+
     *   Remove unnecessary commits and squash commits together when appropriate.
         *   If you are not familiar with rebasing with git, check out the following resources:
             *   CLI - https://thoughtbot.com/blog/git-interactive-rebase-squash-amend-rewriting-history
             *   GUI (SourceTree) - https://www.atlassian.com/blog/sourcetree/interactive-rebase-sourcetree
+
 *   Code Styling and Formatting
     *   [Consult the style guide](https://github.com/tadanokojin/pcsx2/blob/coding-guide/pcsx2/Docs/Coding_Guidelines.md)
+
     *   Run `clang-format` using the configuration file in the root of the repository
         *   Visual Studio Setup - https://devblogs.microsoft.com/cppblog/clangformat-support-in-visual-studio-2017-15-7-preview-1/
         *   IMPORTANT - if you are running `clang-format` on unrelated changes (ie. formatting an entire file), please do so in a separate commit.
@@ -41,9 +45,9 @@ The following is a list of *general* style recommendations that will make review
 ## General Documentation And Coding Strategies
 
 *   [Commenting Etiquette](https://github.com/PCSX2/pcsx2/wiki/Commenting-Etiquette)
+
 *   [Coding style](https://github.com/PCSX2/pcsx2/wiki/Code-Formatting-Guidelines)
     *   [More comprehensive style-guide (Currently in Draft)](https://github.com/tadanokojin/pcsx2/blob/coding-guide/pcsx2/Docs/Coding_Guidelines.md)
-*   [wxWidgets coding strategies](https://github.com/PCSX2/pcsx2/wiki/wxWidgets-Coding-Strategies)
 
 ## Tasks
 

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: [PCSX2]

.github/ISSUE_TEMPLATE/app_bug_report.yaml

@@ -12,19 +12,22 @@ body:
         ## Important: Read First
 
         Please do not make support requests on GitHub. Our issue tracker is for tracking bugs and feature requests only
-        If you need help configuring the emulator please make a request on our forums or contact us on discord
+        If you need help configuring the emulator please make a request on our forums or contact us on discord.
 
-        If you are unsure, start with [discord](https://discord.com/invite/TCz3t9k) or the [forums](https://forums.pcsx2.net/index.php)
+        If you are unsure, start with [discord](https://discord.com/invite/TCz3t9k) or the [forums](https://forums.pcsx2.net/index.php).
 
-        Please make an effort to make sure your issue isn't already reported
+        Please make an effort to make sure your issue isn't already reported.
 
         ### Please Avoid Issues Pertaining to the Following:
-        - We are **not** accepting bug reports for **PSX mode** at this time
-          - If you are interested in helping contribute to PSX mode please do so on the forums. Otherwise our recommendation is that you use a [proper PSX emulator](https://emulation.gametechwiki.com/index.php/PlayStation_emulators)
-        - We do **not** accept issues relating to **upscaling** at this time
-          - We are aware of the various problems with upscaling. The issue spans many games and having hundreds of issues for the same fundamental issues isn't particularly helpful. There are several workarounds for graphical problems that come as a result of upscaling
-          - Please try your game at native resolution before creating an issue
-          - If your bug is the result of upscaling please use the forums or discord for assistance with various upscaling workarounds. Additionally, the unofficial PCSX2 [Wiki](https://wiki.pcsx2.net/Main_Page) often lists various fixes for upscaling issues
+        - We are **not** accepting bug reports for **PSX mode** at this time.
+          - If you are interested in helping contribute to PSX mode please do so on the forums. Otherwise our recommendation is that you use  [Duckstation](https://github.com/stenzek/duckstation/releases/tag/latest).
+        - We do **not** accept issues relating to **upscaling** at this time.
+          - We are aware of the various problems with upscaling. The issue spans many games and having hundreds of issues for the same fundamental issues isn't particularly helpful. There are several workarounds for graphical problems that come as a result of upscaling.
+          - Please try your game at native resolution before creating an issue.
+          - If your bug is the result of upscaling please use the forums or discord for assistance with various upscaling workarounds. Additionally, the unofficial PCSX2 [Wiki](https://wiki.pcsx2.net/Main_Page) often lists various fixes for upscaling issues.
+        - We do **not** accept issues relating to Widescreen/no-interlace patches at this time.
+          - Any issues pertaining to Widescreen/no-interlace patches please forward them to the [patches repository](https://github.com/PCSX2/pcsx2_patches). 
+
   - type: textarea
     id: desc
     attributes:
@@ -60,16 +63,13 @@ body:
       label: Operating System
       options:
       - Windows 11
-      - Windows 10 (32bit)
       - Windows 10 (64bit)
-      - Windows 8.1 (32bit)
-      - Windows 8.1 (64bit)
-      - Linux (32bit) - Specify Distro Below
-      - Linux (64bit) - Specify Distro Below
-      - macOS (Monteray)
-      - macOS (BigSur)
-      - macOS (Catalina)
-      - macOS (Mojave)
+      - Linux (64bit) - Specify distro below
+      - macOS 13 (Ventura)
+      - macOS 12 (Monterey)
+      - macOS 11 (Big Sur)
+      - macOS 10.15 (Catalina)
+      - macOS 10.14 (Mojave)
     validations:
       required: true
   - type: input
@@ -79,3 +79,12 @@ body:
       placeholder: "Example: Arch"
     validations:
       required: false
+  - type: textarea
+    id: logsDumps
+    attributes:
+      label: "Logs & Dumps"
+      description: |
+        Please feel free to attach any logs here.
+        If PCSX2 crashed, please post crash logs and the .dmp file (in a zip file) if appropriate.
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/emu_bug_report.yaml

@@ -12,19 +12,22 @@ body:
         ## Important: Read First
 
         Please do not make support requests on GitHub. Our issue tracker is for tracking bugs and feature requests only
-        If you need help configuring the emulator please make a request on our forums or contact us on discord
+        If you need help configuring the emulator please make a request on our forums or contact us on discord.
 
-        If you are unsure, start with [discord](https://discord.com/invite/TCz3t9k) or the [forums](https://forums.pcsx2.net/index.php)
+        If you are unsure, start with [discord](https://discord.com/invite/TCz3t9k) or the [forums](https://forums.pcsx2.net/index.php).
 
-        Please make an effort to make sure your issue isn't already reported
+        Please make an effort to make sure your issue isn't already reported.
 
         ### Please Avoid Issues Pertaining to the Following:
-        - We are **not** accepting bug reports for **PSX mode** at this time
-          - If you are interested in helping contribute to PSX mode please do so on the forums. Otherwise our recommendation is that you use a [proper PSX emulator](https://emulation.gametechwiki.com/index.php/PlayStation_emulators)
-        - We do **not** accept issues relating to **upscaling** at this time
-          - We are aware of the various problems with upscaling. The issue spans many games and having hundreds of issues for the same fundamental issues isn't particularly helpful. There are several workarounds for graphical problems that come as a result of upscaling
-          - Please try your game at native resolution before creating an issue
-          - If your bug is the result of upscaling please use the forums or discord for assistance with various upscaling workarounds. Additionally, the unofficial PCSX2 [Wiki](https://wiki.pcsx2.net/Main_Page) often lists various fixes for upscaling issues
+        - We are **not** accepting bug reports for **PSX mode** at this time.
+          - If you are interested in helping contribute to PSX mode please do so on the forums. Otherwise our recommendation is that you use  [Duckstation](https://github.com/stenzek/duckstation/releases/tag/latest).
+        - We do **not** accept issues relating to **upscaling** at this time.
+          - We are aware of the various problems with upscaling. The issue spans many games and having hundreds of issues for the same fundamental issues isn't particularly helpful. There are several workarounds for graphical problems that come as a result of upscaling.
+          - Please try your game at native resolution before creating an issue.
+          - If your bug is the result of upscaling please use the forums or discord for assistance with various upscaling workarounds. Additionally, the unofficial PCSX2 [Wiki](https://wiki.pcsx2.net/Main_Page) often lists various fixes for upscaling issues.
+        - We do **not** accept issues relating to Widescreen/no-interlace patches at this time.
+          - Any issues pertaining to Widescreen/no-interlace patches please forward them to the [patches repository](https://github.com/PCSX2/pcsx2_patches). 
+
   - type: textarea
     id: desc
     attributes:
@@ -52,16 +55,13 @@ body:
         ## System Info
 
         Please make sure your system meets our requirements for OS version, CPU and GPU
-        - [System Requirements](https://github.com/PCSX2/pcsx2#system-requirements)
+        - [System Requirements](https://github.com/PCSX2/pcsx2#system-requirements).
 
-        We **do not** accept bug reports for **unsupported operating systems**.
-        - [For macOS Support](https://forums.pcsx2.net/Thread-Native-Mac-Testing-Build)
-
-        Performance issues as a result of not meeting our hardware requirements are not valid
+        Performance issues as a result of not meeting our hardware requirements are not valid.
 
         Please read our known issues pages for AMD and Intel drivers.
-        - [Intel Drivers](https://github.com/PCSX2/pcsx2/wiki/OpenGL-and-Intel-GPUs-All-you-need-to-know)
-        - [AMD Drivers](https://github.com/PCSX2/pcsx2/wiki/OpenGL-and-AMD-GPUs---All-you-need-to-know)
+        - [Intel Drivers](https://github.com/PCSX2/pcsx2/wiki/OpenGL-and-Intel-GPUs-All-you-need-to-know).
+        - [AMD Drivers](https://github.com/PCSX2/pcsx2/wiki/OpenGL-and-AMD-GPUs---All-you-need-to-know).
 
         We are **not** accepting issues related to the **libretro** core. The libretro core is being maintained separately at this time
   - type: input
@@ -78,16 +78,13 @@ body:
       label: Operating System
       options:
       - Windows 11
-      - Windows 10 (32bit)
       - Windows 10 (64bit)
-      - Windows 8.1 (32bit)
-      - Windows 8.1 (64bit)
-      - Linux (32bit) - Specify Distro Below
-      - Linux (64bit) - Specify Distro Below
-      - macOS (Monteray)
-      - macOS (BigSur)
-      - macOS (Catalina)
-      - macOS (Mojave)
+      - Linux (64bit) - Specify distro below
+      - macOS 13 (Ventura)
+      - macOS 12 (Monterey)
+      - macOS 11 (Big Sur)
+      - macOS 10.15 (Catalina)
+      - macOS 10.14 (Mojave)
     validations:
       required: true
   - type: input
@@ -123,11 +120,11 @@ body:
     attributes:
       label: Emulation Settings
       description: |
-        Any non-default core settings. If you don't want to list them out, please provide screenshots of your configuration window
+        Any non-default core settings. If you don't want to list them out, please provide screenshots of your configuration window.
 
-        Please note that the safe preset works for most games. MTVU can have some compatibility issues so please disable it before making a report
+        Please note that the safe preset works for most games. MTVU can have some compatibility issues so please disable it before making a report.
 
-        If you need to modify the settings manually because a game requires you to do so to work, please state that explicitly
+        If you need to modify the settings manually because a game requires you to do so to work, please state that explicitly.
     validations:
       required: false
   - type: textarea
@@ -142,8 +139,8 @@ body:
     attributes:
       label: "Logs & Dumps"
       description: |
-        Please feel free to attach any logs, block dumps, GSdump, etc here
-
+        Please feel free to attach any logs, block dumps, GSdump, etc here.
+        If PCSX2 crashed, please post crash logs and the .dmp file (in a zip file) if appropriate.
         If your problem is graphical in nature it is highly recommended that you provide a GSdump. [GSdump Guide](https://forums.pcsx2.net/Thread-How-to-create-a-proper-GS-dump)
     validations:
       required: false

.github/labeler.yml

@@ -12,7 +12,6 @@
   - 'cmake/**/*'
   - 'CMakeLists.txt'
   - '**/CMakeLists.txt'
-  - 'buildbot.xml'
   - 'build.sh'
 'Dependencies':
   - '3rdparty/*'
@@ -24,14 +23,6 @@
   - '**/*.md'
   - '*.pdf'
   - '**/*.pdf'
-'GUI/WX':
-  - 'pcsx2/gui/*'
-  - 'pcsx2/gui/**/*'
-  - 'pcsx2/SPU2/wx/*'
-  - 'pcsx2/SPU2/wx/**/*'
-  - 'pcsx2/PAD/Linux/wx_dialog/*'
-  - 'pcsx2/PAD/Linux/wx_dialog/**/*'
-  - 'pcsx2/GS/Window/GSwxDialog.h'
 'GUI/Qt':
   - 'pcsx2-qt/*'
   - 'pcsx2-qt/**/*'
@@ -40,22 +31,25 @@
 'GameDB':
   - '**/GameIndex.*'
 'Installer | Package':
-  - 'nsis/*'
-  - 'nsis/**/*'
   - 'build.sh'
+'Translations':
+  - 'pcsx2-qt/Translations/*'
 
 # Tools / Features
 'Debugger':
   - 'pcsx2/DebugTools/*'
   - 'pcsx2/DebugTools/**/*'
-  - 'pcsx2/gui/Debugger/*'
-  - 'pcsx2/gui/Debugger/**/*'
+  - 'pcsx2-qt/Debugger/*'
+  - 'pcsx2-qt/Debugger/**/*'
 'IPC':
   - 'pcsx2/IPC*'
   - 'pcsx2/**/IPC*'
 'TAS Functionality':
   - 'pcsx2/Recording/*'
   - 'pcsx2/Recording/**/*'
+'RetroAchievements':
+  - 'pcsx2/Frontend/Achievements.*'
+  - 'pcsx2/Achievements.*'
 
 # Emulation Components
 'Counters':
@@ -75,18 +69,34 @@
 'GS':
   - 'pcsx2/GS/*'
   - 'pcsx2/GS/**/*'
-'GS: Direct3D':
+  - 'bin/resources/shaders/*'
+  - 'bin/resources/shaders/**/*'
+'GS: Direct3D 11':
   - 'pcsx2/GS/Renderers/DX11/*'
   - 'pcsx2/GS/Renderers/DX11/**/*'
+  - 'bin/resources/shaders/dx11/*'
+  - 'bin/resources/shaders/dx11/**/*'
+'GS: Direct3D 12':
+  - 'pcsx2/GS/Renderers/DX12/*'
+  - 'pcsx2/GS/Renderers/DX12/**/*'
+  - 'bin/resources/shaders/dx11/*'
+  - 'bin/resources/shaders/dx11/**/*'
 'GS: Hardware':
   - 'pcsx2/GS/Renderers/HW/*'
   - 'pcsx2/GS/Renderers/HW/**/*'
 'GS: OpenGL':
   - 'pcsx2/GS/Renderers/OpenGL/*'
   - 'pcsx2/GS/Renderers/OpenGL/**/*'
+  - 'bin/resources/shaders/opengl/*'
+  - 'bin/resources/shaders/opengl/**/*'
 'GS: Vulkan':
   - 'pcsx2/GS/Renderers/Vulkan/*'
   - 'pcsx2/GS/Renderers/Vulkan/**/*'
+  - 'bin/resources/shaders/vulkan/*'
+  - 'bin/resources/shaders/vulkan/**/*'
+'GS: Metal':
+  - 'pcsx2/GS/Renderers/Metal/*'
+  - 'pcsx2/GS/Renderers/Metal/**/*'
 'GS: Texture Cache':
   - 'pcsx2/GS/Renderers/*TextureCache*.*'
   - 'pcsx2/GS/Renderers/**/*TextureCache*.*'
@@ -105,14 +115,11 @@
   - 'pcsx2/IPU/*'
   - 'pcsx2/IPU/**/*'
 'Memory Card':
-  - 'pcsx2/gui/MemoryCard*'
-  - 'pcsx2/gui/**/MemoryCard*'
-'PAD: Linux/Mac':
-  - 'pcsx2/PAD/Linux/*'
-  - 'pcsx2/PAD/Linux/**/*'
-'PAD: Windows':
-  - 'pcsx2/PAD/Windows/*'
-  - 'pcsx2/PAD/Windows/**/*'
+  - 'pcsx2/SIO/Memcard/*'
+  - 'pcsx2/SIO/Memcard/**/*'
+'PAD':
+  - 'pcsx2/SIO/Pad/*'
+  - 'pcsx2/SIO/Pad/**/*'
 'SPU2':
   - 'pcsx2/SPU2/*'
   - 'pcsx2/SPU2/**/*'

.github/workflows/architecture/README.md

@@ -0,0 +1,14 @@
+# CI Documentation
+
+## Releases
+
+```mermaid
+sequenceDiagram
+  PCSX2 Repo->>Actions: PR is merged or commit is pushed to master
+  Actions->>PCSX2 Repo: Increment latest tag and push, create a draft release
+  Actions->>Actions: Kicked off pipeline on the tag push, build relevant configs
+  Actions->>PCSX2 Repo: Rename and upload artifacts to draft release, publish the release
+  Actions->>Discord: Announce release via a WebHook
+  PCSX2 Repo->>Web API: POST webhook to API informing it that a new release has occurred
+  Web API->>Web API: Update cache with new release
+```

.github/workflows/architecture/release-process.puml

@@ -1,47 +0,0 @@
-@startuml
-participant User as user
-participant Github as github
-participant "Create Release WF" as create
-participant "Build WFs" as build
-participant "Finalize Release WF" as finalize
-participant Discord as discord
-
-==Nightly Release==
-
-user -> github : New Commit on master (from PR, or directly)
-...waiting for commit push event to fire...
-github -> create : Push a new git tag, patch incrementing latest Version
-alt from-pr? case
-    create -> create : Use links to the PR as a description
-else was a commit
-    create -> create : Use Commit Message as Description
-end
-create -> create : Generate release notes
-create -> github : Create new draft release, associated with tag and with the notes
-note right
-Draft releases are not public facing, only those with write access can see them!
-end note
-...waiting for push tag event to fire...
-loop for all build workflows
-github -> build : Build the tag commit
-build -> build : .exe will use the git tag for it's title and such
-build -> build : Upload the generated artifact to the associated release
-alt all-artifacts-uploaded? case
-  build -> github : Publish the release
-  user -> github : Can now download the artifacts on the published release
-end
-note right 
-This is the only area where an eventual consistency issue is apparent
-It is because GitHub does not fire events for when draft releases are edited
-This is glossed over in the initial impl and can be improved and be made eventually consistent as well
-end note
-
-
-...waiting for release publish event to fire...
-github -> finalize : Announce the Release
-finalize -> github : Gather all asset links, and format message embed.
-finalize -> discord : Announce new build via a WebHook
-
-...waiting for announcement...
-user -> discord : Can download artifacts from links via the discord
-@enduml

.github/workflows/cron_publish_flatpak.yml

@@ -0,0 +1,41 @@
+name: 📦 Publish Flathub Release
+
+on:
+  schedule:
+    - cron: "0 0 * * *" # Every day at 12am UTC.
+  workflow_dispatch: # As well as manually.
+
+jobs:
+  check:
+    if: github.repository == 'PCSX2/pcsx2'
+    name: "Check if release is needed"
+    runs-on: ubuntu-latest
+    outputs:
+      PCSX2_RELEASE: ${{ steps.getinfo.outputs.PCSX2_RELEASE }}
+      FLATHUB_RELEASE: ${{ steps.getinfo.outputs.FLATHUB_RELEASE }}
+    steps:
+      - name: Get latest tag and Flathub release
+        id: getinfo
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          PCSX2_RELEASE=$(gh api -H 'Accept: application/vnd.github+json' -H 'X-GitHub-Api-Version: 2022-11-28' /repos/PCSX2/pcsx2/releases | jq -r '.[0].tag_name')
+          FLATHUB_RELEASE=$(curl -L -s https://flathub.org/api/v2/appstream/net.pcsx2.PCSX2 | jq -r '.releases | max_by(.version) | .version')
+          echo "Latest PCSX2 release is: '${PCSX2_RELEASE}'"
+          echo "Latest Flathub release is: '${FLATHUB_RELEASE}'"
+          echo "PCSX2_RELEASE=${PCSX2_RELEASE}" >> "$GITHUB_OUTPUT"
+          echo "FLATHUB_RELEASE=${FLATHUB_RELEASE}" >> "$GITHUB_OUTPUT"
+
+  build:
+    needs: check
+    if: needs.check.outputs.FLATHUB_RELEASE < needs.check.outputs.PCSX2_RELEASE
+    name: "Build and publish Flatpak"
+    uses: ./.github/workflows/linux_build_flatpak.yml
+    with:
+      jobName: "Qt"
+      compiler: clang
+      cmakeflags: ""
+      publish: true
+      branch: stable
+    secrets: inherit
+

.github/workflows/cron_update_base_translation.yml

@@ -0,0 +1,28 @@
+name: 🌎 Update Base Translation
+
+on:
+  schedule:
+    - cron: "0 0 * * *" # Every day at 12am UTC.
+  workflow_dispatch: # As well as manually.
+
+jobs:
+  update:
+    if: github.repository == 'PCSX2/pcsx2'
+    name: "Update Base Translation"
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Update Base Translation
+        run: ./.github/workflows/scripts/common/update_base_translation.sh
+      
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v5
+        with:
+          title: "Qt: Update Base Translation"
+          commit-message: "Qt: Update Base Translation"
+          committer: "PCSX2 Bot <PCSX2Bot@users.noreply.github.com>"
+          author: "PCSX2 Bot <PCSX2Bot@users.noreply.github.com>"
+          body: "Daily update of base translation sources."
+          branch: update-base-translation
+          delete-branch: true

.github/workflows/cron_update_controller_db.yml

@@ -0,0 +1,29 @@
+name: 🏭 Update Controller Database
+
+on:
+  schedule:
+    - cron: "0 16 * * 1" # every monday @ 12pm EST - https://crontab.guru/#0_16_*_*_1
+
+jobs:
+  update-controller-db:
+    if: github.repository == 'PCSX2/pcsx2'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Get Latest DB and Prepare DB File
+        run: |
+          cd .github/workflows/scripts/controller-db/
+          wget -O game_controller_db.txt https://raw.githubusercontent.com/gabomdq/SDL_GameControllerDB/master/gamecontrollerdb.txt
+          python ./update-db.py
+          mv ./game_controller_db.txt ${{github.workspace}}/bin/resources/game_controller_db.txt
+
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v5
+        with:
+          title: "PAD: Update to latest controller database"
+          commit-message: "PAD: Update to latest controller database."
+          committer: "PCSX2 Bot <PCSX2Bot@users.noreply.github.com>"
+          author: "PCSX2 Bot <PCSX2Bot@users.noreply.github.com>"
+          body: "Weekly automatic update of SDL Controller DB"
+          reviewers: lightningterror

.github/workflows/lint-gamedb.yml

@@ -1,27 +0,0 @@
-name: 📝 Validate GameDB
-
-on:
-  push:
-    branches:
-      - master
-    paths:
-      - '**/GameIndex.yaml'
-  pull_request:
-    branches:
-      - master
-    paths:
-      - '**/GameIndex.yaml'
-
-jobs:
-  lint:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v3
-
-      - name: Validate GameDB
-        env:
-          SCRIPT_DIR: .github/workflows/scripts/validation/lint-gamedb
-        run: |
-          pip install -r "${SCRIPT_DIR}/requirements.txt"
-          python "${SCRIPT_DIR}/lint-gamedb.py"

.github/workflows/lint_gamedb.yml

@@ -0,0 +1,31 @@
+name: 📝 Validate GameDB
+
+on:
+  push:
+    branches-ignore:
+      - "l10n_master"
+    paths:
+      - '**/GameIndex.yaml'
+  pull_request:
+    branches:
+      - master
+    paths:
+      - '**/GameIndex.yaml'
+
+jobs:
+  lint:
+    name: Lint and Validate GameDB
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v3
+
+      - name: Validate Contents
+        run: |
+          npm install -g ajv-cli
+          ajv validate -s ./pcsx2/Docs/gamedb-schema.json --spec=draft2020 -d ./bin/resources/GameIndex.yaml
+
+      - name: Check Formatting
+        run: |
+          npm install -g prettier
+          prettier --check ./bin/resources/GameIndex.yaml

.github/workflows/linux-workflow.yml

@@ -1,233 +0,0 @@
-name: 🐧 Linux Builds
-
-# Controls when the action will run. Triggers the workflow on push or pull request
-# events but only for the master branch
-on:
-  push:
-    branches:
-      - master
-    tags:
-      - v*
-  pull_request:
-    branches:
-      - master
-    paths-ignore:
-      - "**/*.md"
-      - "**/*.bat"
-      - "**/*.cmd"
-      - "**/*.props"
-      - "**/*.sln"
-      - ".clang-format"
-      - ".codacy.yaml"
-      - ".github/*"
-      - ".github/workflows/lint-gamedb.yml"
-      - ".github/workflows/macos-workflow.yml"
-      - ".github/workflows/pr-triage.yml"
-      - ".github/workflows/scripts/windows/**"
-      - ".github/workflows/scripts/validation/**"
-      - ".github/workflows/windows-workflow.yml"
-      - ".gitignore"
-      - "bin/PCSX2_keys.ini.default"
-      - "build.sh"
-      - "buildbot.xml"
-      - "pcsx2/CDVD/Windows/**"
-      - "pcsx2/DEV9/Win32/**"
-      - "pcsx2/PAD/Windows/**"
-      - "pcsx2/SPU2/Windows/**"
-      - "pcsx2/USB/Win32/**"
-      - "pcsx2/windows/**"
-
-jobs:
-  build:
-    strategy:
-      # Prevent one build from failing everything (although maybe those should be included as experimental builds instead)
-      fail-fast: false
-      matrix:
-        include:
-          - os: ubuntu-18.04
-            platform: x64
-            compiler: gcc
-            cmakeflags: -DLTO_PCSX2_CORE=ON
-            appimage: true
-            experimental: false
-          - os: ubuntu-18.04
-            platform: x64
-            compiler: clang
-            # Need to disable PCH until cmake 3.17
-            # (PCH conflicts with ccache, fixed by https://gitlab.kitware.com/cmake/cmake/-/merge_requests/4400)
-            cmakeflags: -DCMAKE_DISABLE_PRECOMPILE_HEADERS=ON
-            detail: " nopch"
-            appimage: false
-            experimental: false
-          - os: ubuntu-18.04
-            platform: x64
-            compiler: gcc
-            cmakeflags: -DCMAKE_DISABLE_PRECOMPILE_HEADERS=ON
-            detail: " nopch"
-            appimage: false
-            experimental: false
-          - os: ubuntu-18.04
-            platform: x64
-            compiler: gcc
-            cmakeflags: -DCMAKE_DISABLE_PRECOMPILE_HEADERS=ON -DARCH_FLAG=-march=haswell
-            detail: " avx2 nopch"
-            appimage: false
-            experimental: false
-
-    name: ${{ matrix.compiler }}${{ matrix.detail }}
-    runs-on: ${{ matrix.os }}
-    continue-on-error: ${{ matrix.experimental }}
-    # Set some sort of timeout in the event of run-away builds.  We are limited on concurrent jobs so, get rid of them.
-    timeout-minutes: 60
-
-    env:
-      CCACHE_BASEDIR: ${{ github.workspace }}
-      CCACHE_DIR: ${{ github.workspace }}/.ccache
-      CCACHE_COMPRESS: true
-      CCACHE_COMPRESSLEVEL: 9
-      CCACHE_MAXSIZE: 100M
-      SDL: SDL2-2.0.16
-      PATCHELF_VERSION: 0.12
-
-    steps:
-      # NOTE - useful for debugging
-      # - name: Dump GitHub context
-      #   env:
-      #     GITHUB_CONTEXT: ${{ toJson(github) }}
-      #   run: |
-      #     echo "$GITHUB_CONTEXT"
-      #     echo ${{ github.event.pull_request.title }}
-
-      - name: Checkout Repository
-        uses: actions/checkout@v3
-
-      - name: Checkout Submodules
-        if: steps.cache-submodules.outputs.cache-hit != 'true'
-        run: git submodule update --init --recursive -j $(getconf _NPROCESSORS_ONLN)
-
-      # -- SETUP CCACHE - https://cristianadam.eu/20200113/speeding-up-c-plus-plus-github-actions-using-ccache/
-      - name: Prepare ccache timestamp
-        id: ccache_cache_timestamp
-        shell: cmake -P {0}
-        run: |
-          string(TIMESTAMP current_date "%Y-%m-%d-%H;%M;%S" UTC)
-          message("::set-output name=timestamp::${current_date}")
-
-      - name: ccache cache files
-        uses: actions/cache@v3
-        with:
-          path: .ccache
-          key: ${{ matrix.os }} ${{ matrix.platform }} ${{ matrix.compiler }}${{ matrix.detail }} ccache ${{ steps.ccache_cache_timestamp.outputs.timestamp }}
-          restore-keys: ${{ matrix.os }} ${{ matrix.platform }} ${{ matrix.compiler }}${{ matrix.detail }} ccache
-
-      - name: Prepare Artifact Metadata
-        id: artifact-metadata
-        shell: bash
-        run: |
-          ARCH=$([ "${{ matrix.platform }}" == x86 ] && echo "32bit" || echo "64bit")
-          ARTIFACT_NAME=""
-          if [ ${{ github.event_name }} == "pull_request" ]; then
-            PR_SHA=$(git rev-parse --short "${{ github.event.pull_request.head.sha }}")
-            ARTIFACT_NAME="PCSX2-${ARCH}"
-            if [ ! -z "${{ github.event.pull_request.number }}" ]; then
-              PR_NUM=${{ github.event.pull_request.number }}
-              ARTIFACT_NAME="${ARTIFACT_NAME}-pr[${PR_NUM}]"
-            fi
-            ARTIFACT_NAME="${ARTIFACT_NAME}-sha[${PR_SHA}]"
-            if [ ! -z "${{ github.event.pull_request.title }}" ]; then
-              PR_TITLE=$(echo "${{ github.event.pull_request.title }}" | tr -cd '[a-zA-Z0-9[:space:]]_-')
-              ARTIFACT_NAME="${ARTIFACT_NAME}-title["${PR_TITLE}""
-            fi
-          else
-            SHA=$(git rev-parse --short "$GITHUB_SHA")
-            ARTIFACT_NAME="PCSX2-${ARCH}-sha[${SHA}"
-          fi
-          TRIMMED_ARTIFACT_NAME=$(printf "%.199s]" "$ARTIFACT_NAME")
-          echo "name=$TRIMMED_ARTIFACT_NAME"
-          echo "##[set-output name=name;]${TRIMMED_ARTIFACT_NAME}"
-          echo "##[set-output name=arch;]${ARCH}"
-
-      - name: Install Packages
-        env:
-          PLATFORM: ${{ matrix.platform }}
-          COMPILER: ${{ matrix.compiler }}
-        run: .github/workflows/scripts/linux/install-packages.sh
-
-      - name: Cache Dependencies
-        uses: actions/cache@v3
-        with:
-          path: |
-            3rdparty/${{ env.SDL }}
-            3rdparty/patchelf-${{ env.PATCHELF_VERSION }}
-          key: ${{ matrix.os }} ${{ matrix.platform }} ${{ env.SDL }} patchelf-${{ env.PATCHELF_VERSION }}
-
-      - name: Build Dependencies
-        run: |
-          if [[ ! -e 3rdparty/patchelf-${{ env.PATCHELF_VERSION }} ]]; then
-            curl -sSfL https://github.com/NixOS/patchelf/releases/download/${{ env.PATCHELF_VERSION }}/patchelf-${{ env.PATCHELF_VERSION }}.tar.bz2 | tar -xjC 3rdparty
-            mv 3rdparty/patchelf-${{ env.PATCHELF_VERSION }}* 3rdparty/patchelf-${{ env.PATCHELF_VERSION }}
-            cd 3rdparty/patchelf-${{ env.PATCHELF_VERSION }}
-            ./configure
-            make && cd ../../
-          fi
-          sudo make -C 3rdparty/patchelf-${{ env.PATCHELF_VERSION }} install
-          if [[ ! -e 3rdparty/${{ env.SDL }} ]]; then
-            curl -sL https://libsdl.org/release/${{ env.SDL }}.tar.gz | tar -xzC 3rdparty
-            cd 3rdparty/${{ env.SDL }}
-            if [ "${{ matrix.platform }}" == "x86" ]; then
-              ./configure --build=i686-pc-linux-gnu CC=${{ matrix.compiler }} CFLAGS=-m32 CXXFLAGS=-m32 LDFLAGS=-m32 --prefix=/usr --libdir=/usr/lib/i386-linux-gnu
-            else
-              ./configure --prefix=/usr --libdir=/usr/lib/x86_64-linux-gnu
-            fi
-            make -j $(getconf _NPROCESSORS_ONLN) && cd ../../
-          fi
-          sudo make -C 3rdparty/${{ env.SDL }} install
-
-      - name: Generate CMake
-        env:
-          PLATFORM: ${{ matrix.platform }}
-          COMPILER: ${{ matrix.compiler }}
-          ADDITIONAL_CMAKE_ARGS: ${{ matrix.cmakeflags }}
-        run: .github/workflows/scripts/linux/generate-cmake.sh
-
-      - name: Build PCSX2
-        working-directory: build
-        run: ../.github/workflows/scripts/linux/compile.sh
-
-      - name: Run Tests
-        working-directory: ./build
-        run: ninja unittests
-
-      - name: Package AppImage
-        if: matrix.appimage == true
-        env:
-          PLATFORM: ${{ matrix.platform }}
-          COMPILER: ${{ matrix.compiler }}
-          name: ${{ steps.artifact-metadata.outputs.name }}
-        run: .github/workflows/scripts/linux/appimage.sh
-
-      - name: Upload artifact
-        if: matrix.appimage == true
-        uses: actions/upload-artifact@v3
-        with:
-          name: ${{ steps.artifact-metadata.outputs.name }}
-          path: ci-artifacts
-
-      # ---- Release / Tagging related steps ----
-      - name: Prepare Build Artifacts
-        if: github.repository == 'PCSX2/pcsx2' && startsWith(github.ref, 'refs/tags/') && matrix.appimage == true
-        run: |
-          mv ./ci-artifacts/*.AppImage ./ci-artifacts/linux-AppImage-${{ steps.artifact-metadata.outputs.arch }}.AppImage
-          ls ./ci-artifacts/
-
-      - name: Upload Assets and Potential Publish Release
-        if: github.repository == 'PCSX2/pcsx2' && startsWith(github.ref, 'refs/tags/') && matrix.appimage == true
-        env:
-          GITHUB_TOKEN: ${{ secrets.BOT_PAT }}
-          ASSET_DIR: ${{ github.WORKSPACE }}/ci-artifacts
-          ASSET_EXTENSION: AppImage
-          TAG_TO_SEARCH_FOR: ${{ github.REF }}
-        run: |
-          cd ./.github/workflows/scripts/releases/upload-release-artifacts
-          npm ci
-          node index.js

.github/workflows/linux_build_flatpak.yml

@@ -0,0 +1,121 @@
+name: Flatpak Build Steps
+
+on:
+  workflow_call:
+    inputs:
+      jobName:
+        required: true
+        type: string
+      os:
+        required: false
+        type: string
+        default: ubuntu-22.04
+      platform:
+        required: false
+        type: string
+        default: x64
+      compiler:
+        required: true
+        type: string
+      cmakeflags:
+        required: true
+        type: string
+      branch:
+        required: false
+        type: string
+        default: "stable"
+      publish:
+        required: false
+        type: boolean
+        default: false
+      patchesUrl:
+        required: false
+        type: string
+        default: https://github.com/PCSX2/pcsx2_patches/releases/latest/download
+      fetchTags:
+        required: false
+        type: boolean
+        default: false
+
+jobs:
+  build_linux:
+    name: ${{ inputs.jobName }}
+    runs-on: ${{ inputs.os }}
+    timeout-minutes: 60
+
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+
+      # Hackity hack. When running the workflow on a schedule, we don't have the tag,
+      # it doesn't fetch tags, therefore we don't get a version. So grab them manually.
+      # actions/checkout elides tags, fetch them primarily for releases
+      - name: Fetch tags
+        if: ${{ inputs.fetchTags }}
+        run: git fetch --tags --no-recurse-submodules
+
+      - name: Prepare Artifact Metadata
+        id: artifact-metadata
+        shell: bash
+        env:
+          OS: linux
+          BUILD_SYSTEM: flatpak
+          ARCH: ${{ inputs.platform }}
+          EVENT_NAME: ${{ github.event_name }}
+          PR_TITLE: ${{ github.event.pull_request.title }}
+          PR_NUM: ${{ github.event.pull_request.number }}
+          PR_SHA: ${{ github.event.pull_request.head.sha }}
+        run: ./.github/workflows/scripts/common/name-artifacts.sh
+
+      - name: Install Packages
+        env:
+          COMPILER: ${{ inputs.compiler }}
+        run: .github/workflows/scripts/linux/install-packages-flatpak.sh
+
+      - name: Download patches
+        run: |
+          cd bin/resources
+          aria2c -Z "${{ inputs.patchesUrl }}/patches.zip"
+
+      - name: Generate AppStream XML
+        run: |
+          ./.github/workflows/scripts/linux/generate-metainfo.sh .github/workflows/scripts/linux/flatpak/net.pcsx2.PCSX2.metainfo.xml
+          cat .github/workflows/scripts/linux/flatpak/net.pcsx2.PCSX2.metainfo.xml
+          flatpak run org.freedesktop.appstream-glib validate .github/workflows/scripts/linux/flatpak/net.pcsx2.PCSX2.metainfo.xml
+
+      - name: Build Flatpak
+        uses: flatpak/flatpak-github-actions/flatpak-builder@v6.1
+        with:
+          bundle: ${{ steps.artifact-metadata.outputs.artifact-name }}.flatpak
+          manifest-path: .github/workflows/scripts/linux/flatpak/net.pcsx2.PCSX2.json
+          arch: x86_64
+          build-bundle: true
+          verbose: true
+          mirror-screenshots-url: https://dl.flathub.org/repo/screenshots
+          branch: ${{ inputs.branch }}
+          cache: true
+          restore-cache: true
+          cache-key: ${{ inputs.os }} ${{ inputs.platform }} ${{ inputs.compiler }} flatpak ${{ hashFiles('.github/workflows/scripts/linux/flatpak/**/*.json') }}
+
+      - name: Commit screenshots to OSTree
+        run: |
+          ostree commit --repo=repo --canonical-permissions --branch=screenshots/x86_64 flatpak_app/screenshots
+
+      - name: Push to Flathub beta
+        if: inputs.publish == true && inputs.branch == 'beta'
+        uses: flatpak/flatpak-github-actions/flat-manager@v6.1
+        with:
+          flat-manager-url: https://hub.flathub.org/
+          repository: beta
+          token: ${{ secrets.FLATHUB_BETA_TOKEN }}
+
+      - name: Push to Flathub stable
+        if: inputs.publish == true && inputs.branch == 'stable'
+        uses: flatpak/flatpak-github-actions/flat-manager@v6.1
+        with:
+          flat-manager-url: https://hub.flathub.org/
+          repository: stable
+          token: ${{ secrets.FLATHUB_TOKEN }}
+

.github/workflows/linux_build_matrix.yml

@@ -0,0 +1,31 @@
+name: 🐧 Linux Builds
+
+on:
+  push:
+    branches-ignore:
+      - "l10n_master"
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build_linux_qt:
+    name: "AppImage"
+    if: github.repository != 'PCSX2/pcsx2' || github.event_name == 'pull_request'
+    uses: ./.github/workflows/linux_build_qt.yml
+    with:
+      jobName: "AppImage Build"
+      compiler: clang
+      cmakeflags: ""
+      buildAppImage: true
+    secrets: inherit
+  build_linux_flatpak:
+    name: "Flatpak"
+    if: github.repository != 'PCSX2/pcsx2' || github.event_name == 'pull_request'
+    uses: ./.github/workflows/linux_build_flatpak.yml
+    with:
+      jobName: "Flatpak Build"
+      compiler: clang
+      cmakeflags: ""
+      publish: false
+    secrets: inherit

.github/workflows/linux_build_qt.yml

@@ -0,0 +1,140 @@
+name: Linux Build Steps
+
+on:
+  workflow_call:
+    inputs:
+      jobName:
+        required: true
+        type: string
+      os:
+        required: false
+        type: string
+        default: ubuntu-22.04
+      platform:
+        required: false
+        type: string
+        default: x64
+      compiler:
+        required: true
+        type: string
+      cmakeflags:
+        required: true
+        type: string
+      buildAppImage:
+        required: false
+        type: boolean
+        default: false
+      detail:
+        required: false
+        type: string
+        default: ""
+      patchesUrl:
+        required: false
+        type: string
+        default: https://github.com/PCSX2/pcsx2_patches/releases/latest/download
+      fetchTags:
+        required: false
+        type: boolean
+        default: false
+
+jobs:
+  build_linux:
+    name: ${{ inputs.jobName }}
+    runs-on: ${{ inputs.os }}
+    # Set some sort of timeout in the event of run-away builds.  We are limited on concurrent jobs so, get rid of them.
+    timeout-minutes: 60
+    env:
+      CCACHE_BASEDIR: ${{ github.workspace }}
+      CCACHE_DIR: ${{ github.workspace }}/.ccache
+      CCACHE_COMPRESS: true
+      CCACHE_COMPRESSLEVEL: 9
+      CCACHE_MAXSIZE: 100M
+
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+
+      # actions/checkout elides tags, fetch them primarily for releases
+      - name: Fetch Tags
+        if: ${{ inputs.fetchTags }}
+        run: git fetch --tags --no-recurse-submodules
+
+      - name: Prepare Artifact Metadata
+        id: artifact-metadata
+        shell: bash
+        env:
+          OS: linux
+          ARCH: ${{ inputs.platform }}
+          EVENT_NAME: ${{ github.event_name }}
+          PR_TITLE: ${{ github.event.pull_request.title }}
+          PR_NUM: ${{ github.event.pull_request.number }}
+          PR_SHA: ${{ github.event.pull_request.head.sha }}
+        run: ./.github/workflows/scripts/common/name-artifacts.sh
+
+      # -- SETUP CCACHE - https://cristianadam.eu/20200113/speeding-up-c-plus-plus-github-actions-using-ccache/
+      - name: Prepare ccache timestamp
+        id: ccache_cache_timestamp
+        run: echo "timestamp=$(date -u "+%Y-%m-%d-%H;%M;%S")" >> $GITHUB_OUTPUT
+
+      - name: ccache cache files
+        uses: actions/cache@v3
+        with:
+          path: .ccache
+          key: ${{ inputs.os }} ${{ inputs.platform }} ${{ inputs.compiler }} ${{ inputs.detail }} ccache ${{ steps.ccache_cache_timestamp.outputs.timestamp }}
+          restore-keys: ${{ inputs.os }} ${{ inputs.platform }} ${{ inputs.compiler }} ${{ inputs.detail }} ccache
+
+      - name: Install Packages
+        env:
+          COMPILER: ${{ inputs.compiler }}
+        run: .github/workflows/scripts/linux/install-packages-qt.sh
+
+      - name: Cache Dependencies
+        id: cache-deps
+        uses: actions/cache@v3
+        with:
+          path: ~/deps
+          key: ${{ inputs.os }} ${{ inputs.platform }} deps ${{ hashFiles('.github/workflows/scripts/linux/build-dependencies-qt.sh') }}
+
+      - name: Build Dependencies
+        if: steps.cache-deps.outputs.cache-hit != 'true'
+        run: .github/workflows/scripts/linux/build-dependencies-qt.sh
+
+      - name: Download patches
+        run: |
+          cd bin/resources
+          aria2c -Z "${{ inputs.patchesUrl }}/patches.zip"
+
+      - name: Generate CMake
+        env:
+          COMPILER: ${{ inputs.compiler }}
+          ADDITIONAL_CMAKE_ARGS: ${{ inputs.cmakeflags }}
+          CLANG_PATH: /usr/bin/clang-16
+          CLANGXX_PATH: /usr/bin/clang++-16
+        run: |
+          DEPS_PREFIX="$HOME/deps" .github/workflows/scripts/linux/generate-cmake-qt.sh
+
+      - name: Build PCSX2
+        working-directory: build
+        run: ../.github/workflows/scripts/linux/compile.sh
+
+      - name: Run Tests
+        working-directory: ./build
+        run: ninja unittests
+
+      - name: Package AppImage
+        if: inputs.buildAppImage == true
+        env:
+          NAME: ${{ steps.artifact-metadata.outputs.artifact-name }}
+        run: |
+          .github/workflows/scripts/linux/appimage-qt.sh "$(realpath .)" "$(realpath ./build)" "$HOME/deps" "$NAME"
+          mkdir -p "$GITHUB_WORKSPACE"/ci-artifacts/
+          mv "${NAME}.AppImage" "$GITHUB_WORKSPACE"/ci-artifacts/
+
+      - name: Upload artifact
+        if: inputs.buildAppImage == true
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ steps.artifact-metadata.outputs.artifact-name }}
+          path: ci-artifacts

.github/workflows/macos-workflow.yml

@@ -1,117 +0,0 @@
-name: 🍎 MacOS Builds
-
-# Controls when the action will run. Triggers the workflow on push or pull request
-# events but only for the master branch
-on:
-  push:
-    branches:
-      - master
-    paths-ignore:
-      - '**/*.md'
-      - '**/*.bat'
-      - '**/*.cmd'
-      - '**/*.props'
-      - '**/*.sln'
-      - '.clang-format'
-      - '.codacy.yaml'
-      - '.github/*'
-      - '.github/workflows/lint-gamedb.yml'
-      - '.github/workflows/linux-workflow.yml'
-      - '.github/workflows/pr-triage.yml'
-      - '.github/workflows/scripts/windows/**'
-      - '.github/workflows/scripts/validation/**'
-      - '.github/workflows/windows-workflow.yml'
-      - '.gitignore'
-      - 'bin/PCSX2_keys.ini.default'
-      - 'build.sh'
-      - 'buildbot.xml'
-      - 'pcsx2/CDVD/Windows/**'
-      - 'pcsx2/DEV9/Win32/**'
-      - 'pcsx2/PAD/Windows/**'
-      - 'pcsx2/SPU2/Windows/**'
-      - 'pcsx2/USB/Win32/**'
-      - 'pcsx2/windows/**'
-  pull_request:
-    branches:
-      - master
-    paths-ignore:
-      - '**/*.md'
-      - '**/*.bat'
-      - '**/*.cmd'
-      - '**/*.props'
-      - '**/*.sln'
-      - '.clang-format'
-      - '.codacy.yaml'
-      - '.github/*'
-      - '.github/workflows/lint-gamedb.yml'
-      - '.github/workflows/linux-workflow.yml'
-      - '.github/workflows/pr-triage.yml'
-      - '.github/workflows/scripts/windows/**'
-      - '.github/workflows/scripts/validation/**'
-      - '.github/workflows/windows-workflow.yml'
-      - '.gitignore'
-      - 'bin/PCSX2_keys.ini.default'
-      - 'build.sh'
-      - 'buildbot.xml'
-      - 'pcsx2/CDVD/Windows/**'
-      - 'pcsx2/DEV9/Win32/**'
-      - 'pcsx2/PAD/Windows/**'
-      - 'pcsx2/SPU2/Windows/**'
-      - 'pcsx2/USB/Win32/**'
-      - 'pcsx2/windows/**'
-
-jobs:
-  build:
-    strategy:
-      # Prevent one build from failing everything (although maybe those should be included as experimental builds instead)
-      fail-fast: false
-      matrix:
-        os: [macos-11.0]
-        platform: [x64]
-        experimental: [false]
-
-    runs-on: ${{ matrix.os }}
-    continue-on-error: ${{ matrix.experimental }}
-    # Set some sort of timeout in the event of run-away builds.  We are limited on concurrent jobs so, get rid of them.
-    timeout-minutes: 30
-
-    steps:
-      # NOTE - useful for debugging
-      # - name: Dump GitHub context
-      #   env:
-      #     GITHUB_CONTEXT: ${{ toJson(github) }}
-      #   run: |
-      #     echo "$GITHUB_CONTEXT"
-      #     echo ${{ github.event.pull_request.title }}
-
-      - name: Checkout Repository
-        uses: actions/checkout@v3
-
-      - name: Checkout Submodules
-        run: git submodule update --init --recursive -j $(getconf _NPROCESSORS_ONLN)
-
-      - name: Install Packages
-        env:
-          PLATFORM: ${{ matrix.platform }}
-          HOMEBREW_NO_INSTALL_CLEANUP: 1
-          HOMEBREW_NO_ANALYTICS: 1
-        run: |
-          # To save time, only brew update if running the install without it fails
-          function do-install() {
-            brew install sound-touch portaudio wxwidgets sdl2 libsamplerate
-          }
-          if ! do-install; then
-            brew update
-            do-install
-          fi
-
-      - name: Generate CMake Files
-        run: cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_BUILD_PO=FALSE -DLTO_PCSX2_CORE=ON -B build .
-
-      - name: Build PCSX2
-        working-directory: build
-        run: make -j$(getconf _NPROCESSORS_ONLN) # macOS doesn't use make install
-
-      - name: Run Tests
-        working-directory: build
-        run: make -j$(getconf _NPROCESSORS_ONLN) unittests

.github/workflows/macos_build.yml

@@ -0,0 +1,156 @@
+name: MacOS Build Steps
+
+on:
+  workflow_call:
+    inputs:
+      jobName:
+        required: true
+        type: string
+      os:
+        required: false
+        type: string
+        default: macos-13
+      patchesUrl:
+        required: false
+        type: string
+        default: https://github.com/PCSX2/pcsx2_patches/releases/latest/download
+      fetchTags:
+        required: false
+        type: boolean
+        default: false
+
+jobs:
+  build_macos:
+    name: ${{ inputs.jobName }}
+    runs-on: ${{ inputs.os }}
+    # Set some sort of timeout in the event of run-away builds.  We are limited on concurrent jobs so, get rid of them.
+    timeout-minutes: 90
+    env:
+      POWERSHELL_TELEMETRY_OPTOUT: 1
+      CCACHE_BASEDIR: ${{ github.workspace }}
+      CCACHE_DIR: ${{ github.workspace }}/.ccache
+      CCACHE_COMPRESS: true
+      CCACHE_COMPRESSLEVEL: 9
+      CCACHE_MAXSIZE: 100M
+
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+
+      # actions/checkout elides tags, fetch them primarily for releases
+      - name: Fetch Tags
+        if: ${{ inputs.fetchTags }}
+        run: git fetch --tags --no-recurse-submodules
+
+      - name: Use Xcode 14.3.1
+        run: sudo xcode-select -s /Applications/Xcode_14.3.1.app
+
+      - name: Prepare Artifact Metadata
+        id: artifact-metadata
+        shell: bash
+        env:
+          OS: macos
+          EVENT_NAME: ${{ github.event_name }}
+          PR_TITLE: ${{ github.event.pull_request.title }}
+          PR_NUM: ${{ github.event.pull_request.number }}
+          PR_SHA: ${{ github.event.pull_request.head.sha }}
+        run: ./.github/workflows/scripts/common/name-artifacts.sh
+
+      - name: Install Packages
+        env:
+          PLATFORM: "x64"
+          HOMEBREW_NO_INSTALL_CLEANUP: 1
+          HOMEBREW_NO_ANALYTICS: 1
+        run: |
+          brew unlink libjpeg || true # Conflicts with our self-built dependencies
+          brew unlink libpng || true
+          # Unlike other packages, brew's MoltenVK build uses MoltenVK's minimum macOS version of 10.13 so we can use it
+          if ! brew install molten-vk ccache nasm; then
+            brew update
+            brew install molten-vk ccache nasm
+          fi
+
+      - name: Cache Dependencies
+        id: cache-deps
+        uses: actions/cache@v3
+        with:
+          path: ~/deps
+          key: ${{ inputs.os }} deps ${{ hashFiles('.github/workflows/scripts/macos/build-dependencies.sh') }}
+
+      - name: Build Dependencies
+        if: steps.cache-deps.outputs.cache-hit != 'true'
+        run: .github/workflows/scripts/macos/build-dependencies.sh
+
+      - name: Download patches
+        run: |
+          cd bin/resources
+          aria2c -Z "${{ inputs.patchesUrl }}/patches.zip"
+
+      # -- SETUP CCACHE - https://cristianadam.eu/20200113/speeding-up-c-plus-plus-github-actions-using-ccache/
+      - name: Prepare ccache timestamp
+        id: ccache_cache_timestamp
+        run: echo "timestamp=$(date -u "+%Y-%m-%d-%H;%M;%S")" >> $GITHUB_OUTPUT
+
+      - name: Cache ccache cache
+        uses: actions/cache@v3
+        with:
+          path: .ccache
+          key: ${{ inputs.os }} ccache ${{ steps.ccache_cache_timestamp.outputs.timestamp }}
+          restore-keys: ${{ inputs.os }} ccache
+
+      - name: Generate CMake Files
+        run: |
+          cmake -DCMAKE_PREFIX_PATH="$HOME/deps" \
+                -DCMAKE_BUILD_TYPE=Release \
+                -DUSE_OPENGL=OFF \
+                -DDISABLE_ADVANCE_SIMD=ON \
+                -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON \
+                -DUSE_SYSTEM_LIBS=OFF \
+                -DUSE_SYSTEM_SDL2=ON \
+                -DUSE_LINKED_FFMPEG=ON \
+                -DCMAKE_C_COMPILER_LAUNCHER=ccache \
+                -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+                -DCMAKE_DISABLE_PRECOMPILE_HEADERS=ON \
+                -B build .
+
+      - name: Build PCSX2
+        working-directory: build
+        run: |
+          ccache -p
+          ccache -s
+          ccache -z
+          make -j$(getconf _NPROCESSORS_ONLN) # macOS doesn't use make install
+          ccache -s
+          # Ensure there's no global constructors in multi-isa files
+          for dir in */CMakeFiles/GS-{avx,avx2}.dir; do
+            if find "$dir" -name "*.o" | xargs nm | grep _GLOBAL_; then
+              echo "::error::Multi-isa files must not have global constructors!"
+              exit 1
+            fi
+          done
+
+      - name: Run Tests
+        working-directory: build
+        run: make -j$(getconf _NPROCESSORS_ONLN) unittests
+
+      - name: Prepare Build Artifacts
+        run: |
+          cp /usr/local/lib/libMoltenVK.dylib build/pcsx2*/PCSX2.app/Contents/Frameworks/
+          TAG="$(git tag --points-at HEAD)"
+          if [ -z "$TAG" ]; then
+            APPNAME="${{ steps.artifact-metadata.outputs.artifact-name }}"
+          else
+            APPNAME="PCSX2-$TAG"
+          fi
+          mv build/pcsx2*/PCSX2.app "$APPNAME.app"
+          tar --options xz:compression-level=9 -cvJf "${{ steps.artifact-metadata.outputs.artifact-name }}.tar.xz" "$APPNAME.app"
+          mkdir ci-artifacts
+          cp "${{ steps.artifact-metadata.outputs.artifact-name }}.tar.xz" ci-artifacts/macOS.tar.xz
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ steps.artifact-metadata.outputs.artifact-name }}
+          path: "*.tar.xz"

.github/workflows/macos_build_matrix.yml

@@ -0,0 +1,18 @@
+name: 🍎 MacOS Builds
+
+on:
+  push:
+    branches-ignore:
+      - "l10n_master"
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build_macos_qt:
+    name: "Defaults"
+    if: github.repository != 'PCSX2/pcsx2' || github.event_name == 'pull_request'
+    uses: ./.github/workflows/macos_build.yml
+    with:
+      jobName: "MacOS Build"
+    secrets: inherit

.github/workflows/release-push-tag-and-draft.yml

@@ -1,62 +0,0 @@
-# Whenever a commit is pushed to master (ideally via a pull-request!)
-# this action will create the next release, which means:
-# 1. tag master with the proper version
-# 2. create a new draft release (pre-released if a nightly build)
-# 3. add release notes
-
-name: 🏭 Create Release
-
-on:
-  push:
-    branches:
-      - master
-  # TODO - future work
-  # workflow_dispatch:
-  #   inputs:
-  #     isStable:
-  #       description: 'Should it be a stable release?'
-  #       required: true
-  #       default: 'false'
-  #     versionTag:
-  #       description: 'The version to tag with'
-  #       required: true
-
-jobs:
-  cut-release:
-    if: github.repository == 'PCSX2/pcsx2'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-
-      # Docs - https://github.com/mathieudutour/github-tag-action
-      # Workflows cannot trigger other workflows implicitly
-      # - https://github.community/t/github-actions-workflow-not-triggering-with-tag-push/17053/7
-      - name: Bump Version and Push Tag
-        id: tag_version
-        uses: mathieudutour/github-tag-action@v6.0
-        with:
-          github_token: ${{ secrets.BOT_PAT }}
-          tag_prefix: v
-          default_bump: patch
-
-      # Generate the Release Notes
-      - name: Generate Release Notes
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          COMMIT_SHA: ${{ github.SHA }}
-        run: |
-          cd ./.github/workflows/scripts/releases/generate-release-notes
-          npm ci
-          node index.js
-          mv ./release-notes.md ${GITHUB_WORKSPACE}/release-notes.md
-          ls
-
-      # Docs - https://github.com/softprops/action-gh-release
-      - name: Create a GitHub Release
-        uses: softprops/action-gh-release@v1
-        if: steps.tag_version.outputs.new_tag
-        with:
-          body_path: ./release-notes.md
-          draft: true
-          prerelease: true
-          tag_name: ${{ steps.tag_version.outputs.new_tag }}

.github/workflows/release_cut_new.yml

@@ -0,0 +1,186 @@
+# Whenever a commit is pushed to master (ideally via a pull-request!)
+# this action will create the next release, which means:
+# 1. tag master with the proper version
+# 2. create a new draft release (pre-released if a nightly build)
+# 3. add release notes
+
+name: 🏭 Create Release
+
+on:
+  push:
+    branches:
+      - master
+  # TODO - future work
+  # workflow_dispatch:
+  #   inputs:
+  #     isStable:
+  #       description: 'Should it be a stable release?'
+  #       required: true
+  #       default: 'false'
+  #     versionTag:
+  #       description: 'The version to tag with'
+  #       required: true
+
+permissions:
+  contents: write
+
+jobs:
+  cut-release:
+    if: github.repository == 'PCSX2/pcsx2'
+    runs-on: ubuntu-latest
+    name: "Create Tag and Release"
+    steps:
+      - uses: actions/checkout@v3
+
+      # Docs - https://github.com/mathieudutour/github-tag-action
+      - name: Bump Version and Push Tag
+        id: tag_version
+        uses: mathieudutour/github-tag-action@v6.1
+        with:
+          github_token: ${{ github.token }}
+          tag_prefix: v
+          default_bump: patch
+
+      # TODO - we could do this and remove the node.js script, but auto-generated notes only work
+      # with PRs -- not commits (determine how much we care).
+      # - name: Create Draft Release
+      #   run: |
+      #     echo "Creating release with tag - ${{ steps.tag_version.outputs.new_tag }}"
+      #     gh release create ${{ steps.tag_version.outputs.new_tag }} --draft --generate-notes -title ${{ steps.tag_version.outputs.new_tag }}
+
+      - name: Generate Release Notes
+        env:
+          OWNER: PCSX2
+          REPO: pcsx2
+          GITHUB_TOKEN: ${{ github.token }}
+          COMMIT_SHA: ${{ github.SHA }}
+        run: |
+          cd ./.github/workflows/scripts/releases/generate-release-notes
+          npm ci
+          node index.js
+          mv ./release-notes.md ${GITHUB_WORKSPACE}/release-notes.md
+
+      - name: Create a GitHub Release
+        uses: softprops/action-gh-release@v1
+        if: steps.tag_version.outputs.new_tag
+        with:
+          body_path: ./release-notes.md
+          draft: true
+          prerelease: true
+          tag_name: ${{ steps.tag_version.outputs.new_tag }}
+
+  # Build Everything
+  # Linux
+  build_linux_qt:
+    if: github.repository == 'PCSX2/pcsx2'
+    needs:
+      - cut-release
+    name: "Linux"
+    uses: ./.github/workflows/linux_build_qt.yml
+    with:
+      jobName: "AppImage Build"
+      compiler: clang
+      cmakeflags: ""
+      buildAppImage: true
+      fetchTags: true
+    secrets: inherit
+
+  build_linux_flatpak:
+    if: github.repository == 'PCSX2/pcsx2'
+    needs:
+      - cut-release
+    name: "Linux"
+    uses: ./.github/workflows/linux_build_flatpak.yml
+    with:
+      jobName: "Flatpak Build"
+      compiler: clang
+      cmakeflags: ""
+      branch: "stable"
+      publish: false
+      fetchTags: true
+    secrets: inherit
+
+  # Windows
+  build_windows_qt:
+    if: github.repository == 'PCSX2/pcsx2'
+    needs:
+      - cut-release
+    name: "Windows"
+    uses: ./.github/workflows/windows_build_qt.yml
+    with:
+      jobName: "Windows Build"
+      configuration: CMake
+      buildSystem: cmake
+      cmakeFlags: -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl
+      fetchTags: true
+    secrets: inherit
+
+  # MacOS
+  build_macos_qt:
+    if: github.repository == 'PCSX2/pcsx2'
+    needs:
+      - cut-release
+    name: "MacOS"
+    uses: ./.github/workflows/macos_build.yml
+    with:
+      jobName: "MacOS Build"
+      fetchTags: true
+    secrets: inherit
+
+  # Upload the Artifacts
+  upload_artifacts:
+    if: github.repository == 'PCSX2/pcsx2'
+    needs:
+      - build_linux_flatpak
+      - build_linux_qt
+      - build_windows_qt
+      - build_macos_qt
+    name: "Upload Artifacts"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      # actions/checkout elides tags, fetch them primarily for releases
+      - name: Fetch Tags
+        run: git fetch --tags --no-recurse-submodules
+
+      - name: Prepare Artifact Folder
+        run: mkdir ./ci-artifacts/
+
+      - uses: actions/download-artifact@v3
+        name: Download all Artifacts
+        with:
+          path: ./ci-artifacts/
+
+      - name: Display structure of downloaded files
+        run: ls ./ci-artifacts/
+
+      # Prepare artifacts, they are all zips from github!
+      - name: Prepare Artifacts
+        working-directory: ./ci-artifacts/
+        run: for d in *windows*/; do 7z a "${d}asset.7z" ./$d/*; done
+
+      # Artifact Naming:
+      # MacOS: PCSX2-<tag>-macOS-[additional hyphen seperated tags]
+      # Windows|Linux: PCSX2-<tag>-<windows|linux>-<32bit|64bit>--[additional hyphen seperated tags]
+      - name: Name and Upload the Release Assets
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+          SCAN_DIR: ${{ github.WORKSPACE }}/ci-artifacts
+          OUT_DIR: ${{ github.WORKSPACE }}/ci-artifacts/out
+        run: |
+          TAG_VAL=$(git tag --points-at HEAD)
+          echo "TAG_VAL=${TAG_VAL}"
+          gh release list --repo PCSX2/pcsx2
+          mkdir -p ${{ github.WORKSPACE }}/ci-artifacts/out
+          TAG_VAL=${TAG_VAL} python ./.github/workflows/scripts/releases/rename-release-assets.py
+          ls ${{ github.WORKSPACE }}/ci-artifacts/out
+          gh release upload "${TAG_VAL}" ${{ github.WORKSPACE }}/ci-artifacts/out/*  --repo PCSX2/pcsx2 --clobber
+
+      - name: Publish Release
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        run: |
+          TAG_VAL=$(git tag --points-at HEAD)
+          echo "TAG_VAL=${TAG_VAL}"
+          gh release edit ${TAG_VAL} --draft=false --repo PCSX2/pcsx2

.github/workflows/scripts/common/name-artifacts.sh

@@ -0,0 +1,57 @@
+#!/bin/bash
+
+# Artifact Naming Scheme:
+# PCSX2-<OS>-Qt-[ARCH]-[SIMD]-[pr\[PR_NUM\]]-[title|sha\[SHA|PR_TITLE\]
+# -- limited to 200 chars
+# Outputs:
+# - artifact-name
+
+# Inputs as env-vars
+# OS
+# BUILD_SYSTEM
+# ARCH
+# SIMD
+# EVENT_NAME
+# PR_TITLE
+# PR_NUM
+# PR_SHA
+
+NAME=""
+
+if [ "${OS}" == "macos" ]; then
+  # MacOS has combined binaries for x64 and ARM64.
+  NAME="PCSX2-${OS}-Qt"
+elif [[ ("${OS}" == "windows" && "$BUILD_SYSTEM" != "cmake") ]]; then
+  NAME="PCSX2-${OS}-Qt-${ARCH}-${SIMD}"
+else
+  NAME="PCSX2-${OS}-Qt-${ARCH}"
+fi
+
+# Add cmake if used to differentate it from msbuild builds
+# Else the two artifacts will have the same name and the files will be merged
+if [[ ! -z "${BUILD_SYSTEM}" ]]; then
+  if [[ "${BUILD_SYSTEM}" == "cmake" ]] || [[ "${BUILD_SYSTEM}" == "flatpak" ]]; then
+    NAME="${NAME}-${BUILD_SYSTEM}"
+  fi
+fi
+
+# Add PR / Commit Metadata
+if [ "$EVENT_NAME" == "pull_request" ]; then
+  PR_SHA=$(git rev-parse --short "${PR_SHA}")
+  if [ ! -z "${PR_NUM}" ]; then
+    NAME="${NAME}-pr[${PR_NUM}]"
+  fi
+  NAME="${NAME}-sha[${PR_SHA}]"
+  if [ ! -z "${PR_TITLE}" ]; then
+    PR_TITLE=$(echo "${PR_TITLE}" | tr -cd '[a-zA-Z0-9[:space:]]_-')
+    NAME="${NAME}-title[${PR_TITLE}"
+  fi
+else
+  SHA=$(git rev-parse --short "$GITHUB_SHA")
+  NAME="${NAME}-sha[${SHA}"
+fi
+
+# Trim the Name
+NAME=$(printf "%.199s]" "$NAME")
+echo "${NAME}"
+echo "artifact-name=${NAME}" >> "$GITHUB_OUTPUT"

.github/workflows/scripts/common/update_base_translation.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+SCRIPTDIR=$(dirname "${BASH_SOURCE[0]}")
+source "$SCRIPTDIR/../linux/functions.sh"
+
+set -e
+
+# While we use custom Qt builds for our releases, the Qt6 package will be good enough
+# for just updating translations. Saves building it for this action alone.
+retry_command sudo apt-get -y install qt6-l10n-tools
+
+PATH=/usr/lib/qt6/bin:$PATH "$SCRIPTDIR/../../../../pcsx2-qt/Translations/update_en_translation.sh"

.github/workflows/scripts/linux/AppRun

@@ -1,3 +0,0 @@
-#!/bin/bash
-
-$APPDIR/AppRun-patched

.github/workflows/scripts/linux/app-variables.sh

@@ -1,10 +0,0 @@
-#!/bin/bash
-
-export LD_LIBRARY_PATH="$APPDIR/usr/lib:$LD_LIBRARY_PATH"
-export BINARY_NAME=$(basename "$ARGV0")
-if [[ ! -e "$PWD/$BINARY_NAME.config" ]]; then
-        mkdir "$PWD/$BINARY_NAME.config"
-fi       
-export XDG_CONFIG_HOME="$PWD/$BINARY_NAME.config"
-
-mkdir -p "$HOME"/.local/share/icons/hicolor/scalable/apps && cp "$APPDIR"/PCSX2.png "$HOME"/.local/share/icons/hicolor/scalable/apps

.github/workflows/scripts/linux/appimage-qt.sh

@@ -0,0 +1,157 @@
+#!/usr/bin/env bash
+
+# This is free and unencumbered software released into the public domain.
+#
+# Anyone is free to copy, modify, publish, use, compile, sell, or
+# distribute this software, either in source code form or as a compiled
+# binary, for any purpose, commercial or non-commercial, and by any
+# means.
+#
+# In jurisdictions that recognize copyright laws, the author or authors
+# of this software dedicate any and all copyright interest in the
+# software to the public domain. We make this dedication for the benefit
+# of the public at large and to the detriment of our heirs and
+# successors. We intend this dedication to be an overt act of
+# relinquishment in perpetuity of all present and future rights to this
+# software under copyright law.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+#
+# For more information, please refer to <http://unlicense.org/>
+
+SCRIPTDIR=$(dirname "${BASH_SOURCE[0]}")
+source "$SCRIPTDIR/functions.sh"
+
+if [ "$#" -ne 4 ]; then
+    echo "Syntax: $0 <path to pcsx2 directory> <path to build directory> <deps prefix> <output name>"
+    exit 1
+fi
+
+PCSX2DIR=$1
+BUILDDIR=$2
+DEPSDIR=$3
+NAME=$4
+
+BINARY=pcsx2-qt
+APPDIRNAME=PCSX2.AppDir
+STRIP=strip
+
+declare -a MANUAL_QT_LIBS=(
+	"libQt6WaylandEglClientHwIntegration.so.6"
+)
+
+declare -a MANUAL_QT_PLUGINS=(
+	"wayland-decoration-client"
+	"wayland-graphics-integration-client"
+	"wayland-shell-integration"
+)
+
+set -e
+
+LINUXDEPLOY=./linuxdeploy-x86_64.AppImage
+LINUXDEPLOY_PLUGIN_QT=./linuxdeploy-plugin-qt-x86_64.AppImage
+APPIMAGETOOL=./appimagetool-x86_64.AppImage
+PATCHELF=patchelf
+
+if [ ! -f "$LINUXDEPLOY" ]; then
+	retry_command wget -O "$LINUXDEPLOY" https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage
+	chmod +x "$LINUXDEPLOY"
+fi
+
+if [ ! -f "$LINUXDEPLOY_PLUGIN_QT" ]; then
+	retry_command wget -O "$LINUXDEPLOY_PLUGIN_QT" https://github.com/linuxdeploy/linuxdeploy-plugin-qt/releases/download/continuous/linuxdeploy-plugin-qt-x86_64.AppImage
+	chmod +x "$LINUXDEPLOY_PLUGIN_QT"
+fi
+
+if [ ! -f "$APPIMAGETOOL" ]; then
+	retry_command wget -O "$APPIMAGETOOL" https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage
+	chmod +x "$APPIMAGETOOL"
+fi
+
+OUTDIR=$(realpath "./$APPDIRNAME")
+SCRIPTDIR=$(dirname "${BASH_SOURCE[0]}")
+rm -fr "$OUTDIR"
+
+# Why the nastyness? linuxdeploy strips our main binary, and there's no option to turn it off.
+# It also doesn't strip the Qt libs. We can't strip them after running linuxdeploy, because
+# patchelf corrupts the libraries (but they still work), but patchelf+strip makes them crash
+# on load. So, make a backup copy, strip the original (since that's where linuxdeploy finds
+# the libs to copy), then swap them back after we're done.
+# Isn't Linux packaging amazing?
+
+rm -fr "$DEPSDIR.bak"
+cp -a "$DEPSDIR" "$DEPSDIR.bak"
+IFS="
+"
+for i in $(find "$DEPSDIR" -iname '*.so'); do
+  echo "Stripping deps library ${i}"
+  strip "$i"
+done
+
+echo "Copying desktop file..."
+cp "$PCSX2DIR/.github/workflows/scripts/linux/pcsx2-qt.desktop" "net.pcsx2.PCSX2.desktop"
+cp "$PCSX2DIR/bin/resources/icons/AppIconLarge.png" "PCSX2.png"
+
+echo "Running linuxdeploy to create AppDir..."
+EXTRA_QT_PLUGINS="core;gui;network;svg;waylandclient;widgets;xcbqpa" \
+EXTRA_PLATFORM_PLUGINS="libqwayland-egl.so;libqwayland-generic.so" \
+QMAKE="$DEPSDIR/bin/qmake" \
+NO_STRIP="1" \
+$LINUXDEPLOY --plugin qt --appdir="$OUTDIR" --executable="$BUILDDIR/bin/pcsx2-qt" \
+--desktop-file="net.pcsx2.PCSX2.desktop" --icon-file="PCSX2.png"
+
+echo "Copying resources into AppDir..."
+cp -a "$BUILDDIR/bin/resources" "$OUTDIR/usr/bin"
+
+# LinuxDeploy's Qt plugin doesn't include Wayland support. So manually copy in the additional Wayland libraries.
+echo "Copying Qt Wayland libraries..."
+for lib in "${MANUAL_QT_LIBS[@]}"; do
+	srcpath="$DEPSDIR/lib/$lib"
+	dstpath="$OUTDIR/usr/lib/$lib"
+	echo "  $srcpath -> $dstpath"
+	cp "$srcpath" "$dstpath"
+	$PATCHELF --set-rpath '$ORIGIN' "$dstpath"
+done
+
+# .. and plugins.
+echo "Copying Qt Wayland plugins..."
+for GROUP in "${MANUAL_QT_PLUGINS[@]}"; do
+	srcpath="$DEPSDIR/plugins/$GROUP"
+	dstpath="$OUTDIR/usr/plugins/$GROUP"
+	echo "  $srcpath -> $dstpath"
+	mkdir -p "$dstpath"
+
+	for srcsopath in $(find "$DEPSDIR/plugins/$GROUP" -iname '*.so'); do
+		# This is ../../ because it's usually plugins/group/name.so
+		soname=$(basename "$srcsopath")
+		dstsopath="$dstpath/$soname"
+		echo "    $srcsopath -> $dstsopath"
+		cp "$srcsopath" "$dstsopath"
+		$PATCHELF --set-rpath '$ORIGIN/../../lib:$ORIGIN' "$dstsopath"
+	done
+done
+
+# Restore unstripped deps (for cache).
+rm -fr "$DEPSDIR"
+mv "$DEPSDIR.bak" "$DEPSDIR"
+
+# Fix up translations.
+rm -fr "$OUTDIR/usr/bin/translations"
+mv "$OUTDIR/usr/translations" "$OUTDIR/usr/bin"
+cp -a "$BUILDDIR/bin/translations" "$OUTDIR/usr/bin"
+
+# Generate AppStream meta-info.
+echo "Generating AppStream metainfo..."
+mkdir -p "$OUTDIR/usr/share/metainfo"
+"$SCRIPTDIR/generate-metainfo.sh" "$OUTDIR/usr/share/metainfo/net.pcsx2.PCSX2.appdata.xml"
+
+echo "Generating AppImage..."
+rm -f "$NAME.AppImage"
+$APPIMAGETOOL -v "$OUTDIR" "$NAME.AppImage"
+

.github/workflows/scripts/linux/appimage.sh

@@ -1,59 +0,0 @@
-#!/bin/bash
-
-set -ex
-
-echo "${PLATFORM}"
-if [ "${PLATFORM}" == "x86" ]; then
-  APPARCH="i686"
-  ARCH="i386"
-  LIBARCH="i386-linux-gnu"
-else
-  APPARCH="x86_64"
-  ARCH="x86_64"
-  LIBARCH="x86_64-linux-gnu"
-fi
-cd /tmp
-curl -sSfLO "https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-$ARCH.AppImage"
-chmod a+x linuxdeploy*.AppImage
-./linuxdeploy-"$ARCH".AppImage --appimage-extract
-curl -sSfL "https://raw.githubusercontent.com/linuxdeploy/linuxdeploy-plugin-gtk/master/linuxdeploy-plugin-gtk.sh" -o /tmp/squashfs-root/usr/bin/linuxdeploy-plugin-gtk.sh
-chmod a+x /tmp/squashfs-root/usr/bin/linuxdeploy-plugin-gtk.sh
-mv /tmp/squashfs-root/usr/bin/patchelf /tmp/squashfs-root/usr/bin/patchelf.orig
-sudo cp /usr/local/bin/patchelf /tmp/squashfs-root/usr/bin/patchelf
-cd "$GITHUB_WORKSPACE"
-ninja -C build install
-cp ./pcsx2/gui/Resources/AppIcon64.png ./squashfs-root/PCSX2.png
-cp ./linux_various/PCSX2.desktop.in ./squashfs-root/PCSX2.desktop 
-sed -i -e 's|Categories=@PCSX2_MENU_CATEGORIES@|Categories=Game;Emulator;|g' ./squashfs-root/PCSX2.desktop
-sed -i -e 's|__GL_THREADED_OPTIMIZATIONS=1|__GL_THREADED_OPTIMIZATIONS=0|g' ./squashfs-root/PCSX2.desktop
-curl -sSfL "https://github.com/AppImage/AppImageKit/releases/download/continuous/runtime-$APPARCH" -o ./squashfs-root/runtime
-mkdir -p squashfs-root/usr/share/applications && cp ./squashfs-root/PCSX2.desktop ./squashfs-root/usr/share/applications
-mkdir -p squashfs-root/usr/share/icons && cp ./squashfs-root/PCSX2.png ./squashfs-root/usr/share/icons
-mkdir -p squashfs-root/usr/share/icons/hicolor/scalable/apps && cp ./squashfs-root/PCSX2.png ./squashfs-root/usr/share/icons/hicolor/scalable/apps
-mkdir -p squashfs-root/usr/share/pixmaps && cp ./squashfs-root/PCSX2.png ./squashfs-root/usr/share/pixmaps
-mkdir -p squashfs-root/usr/lib/
-mkdir -p squashfs-root/usr/optional/libstdc++
-mkdir -p squashfs-root/usr/optional/libgcc_s
-cp ./.github/workflows/scripts/linux/AppRun "$GITHUB_WORKSPACE"/squashfs-root/AppRun
-curl -sSfL "https://github.com/darealshinji/AppImageKit-checkrt/releases/download/continuous/AppRun-patched-$APPARCH" -o "$GITHUB_WORKSPACE"/squashfs-root/AppRun-patched
-curl -sSfL "https://github.com/darealshinji/AppImageKit-checkrt/releases/download/continuous/exec-$APPARCH.so" -o "$GITHUB_WORKSPACE"/squashfs-root/usr/optional/exec.so
-chmod a+x ./squashfs-root/AppRun
-chmod a+x ./squashfs-root/runtime
-chmod a+x ./squashfs-root/AppRun-patched
-chmod a+x ./squashfs-root/usr/optional/exec.so
-echo "$name" > "$GITHUB_WORKSPACE"/squashfs-root/version.txt
-mkdir -p "$GITHUB_WORKSPACE"/squashfs-root/apprun-hooks
-cp /usr/lib/$LIBARCH/libthai.so.0 "$GITHUB_WORKSPACE"/squashfs-root/usr/lib/
-cp --dereference /usr/lib/"$LIBARCH"/libstdc++.so.6 "$GITHUB_WORKSPACE"/squashfs-root/usr/optional/libstdc++/libstdc++.so.6
-cp --dereference /lib/"$LIBARCH"/libgcc_s.so.1 "$GITHUB_WORKSPACE"/squashfs-root/usr/optional/libgcc_s/libgcc_s.so.1
-chmod +x .github/workflows/scripts/linux/app-variables.sh
-cp .github/workflows/scripts/linux/app-variables.sh "$GITHUB_WORKSPACE"/squashfs-root/apprun-hooks
-export UPD_INFO="gh-releases-zsync|PCSX2|pcsx2|latest|$name.AppImage.zsync"
-export OUTPUT="$name.AppImage"
-/tmp/squashfs-root/AppRun --appdir="$GITHUB_WORKSPACE"/squashfs-root/ --plugin gtk -d "$GITHUB_WORKSPACE"/squashfs-root/PCSX2.desktop -i "$GITHUB_WORKSPACE"/squashfs-root/PCSX2.png --output appimage
-mkdir -p "$GITHUB_WORKSPACE"/ci-artifacts/
-ls -al .
-mv "$name.AppImage" "$GITHUB_WORKSPACE"/ci-artifacts # && mv "$name.AppImage.zsync" "$GITHUB_WORKSPACE"/ci-artifacts
-chmod -R 777 ./ci-artifacts
-cd ./ci-artifacts
-ls -al .

.github/workflows/scripts/linux/build-dependencies-qt.sh

@@ -0,0 +1,159 @@
+#!/usr/bin/env bash
+
+set -e
+
+INSTALLDIR="$HOME/deps"
+NPROCS="$(getconf _NPROCESSORS_ONLN)"
+SDL=SDL2-2.28.1
+QT=6.5.2
+LIBBACKTRACE=ad106d5fdd5d960bd33fae1c48a351af567fd075
+
+mkdir -p deps-build
+cd deps-build
+
+cat > SHASUMS <<EOF
+4977ceba5c0054dbe6c2f114641aced43ce3bf2b41ea64b6a372d6ba129cb15d  $SDL.tar.gz
+fd6f417fe9e3a071cf1424a5152d926a34c4a3c5070745470be6cf12a404ed79  $LIBBACKTRACE.zip
+3db4c729b4d80a9d8fda8dd77128406353baff4755ca619177eda4cddae71269  qtbase-everywhere-src-$QT.tar.xz
+aae0c08924c6a5e47f9d57e031673d611ffff7aab2bee2e1cc460471ecac6743  qtimageformats-everywhere-src-$QT.tar.xz
+48b4cc1093af2e0ab3bea30f60651bddd877a2335d16e7207879a2e9e81963a3  qtsvg-everywhere-src-$QT.tar.xz
+551ffb22751d8fd4d88e9ebd55b9131f4ca55341ee497fdbbba4da8d10d94341  qttools-everywhere-src-$QT.tar.xz
+337c45637e757e754c2f0ea65c20de3e6e53a841dda1253db15baa622515beeb  qttranslations-everywhere-src-$QT.tar.xz
+3020be86fb7fd0abb8509906ca6583cadcaee168159abceaeb5b3e9d42563c9a  qtwayland-everywhere-src-$QT.tar.xz
+EOF
+
+curl -L \
+	-O "https://libsdl.org/release/$SDL.tar.gz" \
+	-O "https://github.com/ianlancetaylor/libbacktrace/archive/$LIBBACKTRACE.zip" \
+	-O "https://download.qt.io/official_releases/qt/${QT%.*}/$QT/submodules/qtbase-everywhere-src-$QT.tar.xz" \
+	-O "https://download.qt.io/official_releases/qt/${QT%.*}/$QT/submodules/qtimageformats-everywhere-src-$QT.tar.xz" \
+	-O "https://download.qt.io/official_releases/qt/${QT%.*}/$QT/submodules/qtsvg-everywhere-src-$QT.tar.xz" \
+	-O "https://download.qt.io/official_releases/qt/${QT%.*}/$QT/submodules/qttools-everywhere-src-$QT.tar.xz" \
+	-O "https://download.qt.io/official_releases/qt/${QT%.*}/$QT/submodules/qttranslations-everywhere-src-$QT.tar.xz" \
+	-O "https://download.qt.io/official_releases/qt/${QT%.*}/$QT/submodules/qtwayland-everywhere-src-$QT.tar.xz"
+
+shasum -a 256 --check SHASUMS
+
+echo "Building SDL..."
+tar xf "$SDL.tar.gz"
+cd "$SDL"
+./configure --prefix "$INSTALLDIR" --disable-dbus --without-x --disable-video-opengl --disable-video-opengles --disable-video-vulkan --disable-wayland-shared --disable-ime --disable-oss --disable-alsa --disable-jack --disable-esd --disable-pipewire --disable-pulseaudio --disable-arts --disable-nas --disable-sndio --disable-fusionsound --disable-diskaudio
+make "-j$NPROCS"
+make install
+cd ..
+
+echo "Building libbacktrace..."
+unzip "$LIBBACKTRACE.zip"
+cd "libbacktrace-$LIBBACKTRACE"
+./configure --prefix="$HOME/deps"
+make
+make install
+cd ..
+
+# Couple notes:
+# -fontconfig is needed otherwise Qt Widgets render only boxes.
+# -qt-doubleconversion avoids a dependency on libdouble-conversion.
+# ICU avoids pulling in a bunch of large libraries, and hopefully we can get away without it.
+# OpenGL is needed to render window decorations in Wayland, apparently.
+echo "Building Qt Base..."
+tar xf "qtbase-everywhere-src-$QT.tar.xz"
+cd "qtbase-everywhere-src-$QT"
+mkdir build
+cd build
+../configure -prefix "$INSTALLDIR" -release -no-dbus -gui -widgets -fontconfig -qt-doubleconversion -ssl -openssl-runtime -opengl desktop -qpa xcb,wayland -xkbcommon -- -DFEATURE_dbus=OFF -DFEATURE_icu=OFF -DFEATURE_printsupport=OFF -DFEATURE_sql=OFF
+cmake --build . --parallel
+cmake --install .
+cd ../../
+
+echo "Building Qt SVG..."
+tar xf "qtsvg-everywhere-src-$QT.tar.xz"
+cd "qtsvg-everywhere-src-$QT"
+mkdir build
+cd build
+cmake -G Ninja -DCMAKE_PREFIX_PATH="$INSTALLDIR" -DCMAKE_INSTALL_PREFIX="$INSTALLDIR" -DCMAKE_BUILD_TYPE=Release ..
+cmake --build . --parallel
+cmake --install .
+cd ../../
+
+echo "Building Qt Image Formats..."
+tar xf "qtimageformats-everywhere-src-$QT.tar.xz"
+cd "qtimageformats-everywhere-src-$QT"
+mkdir build
+cd build
+cmake -G Ninja -DCMAKE_PREFIX_PATH="$INSTALLDIR" -DCMAKE_INSTALL_PREFIX="$INSTALLDIR" -DCMAKE_BUILD_TYPE=Release ..
+cmake --build . --parallel
+cmake --install .
+cd ../../
+
+echo "Building Qt Wayland..."
+tar xf "qtwayland-everywhere-src-$QT.tar.xz"
+cd "qtwayland-everywhere-src-$QT"
+mkdir build
+cd build
+cmake -G Ninja -DCMAKE_PREFIX_PATH="$INSTALLDIR" -DCMAKE_INSTALL_PREFIX="$INSTALLDIR" -DCMAKE_BUILD_TYPE=Release ..
+cmake --build . --parallel
+cmake --install .
+cd ../../
+
+echo "Installing Qt Tools..."
+tar xf "qttools-everywhere-src-$QT.tar.xz"
+cd "qttools-everywhere-src-$QT"
+# From Mac build-dependencies.sh:
+# Linguist relies on a library in the Designer target, which takes 5-7 minutes to build on the CI
+# Avoid it by not building Linguist, since we only need the tools that come with it
+patch -u src/linguist/CMakeLists.txt <<EOF
+--- src/linguist/CMakeLists.txt
++++ src/linguist/CMakeLists.txt
+@@ -14,7 +14,7 @@
+ add_subdirectory(lrelease-pro)
+ add_subdirectory(lupdate)
+ add_subdirectory(lupdate-pro)
+-if(QT_FEATURE_process AND QT_FEATURE_pushbutton AND QT_FEATURE_toolbutton AND TARGET Qt::Widgets AND NOT no-png)
++if(QT_FEATURE_process AND QT_FEATURE_pushbutton AND QT_FEATURE_toolbutton AND TARGET Qt::Widgets AND TARGET Qt::PrintSupport AND NOT no-png)
+     add_subdirectory(linguist)
+ endif()
+EOF
+
+# Also force disable clang scanning, it gets very confused.
+patch -u configure.cmake <<EOF
+--- configure.cmake
++++ configure.cmake
+@@ -14,12 +14,12 @@
+ # Presumably because 6.0 ClangConfig.cmake files are not good enough?
+ # In any case explicitly request a minimum version of 8.x for now, otherwise
+ # building with CMake will fail at compilation time.
+-qt_find_package(WrapLibClang 8 PROVIDED_TARGETS WrapLibClang::WrapLibClang)
++#qt_find_package(WrapLibClang 8 PROVIDED_TARGETS WrapLibClang::WrapLibClang)
+ # special case end
+
+-if(TARGET WrapLibClang::WrapLibClang)
+-    set(TEST_libclang "ON" CACHE BOOL "Required libclang version found." FORCE)
+-endif()
++#if(TARGET WrapLibClang::WrapLibClang)
++#    set(TEST_libclang "ON" CACHE BOOL "Required libclang version found." FORCE)
++#endif()
+
+
+
+EOF
+
+mkdir build
+cd build
+cmake -G Ninja -DCMAKE_PREFIX_PATH="$INSTALLDIR" -DCMAKE_INSTALL_PREFIX="$INSTALLDIR" -DCMAKE_BUILD_TYPE=Release -DFEATURE_assistant=OFF -DFEATURE_clang=OFF -DFEATURE_designer=OFF -DFEATURE_kmap2qmap=OFF -DFEATURE_pixeltool=OFF -DFEATURE_pkg_config=OFF -DFEATURE_qev=OFF -DFEATURE_qtattributionsscanner=OFF -DFEATURE_qtdiag=OFF -DFEATURE_qtplugininfo=OFF ..
+cmake --build . --parallel
+cmake --install .
+cd ../../
+
+echo "Installing Qt Translations..."
+tar xf "qttranslations-everywhere-src-$QT.tar.xz"
+cd "qttranslations-everywhere-src-$QT"
+mkdir build
+cd build
+cmake -G Ninja -DCMAKE_PREFIX_PATH="$INSTALLDIR" -DCMAKE_INSTALL_PREFIX="$INSTALLDIR" -DCMAKE_BUILD_TYPE=Release ..
+cmake --build . --parallel
+cmake --install .
+cd ../../
+
+echo "Cleaning up..."
+cd ..
+rm -r deps-build

.github/workflows/scripts/linux/flatpak/modules/10-libpcap.json

@@ -0,0 +1,24 @@
+{
+  "name": "libpcap",
+  "buildsystem": "cmake-ninja",
+  "build-options": {
+    "strip": true
+  },
+  "sources": [
+    {
+      "type": "git",
+      "url": "https://github.com/the-tcpdump-group/libpcap.git",
+      "tag": "libpcap-1.10.4",
+      "commit": "104271ba4a14de6743e43bcf87536786d8fddea4"
+    }
+  ],
+  "cleanup": [
+    "/bin",
+    "/include",
+    "/lib/*.a",
+    "/lib/*.la",
+    "/lib/pkgconfig",
+    "/share/man"
+  ]
+}
+

.github/workflows/scripts/linux/flatpak/modules/11-libaio.json

@@ -0,0 +1,24 @@
+{
+  "name": "libaio",
+  "no-autogen": true,
+  "make-install-args": [
+    "prefix=/app"
+  ],
+  "build-options": {
+    "strip": true
+  },
+  "sources": [
+    {
+      "type": "git",
+      "url": "https://pagure.io/libaio.git",
+      "tag": "libaio-0.3.113",
+      "commit": "1b18bfafc6a2f7b9fa2c6be77a95afed8b7be448"
+    }
+  ],
+  "cleanup": [
+    "/include",
+    "/lib/*.a",
+    "/lib/*.la"
+  ]
+}
+

.github/workflows/scripts/linux/flatpak/modules/20-sdl2.json

@@ -0,0 +1,45 @@
+{
+  "name": "sdl2",
+  "buildsystem": "autotools",
+  "no-autogen": true,
+  "config-opts": [
+    "--disable-dbus",
+    "--without-x",
+    "--disable-video-opengl",
+    "--disable-video-opengles",
+    "--disable-video-vulkan",
+    "--disable-wayland-shared",
+    "--disable-ime",
+    "--disable-oss",
+    "--disable-alsa",
+    "--disable-jack",
+    "--disable-esd",
+    "--disable-pipewire",
+    "--disable-pulseaudio",
+    "--disable-arts",
+    "--disable-nas",
+    "--disable-sndio",
+    "--disable-fusionsound",
+    "--disable-diskaudio"
+  ],
+  "build-options": {
+    "strip": true
+  },
+  "sources": [
+    {
+      "type": "archive",
+      "url": "https://libsdl.org/release/SDL2-2.28.1.tar.gz",
+      "sha256": "4977ceba5c0054dbe6c2f114641aced43ce3bf2b41ea64b6a372d6ba129cb15d"
+    }
+  ],
+  "cleanup": [
+    "/bin",
+    "/include",
+    "/lib/*.a",
+    "/lib/*.la",
+    "/lib/cmake",
+    "/lib/pkgconfig",
+    "/share/aclocal"
+  ]
+}
+

.github/workflows/scripts/linux/flatpak/modules/21-libbacktrace.json

@@ -0,0 +1,22 @@
+{
+    "name": "libbacktrace",
+    "buildsystem": "autotools",
+    "no-autogen": true,
+    "build-options": {
+      "strip": false,
+      "no-debuginfo": true
+    },
+    "sources": [
+      {
+        "type": "git",
+        "url": "https://github.com/ianlancetaylor/libbacktrace.git",
+        "commit": "ad106d5fdd5d960bd33fae1c48a351af567fd075"
+      }
+    ],
+    "cleanup": [
+      "/include",
+      "/lib/*.a",
+      "/lib/*.la"
+    ]
+  }
+  

.github/workflows/scripts/linux/flatpak/net.pcsx2.PCSX2.json

@@ -0,0 +1,68 @@
+{
+  "app-id": "net.pcsx2.PCSX2",
+  "runtime": "org.kde.Platform",
+  "runtime-version": "6.5",
+  "sdk": "org.kde.Sdk",
+  "sdk-extensions": [
+    "org.freedesktop.Sdk.Extension.llvm16"
+  ],
+  "add-extensions": {
+    "org.freedesktop.Platform.ffmpeg-full": {
+      "directory": "lib/ffmpeg",
+      "version": "22.08",
+      "add-ld-path": ".",
+      "autodownload": true
+    }
+  },
+  "command": "pcsx2-qt",
+  "finish-args": [
+    "--device=all",
+    "--share=network",
+    "--share=ipc",
+    "--socket=fallback-x11",
+    "--socket=wayland",
+    "--socket=pulseaudio",
+    "--filesystem=host:ro",
+    "--talk-name=org.freedesktop.ScreenSaver"
+  ],
+  "modules": [
+    "modules/10-libpcap.json",
+    "modules/11-libaio.json",
+    "modules/20-sdl2.json",
+    "modules/21-libbacktrace.json",
+    {
+      "name": "pcsx2",
+      "buildsystem": "simple",
+      "build-options": {
+        "strip": false,
+        "no-debuginfo": true,
+        "env": {
+          "DEPS_PREFIX": "/app",
+          "COMPILER": "clang",
+          "CLANG_PATH": "/usr/lib/sdk/llvm16/bin/clang",
+          "CLANGXX_PATH": "/usr/lib/sdk/llvm16/bin/clang++",
+          "ADDITIONAL_CMAKE_ARGS": "-DUSE_LINKED_FFMPEG=ON"
+        }
+      },
+      "sources": [
+        {
+          "type": "dir",
+          "path": "../../../../.."
+        }
+      ],
+      "build-commands": [
+        ".github/workflows/scripts/linux/generate-cmake-qt.sh",
+        "cd build && ../.github/workflows/scripts/linux/compile.sh && cd ..",
+        "cp -a build/bin ${FLATPAK_DEST}",
+        "cd build && ninja unittests && cd .."
+      ],
+      "post-install": [
+        "install -Dm644 bin/resources/icons/AppIconLarge.png ${FLATPAK_DEST}/share/icons/hicolor/512x512/apps/net.pcsx2.PCSX2.png",
+        "install -Dm644 .github/workflows/scripts/linux/pcsx2-qt.desktop ${FLATPAK_DEST}/share/applications/net.pcsx2.PCSX2.desktop",
+        "desktop-file-edit --set-key=Icon --set-value=net.pcsx2.PCSX2 ${FLATPAK_DEST}/share/applications/net.pcsx2.PCSX2.desktop",
+        "install -Dm644 .github/workflows/scripts/linux/flatpak/net.pcsx2.PCSX2.metainfo.xml ${FLATPAK_DEST}/share/metainfo/net.pcsx2.PCSX2.metainfo.xml"
+      ]
+    }
+  ]
+}
+

.github/workflows/scripts/linux/functions.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+function retry_command {
+	# Package servers tend to be unreliable at times..
+	# Retry a bunch of times.
+	local RETRIES=10
+
+	for i in $(seq 1 "$RETRIES"); do
+		"$@" && break
+		if [ "$i" == "$RETRIES" ]; then
+			echo "Command \"$@\" failed after ${RETRIES} retries."
+			exit 1
+		fi
+	done
+}
+

.github/workflows/scripts/linux/generate-cmake-qt.sh

@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+
+set -e
+
+if [[ -z "${DEPS_PREFIX}" ]]; then
+  echo "DEPS_PREFIX is not set."
+  exit 1
+fi
+
+echo "Using build dependencies from: ${DEPS_PREFIX}"
+
+if [ "${COMPILER}" = "clang" ]; then
+  if [[ -z "${CLANG_PATH}" ]] || [[ -z "${CLANGXX_PATH}" ]]; then
+    echo "CLANG_PATH or CLANGXX_PATH is not set."
+    exit 1
+  fi
+
+	echo "Using clang toolchain"
+	cat > "clang-toolchain.cmake" << EOF
+set(CMAKE_C_COMPILER "${CLANG_PATH}")
+set(CMAKE_CXX_COMPILER "${CLANGXX_PATH}")
+set(CMAKE_EXE_LINKER_FLAGS_INIT "-fuse-ld=lld")
+set(CMAKE_MODULE_LINKER_FLAGS_INIT "-fuse-ld=lld")
+set(CMAKE_SHARED_LINKER_FLAGS_INIT "-fuse-ld=lld")
+EOF
+	ADDITIONAL_CMAKE_ARGS="$ADDITIONAL_CMAKE_ARGS -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON -DCMAKE_TOOLCHAIN_FILE=clang-toolchain.cmake"
+fi
+
+echo "Additional CMake Args - ${ADDITIONAL_CMAKE_ARGS}"
+
+# Generate CMake into ./build
+# DISABLE_ADVANCE_SIMD is needed otherwise we end up doing -march=native.
+
+# shellcheck disable=SC2086
+cmake \
+	-B build \
+	-G Ninja \
+	$ADDITIONAL_CMAKE_ARGS \
+	-DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+	-DCMAKE_BUILD_TYPE=Release \
+	-DQT_BUILD=ON \
+	-DCUBEB_API=ON \
+	-DX11_API=ON \
+	-DWAYLAND_API=ON \
+	-DENABLE_SETCAP=OFF \
+	-DCMAKE_PREFIX_PATH="${DEPS_PREFIX}" \
+	-DUSE_SYSTEM_SDL2=ON \
+	-DUSE_SYSTEM_ZSTD=OFF \
+	-DDISABLE_ADVANCE_SIMD=TRUE
+

.github/workflows/scripts/linux/generate-cmake.sh

@@ -1,32 +0,0 @@
-#!/bin/bash
-
-set -e
-
-if [ "${COMPILER}" = "gcc" ]; then
-  export CC=gcc-10
-  export CXX=g++-10
-else
-  export CC=clang
-  export CXX=clang++
-fi
-
-if [ "${PLATFORM}" = x86 ]; then
-  ADDITIONAL_CMAKE_ARGS="$ADDITIONAL_CMAKE_ARGS -DCMAKE_TOOLCHAIN_FILE=cmake/linux-compiler-i386-multilib.cmake"
-fi
-echo "Additional CMake Args - ${ADDITIONAL_CMAKE_ARGS}"
-
-# Generate CMake into ./build
-cmake                                       \
--DCMAKE_CXX_COMPILER_LAUNCHER=ccache        \
--DCMAKE_BUILD_TYPE=Release                  \
--DPACKAGE_MODE=TRUE                         \
--DWAYLAND_API=TRUE                          \
--DDISABLE_ADVANCE_SIMD=TRUE                 \
--DDISABLE_PCSX2_WRAPPER=TRUE                \
--DCMAKE_INSTALL_PREFIX="squashfs-root/usr/" \
--DOpenGL_GL_PREFERENCE="LEGACY"             \
--DOPENGL_opengl_LIBRARY=""                  \
--DXDG_STD=TRUE                              \
-$ADDITIONAL_CMAKE_ARGS                      \
--GNinja                                     \
--B build

.github/workflows/scripts/linux/generate-metainfo.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+
+SCRIPTDIR=$(dirname "${BASH_SOURCE[0]}")
+
+if [[ $# -lt 1 ]]; then
+	echo "Output file must be provided as a parameter"
+	exit 1
+fi
+
+OUTFILE=$1
+GIT_DATE=$(git log -1 --pretty=%cd --date=short)
+GIT_VERSION=$(git tag --points-at HEAD)
+GIT_HASH=$(git rev-parse HEAD)
+
+if [[ "${GIT_VERSION}" == "" ]]; then
+	# In the odd event that we run this script before the release gets tagged.
+	GIT_VERSION=$(git describe --tags)
+	if [[ "${GIT_VERSION}" == "" ]]; then
+		GIT_VERSION=$(git rev-parse HEAD)
+	fi
+fi
+
+echo "GIT_DATE: ${GIT_DATE}"
+echo "GIT_VERSION: ${GIT_VERSION}"
+echo "GIT_HASH: ${GIT_HASH}"
+
+cp "${SCRIPTDIR}"/pcsx2-qt.metainfo.xml.in "${OUTFILE}"
+
+sed -i -e "s/@GIT_VERSION@/${GIT_VERSION}/" "${OUTFILE}"
+sed -i -e "s/@GIT_DATE@/${GIT_DATE}/" "${OUTFILE}"
+sed -i -e "s/@GIT_HASH@/${GIT_HASH}/" "${OUTFILE}"
+

.github/workflows/scripts/linux/install-packages-flatpak.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+
+SCRIPTDIR=$(dirname "${BASH_SOURCE[0]}")
+source "$SCRIPTDIR/functions.sh"
+
+set -e
+
+ARCH=x86_64
+KDE_BRANCH=6.5
+BRANCH=22.08
+FLAT_MANAGER_CLIENT_DIR="$HOME/.local/bin"
+
+# Build packages. Mostly needed for flat-manager-client.
+declare -a BUILD_PACKAGES=(
+  "flatpak"
+  "flatpak-builder"
+  "appstream-util"
+  "python3-aiohttp"
+  "python3-tenacity"
+  "python3-gi"
+  "gobject-introspection"
+  "libappstream-glib8"
+  "libappstream-glib-dev"
+  "libappstream-dev"
+  "gir1.2-ostree-1.0"
+)
+
+# Flatpak runtimes and SDKs.
+declare -a FLATPAK_PACKAGES=(
+  "org.kde.Platform/${ARCH}/${KDE_BRANCH}"
+  "org.kde.Sdk/${ARCH}/${KDE_BRANCH}"
+  "org.freedesktop.Platform.ffmpeg-full/${ARCH}/${BRANCH}"
+  "org.freedesktop.Sdk.Extension.llvm16/${ARCH}/${BRANCH}"
+  "org.freedesktop.appstream-glib/${ARCH}/stable"
+)
+
+retry_command sudo apt-get -qq update
+
+# Install packages needed for building
+echo "Will install the following packages for building - ${BUILD_PACKAGES[*]}"
+retry_command sudo apt-get -y install "${BUILD_PACKAGES[@]}"
+
+sudo flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
+
+# Install packages needed for building
+echo "Will install the following packages for building - ${FLATPAK_PACKAGES[*]}"
+retry_command sudo flatpak -y install "${FLATPAK_PACKAGES[@]}"
+
+echo "Downloading flat-manager-client"
+mkdir -p "$FLAT_MANAGER_CLIENT_DIR"
+pushd "$FLAT_MANAGER_CLIENT_DIR"
+aria2c -Z "https://raw.githubusercontent.com/flatpak/flat-manager/9401efbdc0d6bd489507d8401c567ba219d735d5/flat-manager-client"
+chmod +x flat-manager-client
+echo "$FLAT_MANAGER_CLIENT_DIR" >> $GITHUB_PATH
+popd

.github/workflows/scripts/linux/install-packages-qt.sh

@@ -0,0 +1,83 @@
+#!/bin/bash
+
+SCRIPTDIR=$(dirname "${BASH_SOURCE[0]}")
+source "$SCRIPTDIR/functions.sh"
+
+set -e
+
+# Packages - Build and Qt
+declare -a BUILD_PACKAGES=(
+	"build-essential"
+	"g++"
+	"git"
+	"cmake"
+	"ccache"
+	"ninja-build"
+	"patchelf"
+	"libfuse2"
+	"libglib2.0-dev"
+	"libfontconfig1-dev"
+	"libharfbuzz-dev"
+	"libjpeg-dev"
+	"libpng-dev"
+	"libfreetype-dev"
+	"libinput-dev"
+	"libxcb-*-dev"
+	"libxkbcommon-dev"
+	"libxkbcommon-x11-dev"
+	"libxrender-dev"
+	"libwayland-dev"
+	"libgl1-mesa-dev"
+	"libegl-dev"
+	"libegl1-mesa-dev"
+	"libgl1-mesa-dev"
+	"libssl-dev"
+)
+
+# Packages - PCSX2
+declare -a PCSX2_PACKAGES=(
+	"extra-cmake-modules"
+	"libaio-dev"
+	"libasound2-dev"
+	"libbz2-dev"
+	"libcurl4-openssl-dev"
+	"libegl1-mesa-dev"
+	"libgl1-mesa-dev"
+	"libgtk-3-dev"
+	"libharfbuzz-dev"
+	"libjpeg-dev"
+	"liblzma-dev"
+	"libpcap0.8-dev"
+	"libpng-dev"
+	"libpulse-dev"
+	"librsvg2-dev"
+	"libsamplerate0-dev"
+	"libudev-dev"
+	"libx11-xcb-dev"
+	"libavcodec-dev"
+	"libavformat-dev"
+	"libavutil-dev"
+	"libswresample-dev"
+	"libswscale-dev"
+	"pkg-config"
+	"zlib1g-dev"
+)
+
+if [ "${COMPILER}" = "clang" ]; then
+	BUILD_PACKAGES+=("llvm-16" "lld-16" "clang-16")
+
+	# Ubuntu 22.04 doesn't ship with LLVM 16, so we need to pull it from the llvm.org repos.
+	retry_command wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
+	sudo apt-add-repository -n 'deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-16 main'
+fi
+
+retry_command sudo apt-get -qq update && break
+
+# Install packages needed for building
+echo "Will install the following packages for building - ${BUILD_PACKAGES[*]}"
+retry_command sudo apt-get -y install "${BUILD_PACKAGES[@]}"
+
+# Install packages needed by pcsx2
+PCSX2_PACKAGES=("${PCSX2_PACKAGES[@]}")
+echo "Will install the following packages for pcsx2 - ${PCSX2_PACKAGES[*]}"
+retry_command sudo apt-get -y install "${PCSX2_PACKAGES[@]}"

.github/workflows/scripts/linux/install-packages.sh

@@ -1,62 +0,0 @@
-#!/bin/bash
-
-set -e
-
-# Packages - Build Environment
-declare -a BUILD_PACKAGES=(
-  "ccache"
-  "cmake"
-  "ninja-build"
-)
-
-# Packages - PCSX2
-declare -a PCSX2_PACKAGES=(
-  "libaio-dev"
-  "libbz2-dev"
-  "libegl1-mesa-dev"
-  "libgdk-pixbuf2.0-dev"
-  "libgl1-mesa-dev"
-  "libgtk-3-dev"
-  "libharfbuzz-dev"
-  "libjpeg-dev"
-  "liblzma-dev"
-  "libpcap0.8-dev"
-  "libpng-dev"
-  "libpulse-dev"
-  "librsvg2-dev"
-  "libsamplerate0-dev"
-  "libsoundtouch-dev"
-  "libudev-dev"
-  "libwxgtk3.0-gtk3-dev"
-  "libx11-xcb-dev"
-  "pkg-config"
-  "portaudio19-dev"
-  "zlib1g-dev"
-)
-
-if [ "${COMPILER}" = "gcc" ]; then
-  BUILD_PACKAGES+=("g++-10-multilib")
-else
-  BUILD_PACKAGES+=("clang-9")
-  PCSX2_PACKAGES+=("libstdc++-10-dev")
-fi
-
-# - https://github.com/actions/virtual-environments/blob/main/images/linux/Ubuntu2004-README.md
-ARCH=""
-echo "${PLATFORM}"
-if [ "${PLATFORM}" == "x86" ]; then
-  ARCH=":i386"
-  sudo dpkg --add-architecture i386
-fi
-
-sudo apt-get -qq update
-
-# Install packages needed for building
-echo "Will install the following packages for building - ${BUILD_PACKAGES[*]}"
-#sudo apt remove gcc-9 g++-9
-sudo apt-get -y install "${BUILD_PACKAGES[@]}"
-
-# Install packages needed by pcsx2
-PCSX2_PACKAGES=("${PCSX2_PACKAGES[@]/%/"${ARCH}"}")
-echo "Will install the following packages for pcsx2 - ${PCSX2_PACKAGES[*]}"
-sudo apt-get -y install "${PCSX2_PACKAGES[@]}"

.github/workflows/scripts/linux/pcsx2-qt.desktop

@@ -0,0 +1,12 @@
+[Desktop Entry]
+Version=1.0
+Terminal=false
+Type=Application
+Name=PCSX2
+StartupWMClass=PCSX2
+GenericName=PlayStation 2 Emulator
+Comment=Sony PlayStation 2 emulator
+Exec=pcsx2-qt
+Icon=PCSX2
+Keywords=game;emulator;
+Categories=Game;Emulator;

.github/workflows/scripts/linux/pcsx2-qt.metainfo.xml.in

@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<component type="desktop">
+  <id>net.pcsx2.PCSX2</id>
+  <launchable type="desktop-id">net.pcsx2.PCSX2.desktop</launchable>
+  <metadata_license>CC0-1.0</metadata_license>
+  <project_license>GPL-3.0</project_license>
+  <name>PCSX2</name>
+  <developer_name>PCSX2</developer_name>
+  <summary>PlayStation 2 Emulator</summary>
+  <description>
+    <p>PCSX2 is a free and open-source PlayStation 2 (PS2) emulator. Its purpose is to emulate the PS2's hardware, using a combination of MIPS CPU Interpreters, Recompilers and a Virtual Machine which manages hardware states and PS2 system memory. This allows you to play PS2 games on your PC, with many additional features and benefits.</p>
+    <p>PlayStation 2 and PS2 are registered trademarks of Sony Interactive Entertainment. This application is not affiliated in any way with Sony Interactive Entertainment.</p>
+  </description>
+  <url type="homepage">https://pcsx2.net/</url>
+  <url type="bugtracker">https://github.com/PCSX2/pcsx2/issues</url>
+  <url type="donation">https://github.com/sponsors/PCSX2</url>
+  <url type="faq">https://pcsx2.net/docs/</url>
+  <url type="help">https://discord.com/invite/TCz3t9k</url>
+  <url type="translate">https://crowdin.com/project/pcsx2-emulator</url>
+  <url type="vcs-browser">https://github.com/PCSX2/pcsx2</url>
+  <screenshots>
+    <screenshot type="default">
+      <image>https://raw.githubusercontent.com/PCSX2/pcsx2/master/.github/workflows/scripts/linux/flatpak/screenshots/screenshot1.png</image>
+    </screenshot>
+    <screenshot>
+      <image>https://raw.githubusercontent.com/PCSX2/pcsx2/master/.github/workflows/scripts/linux/flatpak/screenshots/screenshot2.png</image>
+    </screenshot>
+  </screenshots>
+  <content_rating type="oars-1.1"/>
+  <update_contact>stenzek_AT_gmail.com</update_contact>
+  <releases>
+    <release version="@GIT_VERSION@" date="@GIT_DATE@" />
+  </releases>
+  <custom>
+    <value key="flathub::manifest">https://raw.githubusercontent.com/PCSX2/pcsx2/@GIT_HASH@/.github/workflows/scripts/linux/flatpak/net.pcsx2.PCSX2.json</value>
+  </custom>
+</component>

.github/workflows/scripts/macos/build-dependencies.sh

@@ -0,0 +1,232 @@
+#!/bin/bash
+
+set -e
+
+export MACOSX_DEPLOYMENT_TARGET=10.14
+
+INSTALLDIR="$HOME/deps"
+NPROCS="$(getconf _NPROCESSORS_ONLN)"
+SDL=SDL2-2.28.1
+PNG=1.6.37
+JPG=9e
+SOUNDTOUCH=soundtouch-2.3.1
+FFMPEG=6.0
+QT=6.4.3 # Currently stuck on Qt 6.4 due to 6.5 requiring macOS 11.0.
+
+mkdir deps-build
+cd deps-build
+
+export PKG_CONFIG_PATH="$INSTALLDIR/lib/pkgconfig:$PKG_CONFIG_PATH"
+export LDFLAGS="-L$INSTALLDIR/lib -dead_strip $LDFLAGS"
+export CFLAGS="-I$INSTALLDIR/include -Os $CFLAGS"
+export CXXFLAGS="-I$INSTALLDIR/include -Os $CXXFLAGS"
+
+cat > SHASUMS <<EOF
+4977ceba5c0054dbe6c2f114641aced43ce3bf2b41ea64b6a372d6ba129cb15d  $SDL.tar.gz
+505e70834d35383537b6491e7ae8641f1a4bed1876dbfe361201fc80868d88ca  libpng-$PNG.tar.xz
+4077d6a6a75aeb01884f708919d25934c93305e49f7e3f36db9129320e6f4f3d  jpegsrc.v$JPG.tar.gz
+6900996607258496ce126924a19fe9d598af9d892cf3f33d1e4daaa9b42ae0b1  $SOUNDTOUCH.tar.gz
+57be87c22d9b49c112b6d24bc67d42508660e6b718b3db89c44e47e289137082  ffmpeg-$FFMPEG.tar.xz
+5087c9e5b0165e7bc3c1a4ab176b35d0cd8f52636aea903fa377bdba00891a60  qtbase-everywhere-src-$QT.tar.xz
+0aff58062e74b84617c5da8325d8cdad5368d8f4d2a11ceafcd58329fe99b798  qtimageformats-everywhere-src-$QT.tar.xz
+88315f886cf81898705e487cedba6e6160724359d23c518c92c333c098879a4a  qtsvg-everywhere-src-$QT.tar.xz
+867df829cd5cd3ae8efe62e825503123542764b13c96953511e567df70c5a091  qttools-everywhere-src-$QT.tar.xz
+79e56b7800d49649a8a8010818538c367a829e0b7a09d5f60bd3aecf5abe972c  qttranslations-everywhere-src-$QT.tar.xz
+EOF
+
+curl -L \
+	-O "https://libsdl.org/release/$SDL.tar.gz" \
+	-O "https://downloads.sourceforge.net/project/libpng/libpng16/$PNG/libpng-$PNG.tar.xz" \
+	-O "https://www.ijg.org/files/jpegsrc.v$JPG.tar.gz" \
+	-O "https://www.surina.net/soundtouch/$SOUNDTOUCH.tar.gz" \
+	-O "https://ffmpeg.org/releases/ffmpeg-$FFMPEG.tar.xz" \
+	-O "https://download.qt.io/official_releases/qt/${QT%.*}/$QT/submodules/qtbase-everywhere-src-$QT.tar.xz" \
+	-O "https://download.qt.io/official_releases/qt/${QT%.*}/$QT/submodules/qtimageformats-everywhere-src-$QT.tar.xz" \
+	-O "https://download.qt.io/official_releases/qt/${QT%.*}/$QT/submodules/qtsvg-everywhere-src-$QT.tar.xz" \
+	-O "https://download.qt.io/official_releases/qt/${QT%.*}/$QT/submodules/qttools-everywhere-src-$QT.tar.xz" \
+	-O "https://download.qt.io/official_releases/qt/${QT%.*}/$QT/submodules/qttranslations-everywhere-src-$QT.tar.xz" \
+
+shasum -a 256 --check SHASUMS
+
+echo "Installing SDL..."
+tar xf "$SDL.tar.gz"
+cd "$SDL"
+./configure --prefix "$INSTALLDIR" --without-x
+make "-j$NPROCS"
+make install
+cd ..
+
+echo "Installing libpng..."
+tar xf "libpng-$PNG.tar.xz"
+cd "libpng-$PNG"
+./configure --prefix "$INSTALLDIR" --disable-dependency-tracking
+make "-j$NPROCS"
+make install
+cd ..
+
+echo "Installing libjpeg..."
+tar xf "jpegsrc.v$JPG.tar.gz"
+cd "jpeg-$JPG"
+./configure --prefix "$INSTALLDIR" --disable-dependency-tracking
+make "-j$NPROCS"
+make install
+cd ..
+
+echo "Installing soundtouch..."
+tar xf "$SOUNDTOUCH.tar.gz"
+cd "$SOUNDTOUCH"
+cmake -B build -DCMAKE_INSTALL_PREFIX="$INSTALLDIR" -DCMAKE_BUILD_TYPE=MinSizeRel
+make -C build "-j$NPROCS"
+make -C build install
+cd ..
+
+echo "Installing FFmpeg..."
+tar xf "ffmpeg-$FFMPEG.tar.xz"
+cd "ffmpeg-$FFMPEG"
+./configure --prefix="$INSTALLDIR" --disable-all --disable-autodetect --disable-static --enable-shared \
+	--enable-avcodec --enable-avformat --enable-avutil --enable-swresample --enable-swscale \
+	--enable-audiotoolbox --enable-videotoolbox \
+	--enable-encoder=ffv1,qtrle,pcm_s16be,pcm_s16le,*_at,*_videotoolbox \
+	--enable-muxer=avi,matroska,mov,mp3,mp4,wav \
+	--enable-protocol=file
+make "-j$NPROCS"
+make install
+cd ..
+
+echo "Installing Qt Base..."
+tar xf "qtbase-everywhere-src-$QT.tar.xz"
+cd "qtbase-everywhere-src-$QT"
+# Qt's panel:shouldEnableURL: implementation does a whole bunch of things that activate macOS's sandbox permissions dialog
+# Since this is called on every file being displayed in the open/save panel, that spams users with permissions dialogs
+# Simple solution: Hopefully no one needs any filters that aren't simple file extension filters, remove all other handling
+patch -u src/plugins/platforms/cocoa/qcocoafiledialoghelper.mm <<EOF
+--- src/plugins/platforms/cocoa/qcocoafiledialoghelper.mm
++++ src/plugins/platforms/cocoa/qcocoafiledialoghelper.mm
+@@ -133,7 +133,5 @@
+     NSURL *url = [NSURL fileURLWithPath:filepath isDirectory:info.isDir()];
+-    bool selectable = (m_options->acceptMode() == QFileDialogOptions::AcceptSave)
+-        || [self panel:m_panel shouldEnableURL:url];
+ 
+     m_panel.directoryURL = [NSURL fileURLWithPath:m_currentDirectory];
+-    m_panel.nameFieldStringValue = selectable ? info.fileName().toNSString() : @"";
++    m_panel.nameFieldStringValue = info.fileName().toNSString();
+ 
+@@ -203,61 +201,2 @@
+     return hidden;
+-}
+-
+-- (BOOL)panel:(id)sender shouldEnableURL:(NSURL *)url
+-{
+-    Q_UNUSED(sender);
+-
+-    NSString *filename = url.path;
+-    if (!filename.length)
+-        return NO;
+-
+-    // Always accept directories regardless of their names (unless it is a bundle):
+-    NSFileManager *fm = NSFileManager.defaultManager;
+-    NSDictionary *fileAttrs = [fm attributesOfItemAtPath:filename error:nil];
+-    if (!fileAttrs)
+-        return NO; // Error accessing the file means 'no'.
+-    NSString *fileType = fileAttrs.fileType;
+-    bool isDir = [fileType isEqualToString:NSFileTypeDirectory];
+-    if (isDir) {
+-        if (!m_panel.treatsFilePackagesAsDirectories) {
+-            if ([NSWorkspace.sharedWorkspace isFilePackageAtPath:filename] == NO)
+-                return YES;
+-        }
+-    }
+-
+-    // Treat symbolic links and aliases to directories like directories
+-    QFileInfo fileInfo(QString::fromNSString(filename));
+-    if (fileInfo.isSymLink() && QFileInfo(fileInfo.symLinkTarget()).isDir())
+-        return YES;
+-
+-    QString qtFileName = fileInfo.fileName();
+-    // No filter means accept everything
+-    bool nameMatches = m_selectedNameFilter->isEmpty();
+-    // Check if the current file name filter accepts the file:
+-    for (int i = 0; !nameMatches && i < m_selectedNameFilter->size(); ++i) {
+-        if (QDir::match(m_selectedNameFilter->at(i), qtFileName))
+-            nameMatches = true;
+-    }
+-    if (!nameMatches)
+-        return NO;
+-
+-    QDir::Filters filter = m_options->filter();
+-    if ((!(filter & (QDir::Dirs | QDir::AllDirs)) && isDir)
+-        || (!(filter & QDir::Files) && [fileType isEqualToString:NSFileTypeRegular])
+-        || ((filter & QDir::NoSymLinks) && [fileType isEqualToString:NSFileTypeSymbolicLink]))
+-        return NO;
+-
+-    bool filterPermissions = ((filter & QDir::PermissionMask)
+-                              && (filter & QDir::PermissionMask) != QDir::PermissionMask);
+-    if (filterPermissions) {
+-        if ((!(filter & QDir::Readable) && [fm isReadableFileAtPath:filename])
+-            || (!(filter & QDir::Writable) && [fm isWritableFileAtPath:filename])
+-            || (!(filter & QDir::Executable) && [fm isExecutableFileAtPath:filename]))
+-            return NO;
+-    }
+-    if (!(filter & QDir::Hidden)
+-        && (qtFileName.startsWith(u'.') || [self isHiddenFileAtURL:url]))
+-            return NO;
+-
+-    return YES;
+ }
+@@ -406,5 +345,2 @@
+ {
+-    if (m_options->acceptMode() != QFileDialogOptions::AcceptSave)
+-        return nil; // panel:shouldEnableURL: does the file filtering for NSOpenPanel
+-
+     QStringList fileTypes;
+EOF
+cmake -B build -DCMAKE_PREFIX_PATH="$INSTALLDIR" -DCMAKE_INSTALL_PREFIX="$INSTALLDIR" -DCMAKE_BUILD_TYPE=Release -DFEATURE_optimize_size=ON -DFEATURE_dbus=OFF -DFEATURE_framework=OFF -DFEATURE_icu=OFF -DFEATURE_opengl=OFF -DFEATURE_printsupport=OFF -DFEATURE_sql=OFF -DFEATURE_gssapi=OFF
+make -C build "-j$NPROCS"
+make -C build install
+cd ..
+echo "Installing Qt SVG..."
+tar xf "qtsvg-everywhere-src-$QT.tar.xz"
+cd "qtsvg-everywhere-src-$QT"
+cmake -B build -DCMAKE_PREFIX_PATH="$INSTALLDIR" -DCMAKE_INSTALL_PREFIX="$INSTALLDIR" -DCMAKE_BUILD_TYPE=MinSizeRel
+make -C build "-j$NPROCS"
+make -C build install
+cd ..
+echo "Installing Qt Image Formats..."
+tar xf "qtimageformats-everywhere-src-$QT.tar.xz"
+cd "qtimageformats-everywhere-src-$QT"
+cmake -B build -DCMAKE_PREFIX_PATH="$INSTALLDIR" -DCMAKE_INSTALL_PREFIX="$INSTALLDIR" -DCMAKE_BUILD_TYPE=MinSizeRel
+make -C build "-j$NPROCS"
+make -C build install
+cd ..
+echo "Installing Qt Tools..."
+tar xf "qttools-everywhere-src-$QT.tar.xz"
+cd "qttools-everywhere-src-$QT"
+# Linguist relies on a library in the Designer target, which takes 5-7 minutes to build on the CI
+# Avoid it by not building Linguist, since we only need the tools that come with it
+patch -u src/linguist/CMakeLists.txt <<EOF
+--- src/linguist/CMakeLists.txt
++++ src/linguist/CMakeLists.txt
+@@ -14,7 +14,7 @@
+ add_subdirectory(lrelease-pro)
+ add_subdirectory(lupdate)
+ add_subdirectory(lupdate-pro)
+-if(QT_FEATURE_process AND QT_FEATURE_pushbutton AND QT_FEATURE_toolbutton AND TARGET Qt::Widgets AND NOT no-png)
++if(QT_FEATURE_process AND QT_FEATURE_pushbutton AND QT_FEATURE_toolbutton AND TARGET Qt::Widgets AND TARGET Qt::PrintSupport AND NOT no-png)
+     add_subdirectory(linguist)
+ endif()
+EOF
+cmake -B build -DCMAKE_PREFIX_PATH="$INSTALLDIR" -DCMAKE_INSTALL_PREFIX="$INSTALLDIR" -DCMAKE_BUILD_TYPE=Release -DFEATURE_assistant=OFF -DFEATURE_clang=OFF -DFEATURE_designer=OFF -DFEATURE_kmap2qmap=OFF -DFEATURE_pixeltool=OFF -DFEATURE_pkg_config=OFF -DFEATURE_qev=OFF -DFEATURE_qtattributionsscanner=OFF -DFEATURE_qtdiag=OFF -DFEATURE_qtplugininfo=OFF
+make -C build "-j$NPROCS"
+make -C build install
+cd ..
+echo "Installing Qt Translations..."
+tar xf "qttranslations-everywhere-src-$QT.tar.xz"
+cd "qttranslations-everywhere-src-$QT"
+cmake -B build -DCMAKE_PREFIX_PATH="$INSTALLDIR" -DCMAKE_INSTALL_PREFIX="$INSTALLDIR" -DCMAKE_BUILD_TYPE=Release
+make -C build "-j$NPROCS"
+make -C build install
+cd ..
+
+echo "Cleaning up..."
+cd ..
+rm -r deps-build

.github/workflows/scripts/releases/announce-release/index.js

@@ -19,7 +19,12 @@ const embed = new MessageEmbed()
     { name: 'Included Changes', value: releaseInfo.body, inline: false }
   );
 
-const webhookClient = new WebhookClient({ url: process.env.DISCORD_BUILD_WEBHOOK });
-await webhookClient.send({
-  embeds: [embed],
-});
+// Get all webhooks, simple comma-sep string
+const webhookUrls = process.env.DISCORD_BUILD_WEBHOOK.split(",");
+
+for (const url of webhookUrls) {
+  const webhookClient = new WebhookClient({ url: url });
+  await webhookClient.send({
+    embeds: [embed],
+  });
+}

.github/workflows/scripts/releases/generate-release-notes/index.js

@@ -1,11 +1,15 @@
 import { Octokit } from "@octokit/rest";
 import { throttling } from "@octokit/plugin-throttling";
 import { retry } from "@octokit/plugin-retry";
+
+let owner = process.env.OWNER;
+let repo = process.env.REPO;
+
 Octokit.plugin(throttling);
 Octokit.plugin(retry);
 const octokit = new Octokit({
   auth: process.env.GITHUB_TOKEN,
-  userAgent: 'PCSX2/pcsx2',
+  userAgent: `${owner}/${repo}`,
   log: {
     debug: () => { },
     info: () => { },
@@ -39,14 +43,14 @@ let commitSha = process.env.COMMIT_SHA;
 console.log(`Searching for Commit - ${commitSha}`);
 
 const { data: commit } = await octokit.rest.repos.getCommit({
-  owner: "PCSX2",
-  repo: "pcsx2",
+  owner: owner,
+  repo: repo,
   ref: commitSha,
 });
 
 const { data: associatedPulls } = await octokit.rest.repos.listPullRequestsAssociatedWithCommit({
-  owner: "PCSX2",
-  repo: "pcsx2",
+  owner: owner,
+  repo: repo,
   commit_sha: commit.sha,
 });
 

.github/workflows/scripts/releases/rename-release-assets.py

@@ -0,0 +1,49 @@
+import os
+import shutil
+
+tag = os.environ['TAG_VAL']
+scan_dir = os.environ['SCAN_DIR']
+output_dir = os.environ['OUT_DIR']
+accepted_exts = ["AppImage", "flatpak", "tar.xz", "7z"]
+
+
+for dir_name in os.listdir(scan_dir):
+  asset_name = "pcsx2-{}".format(tag)
+  if "macos" in dir_name.lower():
+    asset_name += "-macos"
+  elif "linux" in dir_name.lower():
+    if "flatpak" in dir_name.lower():
+      asset_name += "-linux-flatpak-x64"
+    else:
+      asset_name += "-linux-appimage-x64"
+  elif "windows" in dir_name.lower():
+    asset_name += "-windows-x64"
+  else:
+    continue;
+
+  if "avx2" in dir_name.lower():
+    asset_name += "-AVX2"
+  elif "sse4" in dir_name.lower():
+    asset_name += "-SSE4"
+
+  asset_name += "-Qt"
+
+  if "symbols" in dir_name.lower():
+    asset_name += "-symbols"
+
+  print(asset_name)
+
+  dir_handled = False
+  for file in os.listdir(os.path.join(scan_dir, dir_name)):
+    for ext in accepted_exts:
+      if file.endswith(ext):
+        dir_handled = True
+        print("Moving {} to out dir".format(file))
+        shutil.move(os.path.join(scan_dir, dir_name, file), os.path.join(output_dir, asset_name + "." + ext))
+        break
+    if dir_handled:
+      break
+
+  if not dir_handled:
+    print("Could not find asset in directory when one was expected")
+    exit(1)

.github/workflows/scripts/releases/upload-release-artifacts/.gitignore

@@ -1,2 +0,0 @@
-node_modules/
-*.md

.github/workflows/scripts/releases/upload-release-artifacts/index.js

@@ -1,142 +0,0 @@
-import { Octokit } from "@octokit/rest";
-import { throttling } from "@octokit/plugin-throttling";
-import { retry } from "@octokit/plugin-retry";
-Octokit.plugin(throttling);
-Octokit.plugin(retry);
-const octokit = new Octokit({
-  auth: process.env.GITHUB_TOKEN,
-  userAgent: 'PCSX2/pcsx2',
-  log: {
-    debug: () => { },
-    info: () => { },
-    warn: console.warn,
-    error: console.error
-  },
-  throttle: {
-    onRateLimit: (retryAfter, options) => {
-      octokit.log.warn(
-        `Request quota exhausted for request ${options.method} ${options.url}`
-      );
-
-      // Retry twice after hitting a rate limit error, then give up
-      if (options.request.retryCount <= 2) {
-        console.log(`Retrying after ${retryAfter} seconds!`);
-        return true;
-      }
-    },
-    onAbuseLimit: (retryAfter, options) => {
-      // does not retry, only logs a warning
-      octokit.log.warn(
-        `Abuse detected for request ${options.method} ${options.url}`
-      );
-    },
-  }
-});
-
-let assetDir = process.env.ASSET_DIR;
-let tagToSearchFor = process.env.TAG_TO_SEARCH_FOR.split("refs/tags/")[1];
-
-console.log(`Searching in - ${assetDir}`);
-console.log(`Searching for tag - ${tagToSearchFor}`);
-
-const { data: recentReleases } = await octokit.rest.repos.listReleases({
-  owner: "PCSX2",
-  repo: "pcsx2",
-  per_page: 100
-});
-
-let release = undefined;
-for (var i = 0; i < recentReleases.length; i++) {
-  if (recentReleases[i].tag_name == tagToSearchFor) {
-    release = recentReleases[i];
-    break;
-  }
-}
-
-if (release == undefined) {
-  console.log(`Unable to find release with tag - ${tagToSearchFor}`);
-  process.exit(1);
-}
-
-// Upload any assets we need to, don't upload assets that are already there!
-const { data: releaseAssetsPre } = await octokit.rest.repos.listReleaseAssets({
-  owner: "PCSX2",
-  repo: "pcsx2",
-  release_id: release.id,
-  per_page: 100
-});
-
-import glob from 'glob';
-import * as fs from 'fs';
-import * as path from 'path';
-glob(assetDir + `/**/*${process.env.ASSET_EXTENSION}`, {}, async (err, files) => {
-  for (var i = 0; i < files.length; i++) {
-    let foundDuplicate = false;
-    for (var j = 0; j < releaseAssetsPre.length; j++) {
-      let existingAsset = releaseAssetsPre[j];
-      if (existingAsset.name == `pcsx2-${release.tag_name}-${path.basename(files[i])}`) {
-        foundDuplicate = true;
-        break;
-      }
-    }
-    if (foundDuplicate) {
-      continue;
-    }
-
-    var assetBytes = fs.readFileSync(files[i], null);
-    const { data: uploadAsset } = await octokit.rest.repos.uploadReleaseAsset({
-      owner: "PCSX2",
-      repo: "pcsx2",
-      release_id: release.id,
-      name: `pcsx2-${release.tag_name}-${path.basename(files[i])}`,
-      data: assetBytes,
-    });
-  }
-});
-
-// Ideally there would be a webhook event for when an artifact is added to a draft release
-// unfortunately, such a thing does not exist yet.  Therefore, we have to wait a bit
-// for the API to become consistent
-// TODO - future work - we could check previous draft releases to become eventually consistent as well
-// - draft releases should only be a temporary state, so anything that remains a draft had a problem
-await new Promise(resolve => setTimeout(resolve, 10 * 1000));
-
-// Poll the release, and check to see if it's ready to be published
-const { data: releaseAssetsPost } = await octokit.rest.repos.listReleaseAssets({
-  owner: "PCSX2",
-  repo: "pcsx2",
-  release_id: release.id,
-  per_page: 100
-});
-
-// Expected Assets, if we have all of them, we will publish it
-let expectedAssets = {
-  "windows-64bit-sse4": false,
-  "windows-64bit-avx2": false,
-  "linux-appimage-64bit": false
-}
-
-for (var i = 0; i < releaseAssetsPost.length; i++) {
-  let asset = releaseAssetsPost[i];
-  if (asset.name.includes("symbols")) {
-    continue;
-  }
-  for (var j = 0; j < Object.keys(expectedAssets).length; j++) {
-    let expectedNamePrefix = Object.keys(expectedAssets)[j];
-    if (asset.name.toLowerCase().includes(expectedNamePrefix)) {
-      expectedAssets[expectedNamePrefix] = true;
-      break;
-    }
-  }
-}
-
-console.log(expectedAssets);
-
-if (Object.values(expectedAssets).every(Boolean)) {
-  await octokit.rest.repos.updateRelease({
-    owner: "PCSX2",
-    repo: "pcsx2",
-    release_id: release.id,
-    draft: false
-  });
-}

.github/workflows/scripts/releases/upload-release-artifacts/package-lock.json

@@ -1,559 +0,0 @@
-{
-  "name": "upload-release-artifacts",
-  "version": "1.0.0",
-  "lockfileVersion": 2,
-  "requires": true,
-  "packages": {
-    "": {
-      "version": "1.0.0",
-      "license": "ISC",
-      "dependencies": {
-        "@octokit/plugin-retry": "^3.0.9",
-        "@octokit/plugin-throttling": "^3.5.2",
-        "@octokit/rest": "^18.12.0",
-        "glob": "^7.2.0"
-      }
-    },
-    "node_modules/@octokit/auth-token": {
-      "version": "2.5.0",
-      "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-2.5.0.tgz",
-      "integrity": "sha512-r5FVUJCOLl19AxiuZD2VRZ/ORjp/4IN98Of6YJoJOkY75CIBuYfmiNHGrDwXr+aLGG55igl9QrxX3hbiXlLb+g==",
-      "dependencies": {
-        "@octokit/types": "^6.0.3"
-      }
-    },
-    "node_modules/@octokit/core": {
-      "version": "3.5.1",
-      "resolved": "https://registry.npmjs.org/@octokit/core/-/core-3.5.1.tgz",
-      "integrity": "sha512-omncwpLVxMP+GLpLPgeGJBF6IWJFjXDS5flY5VbppePYX9XehevbDykRH9PdCdvqt9TS5AOTiDide7h0qrkHjw==",
-      "dependencies": {
-        "@octokit/auth-token": "^2.4.4",
-        "@octokit/graphql": "^4.5.8",
-        "@octokit/request": "^5.6.0",
-        "@octokit/request-error": "^2.0.5",
-        "@octokit/types": "^6.0.3",
-        "before-after-hook": "^2.2.0",
-        "universal-user-agent": "^6.0.0"
-      }
-    },
-    "node_modules/@octokit/endpoint": {
-      "version": "6.0.12",
-      "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-6.0.12.tgz",
-      "integrity": "sha512-lF3puPwkQWGfkMClXb4k/eUT/nZKQfxinRWJrdZaJO85Dqwo/G0yOC434Jr2ojwafWJMYqFGFa5ms4jJUgujdA==",
-      "dependencies": {
-        "@octokit/types": "^6.0.3",
-        "is-plain-object": "^5.0.0",
-        "universal-user-agent": "^6.0.0"
-      }
-    },
-    "node_modules/@octokit/graphql": {
-      "version": "4.8.0",
-      "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-4.8.0.tgz",
-      "integrity": "sha512-0gv+qLSBLKF0z8TKaSKTsS39scVKF9dbMxJpj3U0vC7wjNWFuIpL/z76Qe2fiuCbDRcJSavkXsVtMS6/dtQQsg==",
-      "dependencies": {
-        "@octokit/request": "^5.6.0",
-        "@octokit/types": "^6.0.3",
-        "universal-user-agent": "^6.0.0"
-      }
-    },
-    "node_modules/@octokit/openapi-types": {
-      "version": "11.1.0",
-      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-11.1.0.tgz",
-      "integrity": "sha512-dWZfYvCCdjZzDYA3lIAMF72Q0jld8xidqCq5Ryw09eBJXZdcM6he0vWBTvw/b5UnGYqexxOyHWgfrsTlUJL3Gw=="
-    },
-    "node_modules/@octokit/plugin-paginate-rest": {
-      "version": "2.16.9",
-      "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-2.16.9.tgz",
-      "integrity": "sha512-gfSCMgz5scFKsR0dW4jaYsDJVt/UwCHp4dF7sHlmSekZvwzvLiOAGZ4MQkEsL5DW9hIk2W+UQkYZMTA1b6Wsqw==",
-      "dependencies": {
-        "@octokit/types": "^6.33.0"
-      }
-    },
-    "node_modules/@octokit/plugin-request-log": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/@octokit/plugin-request-log/-/plugin-request-log-1.0.4.tgz",
-      "integrity": "sha512-mLUsMkgP7K/cnFEw07kWqXGF5LKrOkD+lhCrKvPHXWDywAwuDUeDwWBpc69XK3pNX0uKiVt8g5z96PJ6z9xCFA=="
-    },
-    "node_modules/@octokit/plugin-rest-endpoint-methods": {
-      "version": "5.12.1",
-      "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-5.12.1.tgz",
-      "integrity": "sha512-0nY3htfl6x9UkPcqv8pm9vOC/bTA7f4IMDWln13neHRdNWQvOQgZ9fRxK7BAc74rye4yVINEFi9Yb9rnGUvosA==",
-      "dependencies": {
-        "@octokit/types": "^6.33.0",
-        "deprecation": "^2.3.1"
-      }
-    },
-    "node_modules/@octokit/plugin-retry": {
-      "version": "3.0.9",
-      "resolved": "https://registry.npmjs.org/@octokit/plugin-retry/-/plugin-retry-3.0.9.tgz",
-      "integrity": "sha512-r+fArdP5+TG6l1Rv/C9hVoty6tldw6cE2pRHNGmFPdyfrc696R6JjrQ3d7HdVqGwuzfyrcaLAKD7K8TX8aehUQ==",
-      "dependencies": {
-        "@octokit/types": "^6.0.3",
-        "bottleneck": "^2.15.3"
-      }
-    },
-    "node_modules/@octokit/plugin-throttling": {
-      "version": "3.5.2",
-      "resolved": "https://registry.npmjs.org/@octokit/plugin-throttling/-/plugin-throttling-3.5.2.tgz",
-      "integrity": "sha512-Eu7kfJxU8vmHqWGNszWpg+GVp2tnAfax3XQV5CkYPEE69C+KvInJXW9WajgSeW+cxYe0UVdouzCtcreGNuJo7A==",
-      "dependencies": {
-        "@octokit/types": "^6.0.1",
-        "bottleneck": "^2.15.3"
-      }
-    },
-    "node_modules/@octokit/request": {
-      "version": "5.6.2",
-      "resolved": "https://registry.npmjs.org/@octokit/request/-/request-5.6.2.tgz",
-      "integrity": "sha512-je66CvSEVf0jCpRISxkUcCa0UkxmFs6eGDRSbfJtAVwbLH5ceqF+YEyC8lj8ystKyZTy8adWr0qmkY52EfOeLA==",
-      "dependencies": {
-        "@octokit/endpoint": "^6.0.1",
-        "@octokit/request-error": "^2.1.0",
-        "@octokit/types": "^6.16.1",
-        "is-plain-object": "^5.0.0",
-        "node-fetch": "^2.6.1",
-        "universal-user-agent": "^6.0.0"
-      }
-    },
-    "node_modules/@octokit/request-error": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-2.1.0.tgz",
-      "integrity": "sha512-1VIvgXxs9WHSjicsRwq8PlR2LR2x6DwsJAaFgzdi0JfJoGSO8mYI/cHJQ+9FbN21aa+DrgNLnwObmyeSC8Rmpg==",
-      "dependencies": {
-        "@octokit/types": "^6.0.3",
-        "deprecation": "^2.0.0",
-        "once": "^1.4.0"
-      }
-    },
-    "node_modules/@octokit/rest": {
-      "version": "18.12.0",
-      "resolved": "https://registry.npmjs.org/@octokit/rest/-/rest-18.12.0.tgz",
-      "integrity": "sha512-gDPiOHlyGavxr72y0guQEhLsemgVjwRePayJ+FcKc2SJqKUbxbkvf5kAZEWA/MKvsfYlQAMVzNJE3ezQcxMJ2Q==",
-      "dependencies": {
-        "@octokit/core": "^3.5.1",
-        "@octokit/plugin-paginate-rest": "^2.16.8",
-        "@octokit/plugin-request-log": "^1.0.4",
-        "@octokit/plugin-rest-endpoint-methods": "^5.12.0"
-      }
-    },
-    "node_modules/@octokit/types": {
-      "version": "6.33.0",
-      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-6.33.0.tgz",
-      "integrity": "sha512-0zffZ048M0UhthyPXQHLz4038Ak46nMWZXkzlXvXB/M/L1jYPBceq4iZj4qjKVrvveaJrrgKdJ9+3yUuITfcCw==",
-      "dependencies": {
-        "@octokit/openapi-types": "^11.1.0"
-      }
-    },
-    "node_modules/balanced-match": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="
-    },
-    "node_modules/before-after-hook": {
-      "version": "2.2.2",
-      "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-2.2.2.tgz",
-      "integrity": "sha512-3pZEU3NT5BFUo/AD5ERPWOgQOCZITni6iavr5AUw5AUwQjMlI0kzu5btnyD39AF0gUEsDPwJT+oY1ORBJijPjQ=="
-    },
-    "node_modules/bottleneck": {
-      "version": "2.19.5",
-      "resolved": "https://registry.npmjs.org/bottleneck/-/bottleneck-2.19.5.tgz",
-      "integrity": "sha512-VHiNCbI1lKdl44tGrhNfU3lup0Tj/ZBMJB5/2ZbNXRCPuRCO7ed2mgcK4r17y+KB2EfuYuRaVlwNbAeaWGSpbw=="
-    },
-    "node_modules/brace-expansion": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "node_modules/concat-map": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s="
-    },
-    "node_modules/deprecation": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/deprecation/-/deprecation-2.3.1.tgz",
-      "integrity": "sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ=="
-    },
-    "node_modules/fs.realpath": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
-      "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8="
-    },
-    "node_modules/glob": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz",
-      "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==",
-      "dependencies": {
-        "fs.realpath": "^1.0.0",
-        "inflight": "^1.0.4",
-        "inherits": "2",
-        "minimatch": "^3.0.4",
-        "once": "^1.3.0",
-        "path-is-absolute": "^1.0.0"
-      },
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/inflight": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
-      "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
-      "dependencies": {
-        "once": "^1.3.0",
-        "wrappy": "1"
-      }
-    },
-    "node_modules/inherits": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
-    },
-    "node_modules/is-plain-object": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz",
-      "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/minimatch": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
-      "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
-      },
-      "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/node-fetch": {
-      "version": "2.6.7",
-      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.7.tgz",
-      "integrity": "sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==",
-      "dependencies": {
-        "whatwg-url": "^5.0.0"
-      },
-      "engines": {
-        "node": "4.x || >=6.0.0"
-      },
-      "peerDependencies": {
-        "encoding": "^0.1.0"
-      },
-      "peerDependenciesMeta": {
-        "encoding": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/once": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
-      "dependencies": {
-        "wrappy": "1"
-      }
-    },
-    "node_modules/path-is-absolute": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
-      "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/tr46": {
-      "version": "0.0.3",
-      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
-      "integrity": "sha1-gYT9NH2snNwYWZLzpmIuFLnZq2o="
-    },
-    "node_modules/universal-user-agent": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-6.0.0.tgz",
-      "integrity": "sha512-isyNax3wXoKaulPDZWHQqbmIx1k2tb9fb3GGDBRxCscfYV2Ch7WxPArBsFEG8s/safwXTT7H4QGhaIkTp9447w=="
-    },
-    "node_modules/webidl-conversions": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
-      "integrity": "sha1-JFNCdeKnvGvnvIZhHMFq4KVlSHE="
-    },
-    "node_modules/whatwg-url": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
-      "integrity": "sha1-lmRU6HZUYuN2RNNib2dCzotwll0=",
-      "dependencies": {
-        "tr46": "~0.0.3",
-        "webidl-conversions": "^3.0.0"
-      }
-    },
-    "node_modules/wrappy": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8="
-    }
-  },
-  "dependencies": {
-    "@octokit/auth-token": {
-      "version": "2.5.0",
-      "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-2.5.0.tgz",
-      "integrity": "sha512-r5FVUJCOLl19AxiuZD2VRZ/ORjp/4IN98Of6YJoJOkY75CIBuYfmiNHGrDwXr+aLGG55igl9QrxX3hbiXlLb+g==",
-      "requires": {
-        "@octokit/types": "^6.0.3"
-      }
-    },
-    "@octokit/core": {
-      "version": "3.5.1",
-      "resolved": "https://registry.npmjs.org/@octokit/core/-/core-3.5.1.tgz",
-      "integrity": "sha512-omncwpLVxMP+GLpLPgeGJBF6IWJFjXDS5flY5VbppePYX9XehevbDykRH9PdCdvqt9TS5AOTiDide7h0qrkHjw==",
-      "requires": {
-        "@octokit/auth-token": "^2.4.4",
-        "@octokit/graphql": "^4.5.8",
-        "@octokit/request": "^5.6.0",
-        "@octokit/request-error": "^2.0.5",
-        "@octokit/types": "^6.0.3",
-        "before-after-hook": "^2.2.0",
-        "universal-user-agent": "^6.0.0"
-      }
-    },
-    "@octokit/endpoint": {
-      "version": "6.0.12",
-      "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-6.0.12.tgz",
-      "integrity": "sha512-lF3puPwkQWGfkMClXb4k/eUT/nZKQfxinRWJrdZaJO85Dqwo/G0yOC434Jr2ojwafWJMYqFGFa5ms4jJUgujdA==",
-      "requires": {
-        "@octokit/types": "^6.0.3",
-        "is-plain-object": "^5.0.0",
-        "universal-user-agent": "^6.0.0"
-      }
-    },
-    "@octokit/graphql": {
-      "version": "4.8.0",
-      "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-4.8.0.tgz",
-      "integrity": "sha512-0gv+qLSBLKF0z8TKaSKTsS39scVKF9dbMxJpj3U0vC7wjNWFuIpL/z76Qe2fiuCbDRcJSavkXsVtMS6/dtQQsg==",
-      "requires": {
-        "@octokit/request": "^5.6.0",
-        "@octokit/types": "^6.0.3",
-        "universal-user-agent": "^6.0.0"
-      }
-    },
-    "@octokit/openapi-types": {
-      "version": "11.1.0",
-      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-11.1.0.tgz",
-      "integrity": "sha512-dWZfYvCCdjZzDYA3lIAMF72Q0jld8xidqCq5Ryw09eBJXZdcM6he0vWBTvw/b5UnGYqexxOyHWgfrsTlUJL3Gw=="
-    },
-    "@octokit/plugin-paginate-rest": {
-      "version": "2.16.9",
-      "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-2.16.9.tgz",
-      "integrity": "sha512-gfSCMgz5scFKsR0dW4jaYsDJVt/UwCHp4dF7sHlmSekZvwzvLiOAGZ4MQkEsL5DW9hIk2W+UQkYZMTA1b6Wsqw==",
-      "requires": {
-        "@octokit/types": "^6.33.0"
-      }
-    },
-    "@octokit/plugin-request-log": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/@octokit/plugin-request-log/-/plugin-request-log-1.0.4.tgz",
-      "integrity": "sha512-mLUsMkgP7K/cnFEw07kWqXGF5LKrOkD+lhCrKvPHXWDywAwuDUeDwWBpc69XK3pNX0uKiVt8g5z96PJ6z9xCFA=="
-    },
-    "@octokit/plugin-rest-endpoint-methods": {
-      "version": "5.12.1",
-      "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-5.12.1.tgz",
-      "integrity": "sha512-0nY3htfl6x9UkPcqv8pm9vOC/bTA7f4IMDWln13neHRdNWQvOQgZ9fRxK7BAc74rye4yVINEFi9Yb9rnGUvosA==",
-      "requires": {
-        "@octokit/types": "^6.33.0",
-        "deprecation": "^2.3.1"
-      }
-    },
-    "@octokit/plugin-retry": {
-      "version": "3.0.9",
-      "resolved": "https://registry.npmjs.org/@octokit/plugin-retry/-/plugin-retry-3.0.9.tgz",
-      "integrity": "sha512-r+fArdP5+TG6l1Rv/C9hVoty6tldw6cE2pRHNGmFPdyfrc696R6JjrQ3d7HdVqGwuzfyrcaLAKD7K8TX8aehUQ==",
-      "requires": {
-        "@octokit/types": "^6.0.3",
-        "bottleneck": "^2.15.3"
-      }
-    },
-    "@octokit/plugin-throttling": {
-      "version": "3.5.2",
-      "resolved": "https://registry.npmjs.org/@octokit/plugin-throttling/-/plugin-throttling-3.5.2.tgz",
-      "integrity": "sha512-Eu7kfJxU8vmHqWGNszWpg+GVp2tnAfax3XQV5CkYPEE69C+KvInJXW9WajgSeW+cxYe0UVdouzCtcreGNuJo7A==",
-      "requires": {
-        "@octokit/types": "^6.0.1",
-        "bottleneck": "^2.15.3"
-      }
-    },
-    "@octokit/request": {
-      "version": "5.6.2",
-      "resolved": "https://registry.npmjs.org/@octokit/request/-/request-5.6.2.tgz",
-      "integrity": "sha512-je66CvSEVf0jCpRISxkUcCa0UkxmFs6eGDRSbfJtAVwbLH5ceqF+YEyC8lj8ystKyZTy8adWr0qmkY52EfOeLA==",
-      "requires": {
-        "@octokit/endpoint": "^6.0.1",
-        "@octokit/request-error": "^2.1.0",
-        "@octokit/types": "^6.16.1",
-        "is-plain-object": "^5.0.0",
-        "node-fetch": "^2.6.1",
-        "universal-user-agent": "^6.0.0"
-      }
-    },
-    "@octokit/request-error": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-2.1.0.tgz",
-      "integrity": "sha512-1VIvgXxs9WHSjicsRwq8PlR2LR2x6DwsJAaFgzdi0JfJoGSO8mYI/cHJQ+9FbN21aa+DrgNLnwObmyeSC8Rmpg==",
-      "requires": {
-        "@octokit/types": "^6.0.3",
-        "deprecation": "^2.0.0",
-        "once": "^1.4.0"
-      }
-    },
-    "@octokit/rest": {
-      "version": "18.12.0",
-      "resolved": "https://registry.npmjs.org/@octokit/rest/-/rest-18.12.0.tgz",
-      "integrity": "sha512-gDPiOHlyGavxr72y0guQEhLsemgVjwRePayJ+FcKc2SJqKUbxbkvf5kAZEWA/MKvsfYlQAMVzNJE3ezQcxMJ2Q==",
-      "requires": {
-        "@octokit/core": "^3.5.1",
-        "@octokit/plugin-paginate-rest": "^2.16.8",
-        "@octokit/plugin-request-log": "^1.0.4",
-        "@octokit/plugin-rest-endpoint-methods": "^5.12.0"
-      }
-    },
-    "@octokit/types": {
-      "version": "6.33.0",
-      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-6.33.0.tgz",
-      "integrity": "sha512-0zffZ048M0UhthyPXQHLz4038Ak46nMWZXkzlXvXB/M/L1jYPBceq4iZj4qjKVrvveaJrrgKdJ9+3yUuITfcCw==",
-      "requires": {
-        "@octokit/openapi-types": "^11.1.0"
-      }
-    },
-    "balanced-match": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="
-    },
-    "before-after-hook": {
-      "version": "2.2.2",
-      "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-2.2.2.tgz",
-      "integrity": "sha512-3pZEU3NT5BFUo/AD5ERPWOgQOCZITni6iavr5AUw5AUwQjMlI0kzu5btnyD39AF0gUEsDPwJT+oY1ORBJijPjQ=="
-    },
-    "bottleneck": {
-      "version": "2.19.5",
-      "resolved": "https://registry.npmjs.org/bottleneck/-/bottleneck-2.19.5.tgz",
-      "integrity": "sha512-VHiNCbI1lKdl44tGrhNfU3lup0Tj/ZBMJB5/2ZbNXRCPuRCO7ed2mgcK4r17y+KB2EfuYuRaVlwNbAeaWGSpbw=="
-    },
-    "brace-expansion": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
-      "requires": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "concat-map": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s="
-    },
-    "deprecation": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/deprecation/-/deprecation-2.3.1.tgz",
-      "integrity": "sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ=="
-    },
-    "fs.realpath": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
-      "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8="
-    },
-    "glob": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz",
-      "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==",
-      "requires": {
-        "fs.realpath": "^1.0.0",
-        "inflight": "^1.0.4",
-        "inherits": "2",
-        "minimatch": "^3.0.4",
-        "once": "^1.3.0",
-        "path-is-absolute": "^1.0.0"
-      }
-    },
-    "inflight": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
-      "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
-      "requires": {
-        "once": "^1.3.0",
-        "wrappy": "1"
-      }
-    },
-    "inherits": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
-    },
-    "is-plain-object": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz",
-      "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q=="
-    },
-    "minimatch": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
-      "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
-      "requires": {
-        "brace-expansion": "^1.1.7"
-      }
-    },
-    "node-fetch": {
-      "version": "2.6.7",
-      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.7.tgz",
-      "integrity": "sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==",
-      "requires": {
-        "whatwg-url": "^5.0.0"
-      }
-    },
-    "once": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
-      "requires": {
-        "wrappy": "1"
-      }
-    },
-    "path-is-absolute": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
-      "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18="
-    },
-    "tr46": {
-      "version": "0.0.3",
-      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
-      "integrity": "sha1-gYT9NH2snNwYWZLzpmIuFLnZq2o="
-    },
-    "universal-user-agent": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-6.0.0.tgz",
-      "integrity": "sha512-isyNax3wXoKaulPDZWHQqbmIx1k2tb9fb3GGDBRxCscfYV2Ch7WxPArBsFEG8s/safwXTT7H4QGhaIkTp9447w=="
-    },
-    "webidl-conversions": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
-      "integrity": "sha1-JFNCdeKnvGvnvIZhHMFq4KVlSHE="
-    },
-    "whatwg-url": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
-      "integrity": "sha1-lmRU6HZUYuN2RNNib2dCzotwll0=",
-      "requires": {
-        "tr46": "~0.0.3",
-        "webidl-conversions": "^3.0.0"
-      }
-    },
-    "wrappy": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8="
-    }
-  }
-}

.github/workflows/scripts/releases/upload-release-artifacts/package.json

@@ -1,18 +0,0 @@
-{
-  "name": "upload-release-artifacts",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "type": "module",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "author": "",
-  "license": "ISC",
-  "dependencies": {
-    "@octokit/plugin-retry": "^3.0.9",
-    "@octokit/plugin-throttling": "^3.5.2",
-    "@octokit/rest": "^18.12.0",
-    "glob": "^7.2.0"
-  }
-}

.github/workflows/scripts/validation/lint-gamedb/lint-gamedb.py

@@ -1,256 +0,0 @@
-import yaml
-
-# Assumes this is ran from the root of the repository
-file_path = "./bin/resources/GameIndex.yaml"
-
-# These settings have to be manually kept in sync with the emulator code unfortunately.
-# up to date validation should ALWAYS be provided via the application!
-allowed_game_options = [
-    "name",
-    "region",
-    "compat",
-    "roundModes",
-    "clampModes",
-    "gameFixes",
-    "gsHWFixes",
-    "speedHacks",
-    "memcardFilters",
-    "patches",
-]
-allowed_round_modes = ["eeRoundMode", "vuRoundMode"]
-allowed_clamp_modes = ["eeClampMode", "vuClampMode"]
-allowed_game_fixes = [
-    "FpuMulHack",
-    "FpuNegDivHack",
-    "GoemonTlbHack",
-    "SoftwareRendererFMVHack",
-    "SkipMPEGHack",
-    "OPHFlagHack",
-    "EETimingHack",
-    "DMABusyHack",
-    "GIFFIFOHack",
-    "VIFFIFOHack",
-    "VIF1StallHack",
-    "VuAddSubHack",
-    "IbitHack",
-    "VUSyncHack",
-    "VUOverflowHack",
-    "XGKickHack",
-]
-allowed_gs_hw_fixes = [
-    "autoFlush",
-    "conservativeFramebuffer",
-    "cpuFramebufferConversion",
-    "disableDepthSupport",
-    "wrapGSMem",
-    "preloadFrameData",
-    "disablePartialInvalidation",
-    "textureInsideRT",
-    "alignSprite",
-    "mergeSprite",
-    "wildArmsHack",
-    "pointListPalette",
-    "mipmap",
-    "trilinearFiltering",
-    "skipDrawStart",
-    "skipDrawEnd",
-    "halfBottomOverride",
-    "halfPixelOffset",
-    "roundSprite",
-    "texturePreloading",
-    "deinterlace",
-]
-gs_hw_fix_ranges = {
-    "mipmap": (0, 2),
-    "trilinearFiltering": (0, 2),
-    "skipDrawStart": (0, 100000),
-    "skipDrawEnd": (0, 100000),
-    "halfPixelOffset": (0, 3),
-    "roundSprite": (0, 2),
-    "deinterlace": (0, 7),
-}
-allowed_speed_hacks = ["mvuFlagSpeedHack", "InstantVU1SpeedHack", "MTVUSpeedHack"]
-# Patches are allowed to have a 'default' key or a crc-32 key, followed by
-allowed_patch_options = ["author", "content"]
-
-issue_list = []
-
-
-def is_hex_number(string):
-    try:
-        int(string, 16)
-        return True
-    except Exception:
-        return False
-
-
-def validate_string_option(serial, key, value):
-    if not isinstance(value, str):
-        issue_list.append("[{}]: '{}' must be a string".format(serial, key))
-
-
-def validate_int_option(serial, key, value, low, high):
-    if not isinstance(value, int) or (value < low or value > high):
-        issue_list.append(
-            "[{}]: '{}' must be an int and between {}-{} (inclusive)".format(
-                serial, key, low, high
-            )
-        )
-
-
-def validate_list_of_strings(serial, key, value):
-    if not isinstance(value, list) or not all(isinstance(item, str) for item in value):
-        issue_list.append("[{}]: '{}' must be a list of strings".format(serial, key))
-
-
-def validate_valid_options(serial, key, value, allowed_values):
-    if value not in allowed_values:
-        issue_list.append("[{}]: Invalid '{}' option [{}]".format(serial, key, value))
-
-
-def validate_clamp_round_modes(serial, key, value, allowed_values):
-    if not isinstance(value, dict):
-        issue_list.append("[{}]: '{}' must be a valid object".format(serial, key))
-        return
-    for mode_key, mode_value in value.items():
-        validate_valid_options(serial, key, mode_key, allowed_values)
-        validate_int_option(serial, key, mode_value, 0, 3)
-
-
-def validate_game_fixes(serial, key, value):
-    if not isinstance(value, list):
-        issue_list.append(
-            "[{}]: 'gameFixes' must be a list of valid gameFixes".format(serial)
-        )
-        return
-    for gamefix in value:
-        validate_valid_options(serial, key, gamefix, allowed_game_fixes)
-
-
-def validate_gs_hw_fix_value(serial, key, value):
-    low, high = 0, 1
-    if key in gs_hw_fix_ranges:
-        low, high = gs_hw_fix_ranges[key]
-    validate_int_option(serial, key, value, low, high)
-
-
-def validate_gs_hw_fixes(serial, key, value):
-    if not isinstance(value, dict):
-        issue_list.append("[{}]: 'gsHWFixes' must be a valid object".format(serial))
-        return
-    for fix, fix_value in value.items():
-        validate_valid_options(serial, key, fix, allowed_gs_hw_fixes)
-        validate_gs_hw_fix_value(serial, fix, fix_value)
-
-    # skipdraw range must have end >= start
-    skip_draw_start = value["skipDrawStart"] if "skipDrawStart" in value else 0
-    skip_draw_end = value["skipDrawEnd"] if "skipDrawEnd" in value else 0
-    if isinstance(skip_draw_start, int) and isinstance(skip_draw_end, int) and skip_draw_end < skip_draw_start:
-        issue_list.append("[{}]: skipDrawStart({}) must be greater or equal to skipDrawEnd({})".format(
-            serial, skip_draw_start, skip_draw_end))
-
-
-def validate_speed_hacks(serial, key, value):
-    if not isinstance(value, dict):
-        issue_list.append("[{}]: 'speedHacks' must be a valid object".format(serial))
-        return
-    for speedhack, speedhack_value in value.items():
-        validate_valid_options(serial, key, speedhack, allowed_speed_hacks)
-        validate_int_option(serial, speedhack, speedhack_value, 0, 1)
-
-
-def validate_patches(serial, key, value):
-    if not isinstance(value, dict):
-        issue_list.append(
-            "[{}]: 'patches' must be valid mapping of CRC32 -> Patch Objects".format(
-                serial
-            )
-        )
-        return
-    for crc, patch in value.items():
-        if crc != "default" and not is_hex_number(str(crc)):
-            issue_list.append(
-                "[{}]: Patches must either be key'd with 'default' or a valid CRC-32 Hex String".format(
-                    serial
-                )
-            )
-            continue
-        for patch_option, option_value in patch.items():
-            validate_valid_options(serial, key, patch_option, allowed_patch_options)
-            if patch_option == "author":
-                validate_string_option(serial, patch_option, option_value)
-            if patch_option == "content":
-                validate_string_option(serial, patch_option, option_value)
-
-
-# pylint:disable=unnecessary-lambda
-option_validation_handlers = {
-    "name": (lambda serial, key, value: validate_string_option(serial, key, value)),
-    "region": (lambda serial, key, value: validate_string_option(serial, key, value)),
-    "compat": (
-        lambda serial, key, value: validate_int_option(serial, key, value, 0, 6)
-    ),
-    "roundModes": (
-        lambda serial, key, value: validate_clamp_round_modes(
-            serial, key, value, allowed_round_modes
-        )
-    ),
-    "clampModes": (
-        lambda serial, key, value: validate_clamp_round_modes(
-            serial, key, value, allowed_clamp_modes
-        )
-    ),
-    "gameFixes": (lambda serial, key, value: validate_game_fixes(serial, key, value)),
-    "gsHWFixes": (lambda serial, key, value: validate_gs_hw_fixes(serial, key, value)),
-    "speedHacks": (lambda serial, key, value: validate_speed_hacks(serial, key, value)),
-    "memcardFilters": (
-        lambda serial, key, value: validate_list_of_strings(serial, key, value)
-    ),
-    "patches": (lambda serial, key, value: validate_patches(serial, key, value)),
-}
-
-print("Opening {}...".format(file_path))
-with open(file_path) as f:
-    try:
-        print("Attempting to parse GameDB file...")
-        gamedb = yaml.load(f, Loader=yaml.FullLoader)
-    except Exception as err:
-        print(err)
-        print(
-            "Unable to parse GameDB. Exiting, verify that the file indeed is valid YAML."
-        )
-        exit(1)
-
-    print("File loaded successfully, validating schema...")
-    progress_counter = 0
-    for serial, game_options in gamedb.items():
-        progress_counter = progress_counter + 1
-        if progress_counter % 500 == 0 or progress_counter >= len(gamedb.items()):
-            print(
-                "[{}/{}] Processing GameDB Entries...".format(
-                    progress_counter, len(gamedb.items())
-                )
-            )
-
-        # Check for required values
-        if not "name" in game_options.keys():
-            issue_list.append("[{}]: 'name' is a required value".format(serial))
-        if not "region" in game_options.keys():
-            issue_list.append("[{}]: 'region' is a required value".format(serial))
-
-        # Check the options
-        for key, value in game_options.items():
-            if key not in allowed_game_options:
-                issue_list.append("[{}]: Invalid option [{}]".format(serial, key))
-                continue
-
-            if key in option_validation_handlers:
-                option_validation_handlers[key](serial, key, value)
-
-if len(issue_list) > 0:
-    print("Issues found during validation:")
-    print(*issue_list, sep="\n")
-    exit(1)
-else:
-    print("GameDB Validated Successfully!")
-    exit(0)

.github/workflows/scripts/validation/lint-gamedb/requirements.txt

@@ -1 +0,0 @@
-PyYAML==5.4.1

.github/workflows/update-controller-db.yml

@@ -1,29 +0,0 @@
-name: 🏭 Update Controller Database
-
-on:
-  schedule:
-    - cron: "0 16 * * 1" # every monday @ 12pm EST - https://crontab.guru/#0_16_*_*_1
-
-jobs:
-  update-controller-db:
-    if: github.repository == 'PCSX2/pcsx2'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Get Latest DB and Prepare DB File
-        run: |
-          cd .github/workflows/scripts/controller-db/
-          wget -O game_controller_db.txt https://raw.githubusercontent.com/gabomdq/SDL_GameControllerDB/master/gamecontrollerdb.txt
-          python ./update-db.py
-          mv ./game_controller_db.txt ${{github.workspace}}/bin/resources/game_controller_db.txt
-
-      - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v4
-        with:
-          title: "PAD: Update to latest controller database"
-          commit-message: "PAD: Update to latest controller database."
-          committer: "PCSX2 Bot <PCSX2Bot@users.noreply.github.com>"
-          author: "PCSX2 Bot <PCSX2Bot@users.noreply.github.com>"
-          body: "Weekly automatic update of SDL Controller DB"
-          reviewers: lightningterror

.github/workflows/windows-workflow.yml

@@ -1,206 +0,0 @@
-name: 🖥️ Windows Builds
-
-# Controls when the action will run. Triggers the workflow on push or pull request
-# events but only for the master branch
-on:
-  push:
-    branches:
-      - master
-    tags:
-      - v*
-  pull_request:
-    branches:
-      - master
-    paths-ignore:
-      - '**/*.md'
-      - '.clang-format'
-      - '.codacy.yaml'
-      - '.github/*'
-      - '.github/workflows/lint-gamedb.yml'
-      - '.github/workflows/linux-workflow.yml'
-      - '.github/workflows/macos-workflow.yml'
-      - '.github/workflows/scripts/linux/**'
-      - '.github/workflows/scripts/validation/**'
-      - '.gitignore'
-      - 'bin/PCSX2_keys.ini.default'
-      - 'build.sh'
-      - 'buildbot.xml'
-      - 'linux_various/**'
-      - 'mscompile.cmd'
-      - 'pcsx2/CDVD/Linux/**'
-      - 'pcsx2/DEV9/Linux/**'
-      - 'pcsx2/Linux/**'
-      - 'pcsx2/PAD/Linux/**'
-      - 'pcsx2/SPU2/Linux/**'
-      - 'pcsx2/USB/linux/**'
-
-jobs:
-  build:
-    strategy:
-      # Prevent one build from failing everything (although maybe those should be included as experimental builds instead)
-      fail-fast: false
-      matrix:
-        os: [windows-2019]
-        platform: [x64]
-        configuration: [Release, Release AVX2, CMake, Qt]
-        experimental: [false]
-
-    name: ${{ matrix.configuration }}
-    runs-on: ${{ matrix.os }}
-    continue-on-error: ${{ matrix.experimental }}
-    # Set some sort of timeout in the event of run-away builds.  We are limited on concurrent jobs so, get rid of them.
-    timeout-minutes: 60
-
-    env:
-      POWERSHELL_TELEMETRY_OPTOUT: 1
-      BUILDCACHE_COMPRESS_FORMAT: ZSTD
-      BUILDCACHE_COMPRESS_LEVEL: 9
-      BUILDCACHE_MAX_CACHE_SIZE: 536870912 # 512MB
-      BUILDCACHE_DIRECT_MODE: true
-      BUILDCACHE_LOG_FILE: ${{ github.workspace }}\buildcache.log
-
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v3
-
-      - name: Checkout Submodules
-        run: git submodule update --init --recursive -j $env:NUMBER_OF_PROCESSORS
-
-      - name: Setup Buildcache
-        if: matrix.configuration == 'CMake' # TODO: buildcache on VS
-        uses: mikehardy/buildcache-action@v1.2.2
-        with:
-          cache_key: ${{ matrix.os }} ${{ matrix.platform }} ${{ matrix.configuration }}
-
-      - name: Verify VS Project Files
-        if: matrix.configuration != 'CMake'
-        run: .github\workflows\scripts\windows\validate-vs-filters.ps1
-
-      - name: Setup msbuild
-        if: matrix.configuration != 'CMake'
-        uses: microsoft/setup-msbuild@v1
-
-      - name: Download Qt build files
-        if: matrix.configuration == 'Qt'
-        shell: cmd
-        run: |
-          cd 3rdparty\qt
-          aria2c https://github.com/PCSX2/pcsx2-windows-dependencies/releases/download/2022-04-13/qt-6.3.0-x64.7z
-          7z x qt-6.3.0-x64.7z
-          del qt-6.3.0-x64.7z
-
-      - name: Generate CMake
-        if: matrix.configuration == 'CMake'
-        id: cmake
-        shell: cmd
-        run: |
-          if "${{ github.event.inputs.retainDebugArtifacts }}"=="true" (SET type=RelWithDebInfo) else (SET type=Release)
-          if "${{ matrix.platform }}"=="Win32" (SET vcvars=vcvarsamd64_x86.bat) else (SET vcvars=vcvars64.bat)
-          call "%ProgramFiles(x86)%\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\%vcvars%"
-          echo ::set-output name=buildtype::%type%
-          echo ::set-output name=vcvars::%vcvars%
-          cmake . -B build -DCMAKE_BUILD_TYPE=%type% -DLTO_PCSX2_CORE=ON -G Ninja -DCMAKE_C_COMPILER_LAUNCHER=..\buildcache\bin\buildcache.exe -DCMAKE_CXX_COMPILER_LAUNCHER=..\buildcache\bin\buildcache.exe -DCMAKE_DISABLE_PRECOMPILE_HEADERS=ON
-
-      - name: Build PCSX2
-        shell: cmd
-        env:
-          # Set to 'true' to retain the .pdb / .exp / .lib, etc files which can be useful for repro'ing issues that only occur in the compiled .exe
-          RetainDebuggingArtifacts: ${{ github.event.inputs.retainDebugArtifacts == 'true' }}
-        run: |
-          if "${{ matrix.configuration }}"=="CMake" (
-            call "%ProgramFiles(x86)%\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\${{ steps.cmake.outputs.vcvars }}"
-            cmake --build build --config ${{ steps.cmake.outputs.buildtype }}
-          ) else (
-              if "${{ matrix.configuration }}"=="Qt" (
-                rem This is hardcoded to Release AVX2 for now, because of the artifact naming below.
-                msbuild "PCSX2_qt.sln" /m /v:m /p:Configuration="Release AVX2" /p:Platform="${{ matrix.platform }}"
-              ) else (
-                msbuild "PCSX2_suite.sln" /m /v:m /p:Configuration="${{ matrix.configuration }}" /p:Platform="${{ matrix.platform }}"
-              )
-          )
-
-      - name: Run Tests
-        if: matrix.configuration == 'CMake'
-        shell: cmd
-        run: |
-          call "%ProgramFiles(x86)%\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\${{ steps.cmake.outputs.vcvars }}"
-          cmake --build build --config ${{ steps.cmake.outputs.buildtype }} --target unittests
-
-      - name: Prepare Artifact Metadata
-        id: artifact-metadata
-        shell: bash
-        run: |
-          ARCH=$([ "${{ matrix.platform }}" == Win32 ] && echo "32bit" || echo "64bit")
-          case "${{ matrix.configuration }}" in
-            Release) SIMD="SSE4";;
-            *AVX2)   SIMD="AVX2";;
-            Qt)      SIMD="QT";;
-            CMake)   SIMD="CMake"
-                     cp build/pcsx2/pcsx2* bin/ ;;
-            *)       SIMD="UNKNOWN";;
-          esac
-          if [ ${{ github.event_name }} == "pull_request" ]; then
-            PR_SHA=$(git rev-parse --short "${{ github.event.pull_request.head.sha }}")
-            ARTIFACT_NAME="PCSX2-${ARCH}-${SIMD}"
-            if [ ! -z "${{ github.event.pull_request.number }}" ]; then
-              PR_NUM=${{ github.event.pull_request.number }}
-              ARTIFACT_NAME="${ARTIFACT_NAME}-pr[${PR_NUM}]"
-            fi
-            ARTIFACT_NAME="${ARTIFACT_NAME}-sha[${PR_SHA}]"
-            if [ ! -z "${{ github.event.pull_request.title }}" ]; then
-              PR_TITLE=$(echo "${{ github.event.pull_request.title }}" | tr -cd '[a-zA-Z0-9[:space:]]_-')
-              ARTIFACT_NAME="${ARTIFACT_NAME}-title["${PR_TITLE}""
-            fi
-          else
-            SHA=$(git rev-parse --short "$GITHUB_SHA")
-            ARTIFACT_NAME="PCSX2-${ARCH}-${SIMD}-sha[${SHA}"
-          fi
-          TRIMMED_ARTIFACT_NAME=$(printf "%.199s]" "$ARTIFACT_NAME")
-          echo "name=$TRIMMED_ARTIFACT_NAME"
-          echo "##[set-output name=name;]${TRIMMED_ARTIFACT_NAME}"
-          echo "##[set-output name=arch;]${ARCH}"
-          echo "##[set-output name=simd;]${SIMD}"
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v3
-        continue-on-error: true
-        with:
-          name: ${{ steps.artifact-metadata.outputs.name }}
-          path: |
-            ./bin
-            !./bin/**/*.bsc
-            !./bin/**/*.exp
-            !./bin/**/*.ilk
-            !./bin/**/*.iobj
-            !./bin/**/*.ipdb
-            !./bin/**/*.pdb
-            !./bin/**/*.lib
-
-      - name: Upload artifact - with symbols
-        if: matrix.configuration != 'CMake'
-        uses: actions/upload-artifact@v3
-        continue-on-error: true
-        with:
-          name: ${{ steps.artifact-metadata.outputs.name }}-symbols
-          path: ./bin/**/*.pdb
-
-      # ---- Release / Tagging related steps ----
-      - name: Prepare Build Artifacts
-        if: github.repository == 'PCSX2/pcsx2' && startsWith(github.ref, 'refs/tags/') && matrix.configuration != 'CMake' && matrix.configuration != 'Qt'
-        run: |
-          mkdir -p ./ci-artifacts/
-          7z a ./ci-artifacts/windows-${{ steps.artifact-metadata.outputs.arch }}-${{ steps.artifact-metadata.outputs.simd }}.7z ./bin/* '-xr!*bsc' '-xr!*.exp' '-xr!*.ilk' '-xr!*.iobj' '-xr!*.ipdb' '-xr!*.pdb' '-xr!*.lib'
-          7z a ./ci-artifacts/windows-${{ steps.artifact-metadata.outputs.arch }}-${{ steps.artifact-metadata.outputs.simd }}-symbols.7z ./bin/*.pdb
-          ls ./ci-artifacts/
-
-      - name: Upload Assets and Potential Publish Release
-        if: github.repository == 'PCSX2/pcsx2' && startsWith(github.ref, 'refs/tags/') && matrix.configuration != 'CMake' && matrix.configuration != 'Qt'
-        env:
-          GITHUB_TOKEN: ${{ secrets.BOT_PAT }}
-          ASSET_DIR: ${{ github.WORKSPACE }}/ci-artifacts
-          ASSET_EXTENSION: 7z
-          TAG_TO_SEARCH_FOR: ${{ github.REF }}
-        run: |
-          cd ./.github/workflows/scripts/releases/upload-release-artifacts
-          npm ci
-          node index.js

.github/workflows/windows_build_matrix.yml

@@ -0,0 +1,84 @@
+name: 🖥️ Windows Builds
+
+on:
+  push:
+    branches-ignore:
+      - "l10n_master"
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  # MSBUILD
+  lint_vs_proj_files:
+    name: Lint VS Project Files
+    if: github.repository != 'PCSX2/pcsx2' || github.event_name == 'pull_request'
+    runs-on: windows-2019
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v3
+      - name: Verify VS Project Files
+        run: .github\workflows\scripts\windows\validate-vs-filters.ps1
+
+  build_qt_sse4:
+    needs: lint_vs_proj_files
+    name: "SSE4"
+    if: github.repository != 'PCSX2/pcsx2' || github.event_name == 'pull_request'
+    uses: ./.github/workflows/windows_build_qt.yml
+    with:
+      jobName: "MSVC SSE4"
+      configuration: Release
+      simd: "SSE4"
+    secrets: inherit
+
+  build_qt_avx2:
+    needs: lint_vs_proj_files
+    name: "AVX2"
+    if: github.repository != 'PCSX2/pcsx2' || github.event_name == 'pull_request'
+    uses: ./.github/workflows/windows_build_qt.yml
+    with:
+      jobName: "MSVC AVX2"
+      configuration: Release AVX2
+    secrets: inherit
+
+  build_qt_cmake:
+    name: "CMake"
+    if: github.repository != 'PCSX2/pcsx2' || github.event_name == 'pull_request'
+    uses: ./.github/workflows/windows_build_qt.yml
+    with:
+      jobName: "CMake MSVC"
+      configuration: CMake
+      buildSystem: cmake
+    secrets: inherit
+
+  build_qt_clang_sse4:
+    needs: lint_vs_proj_files
+    name: "SSE4"
+    if: github.repository != 'PCSX2/pcsx2' || github.event_name == 'pull_request'
+    uses: ./.github/workflows/windows_build_qt.yml
+    with:
+      jobName: "Clang SSE4"
+      configuration: Release Clang
+      simd: "SSE4"
+    secrets: inherit
+
+  build_qt_clang_avx2:
+    needs: lint_vs_proj_files
+    name: "AVX2"
+    if: github.repository != 'PCSX2/pcsx2' || github.event_name == 'pull_request'
+    uses: ./.github/workflows/windows_build_qt.yml
+    with:
+      jobName: "Clang AVX2"
+      configuration: Release Clang AVX2
+    secrets: inherit
+
+  build_qt_cmake_clang:
+    name: "CMake"
+    if: github.repository != 'PCSX2/pcsx2' || github.event_name == 'pull_request'
+    uses: ./.github/workflows/windows_build_qt.yml
+    with:
+      jobName: "CMake Clang"
+      configuration: CMake
+      buildSystem: cmake
+      cmakeFlags: -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl -DPCSX2_EXE_NAME=pcsx2-qt-clang
+    secrets: inherit

.github/workflows/windows_build_qt.yml

@@ -0,0 +1,145 @@
+name: Windows Build Steps - Qt
+
+on:
+  workflow_call:
+    inputs:
+      jobName:
+        required: true
+        type: string
+      os:
+        required: false
+        type: string
+        default: windows-2022
+      platform:
+        required: false
+        type: string
+        default: x64
+      configuration:
+        required: true
+        type: string
+      simd:
+        required: false
+        type: string
+        default: AVX2
+      buildSystem:
+        required: false
+        type: string
+        default: msbuild
+      cmakeFlags:
+        required: false
+        type: string
+        default: ""
+      qt_binary_url:
+        required: false
+        type: string
+        default: https://github.com/PCSX2/pcsx2-windows-dependencies/releases/download/2023-04-25/qt-6.5.0-x64.7z
+      qt_dir:
+        required: false
+        type: string
+        default: 3rdparty\qt\6.5.0\msvc2022_64
+      patchesUrl:
+        required: false
+        type: string
+        default: https://github.com/PCSX2/pcsx2_patches/releases/latest/download
+      fetchTags:
+        required: false
+        type: boolean
+        default: false
+
+jobs:
+  build_windows_qt:
+    name: ${{ inputs.jobName }}
+    runs-on: ${{ inputs.os }}
+    # Set some sort of timeout in the event of run-away builds.  We are limited on concurrent jobs so, get rid of them.
+    timeout-minutes: 60
+    env:
+      POWERSHELL_TELEMETRY_OPTOUT: 1
+
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+
+      # actions/checkout elides tags, fetch them primarily for releases
+      - name: Fetch Tags
+        if: ${{ inputs.fetchTags }}
+        run: git fetch --tags --no-recurse-submodules
+
+      - name: Prepare Artifact Metadata
+        id: artifact-metadata
+        shell: bash
+        env:
+          OS: windows
+          BUILD_SYSTEM: ${{ inputs.buildSystem }}
+          ARCH: ${{ inputs.platform }}
+          SIMD: ${{ inputs.simd }}
+          EVENT_NAME: ${{ github.event_name }}
+          PR_TITLE: ${{ github.event.pull_request.title }}
+          PR_NUM: ${{ github.event.pull_request.number }}
+          PR_SHA: ${{ github.event.pull_request.head.sha }}
+        run: ./.github/workflows/scripts/common/name-artifacts.sh
+
+      - name: Setup msbuild
+        if: inputs.configuration != 'CMake'
+        uses: microsoft/setup-msbuild@v1
+
+      - name: Download Qt build files
+        shell: cmd
+        run: |
+          cd 3rdparty\qt
+          aria2c ${{ inputs.qt_binary_url }}
+          7z x qt-*-x64.7z
+          del qt-*-x64.7z
+
+      - name: Download patches
+        shell: cmd
+        run: |
+          cd bin/resources
+          aria2c -Z "${{ inputs.patchesUrl }}/patches.zip"
+
+      - name: Generate CMake
+        if: inputs.configuration == 'CMake'
+        id: cmake
+        shell: cmd
+        run: |
+          call "%ProgramFiles%\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+          cmake . -B build ${{ inputs.cmakeFlags }} "-DCMAKE_PREFIX_PATH=%cd%\${{ inputs.qt_dir }}" -DQT_BUILD=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON -DDISABLE_ADVANCE_SIMD=ON -G Ninja
+
+      - name: Build PCSX2
+        shell: cmd
+        run: |
+          if "${{ inputs.configuration }}"=="CMake" (
+            call "%ProgramFiles%\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+            cmake --build build --config Release || exit /b
+            cmake --install build --config Release || exit /b
+          ) else (
+            msbuild "PCSX2_qt.sln" /m /v:m /p:Configuration="${{ inputs.configuration }}" /p:Platform="${{ inputs.platform }}"
+          )
+
+      - name: Run Tests
+        if: inputs.configuration == 'CMake'
+        shell: cmd
+        run: |
+          call "%ProgramFiles%\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+          cmake --build build --config Release --target unittests
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ steps.artifact-metadata.outputs.artifact-name }}
+          path: |
+            ./bin
+            !./bin/**/*.bsc
+            !./bin/**/*.exp
+            !./bin/**/*.ilk
+            !./bin/**/*.iobj
+            !./bin/**/*.ipdb
+            !./bin/**/*.pdb
+            !./bin/**/*.lib
+
+      - name: Upload artifact - with symbols
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ steps.artifact-metadata.outputs.artifact-name }}-symbols
+          path: ./bin/**/*.pdb

.gitignore

@@ -30,15 +30,11 @@
 **/x64/Debug*
 **/x64/Devel*
 
-**/bin/PCSX2-linux.sh
-
 _ReSharper.*
 pcsx2.snapshot_*
 svnrev.h
 
-/build
-/build_dev
-/build_dbg
+/build*
 /obj-*
 *.obj
 
@@ -47,8 +43,7 @@ Thumbs.db
 
 Debug.txt
 install_log.txt
-padLog.txt
-GS_opengl_debug.txt
+bad_shader_*
 
 Debug
 Release
@@ -68,14 +63,12 @@ oprofile_data/
 /.vscode*
 
 /bin/**/*.dll
+/bin/**/*.dmp
 /bin/**/*.exp
 /bin/**/*.ilk
 /bin/**/*.lib
 /bin/**/*.pdb
-/bin/pcsx2
-/bin/PCSX2-linux.sh
-/bin/*ReplayLoader
-/bin/GS*.txt
+/bin/pcsx2*
 /bin/qt.conf
 /bin/bios
 /bin/cache
@@ -92,14 +85,11 @@ oprofile_data/
 /bin/sstates
 /bin/textures
 /bin/translations
+/bin/inputprofiles
 /deps
 /ipch
 
 !/3rdparty/libjpeg/change.log
-/3rdparty/**/include/wx/setup.h
-/3rdparty/**/wx/msw/rcdefs.h
-/pcsx2/gui/Resources/*.h
-!/pcsx2/gui/Resources/EmbeddedImage.h
 /tools/bin
 .vs
 

.gitmodules

@@ -14,16 +14,10 @@
 	path = 3rdparty/wil
 	url = https://github.com/microsoft/wil.git
 	branch = master
-[submodule "3rdparty/cubeb/cubeb"]
-	path = 3rdparty/cubeb/cubeb
-	url = https://github.com/mozilla/cubeb.git
 [submodule "3rdparty/rapidyaml/rapidyaml"]
 	path = 3rdparty/rapidyaml/rapidyaml
 	url = https://github.com/biojppm/rapidyaml.git
 	branch = master
-[submodule "3rdparty/imgui/imgui"]
-	path = 3rdparty/imgui/imgui
-	url = https://github.com/ocornut/imgui.git
 [submodule "3rdparty/glslang/glslang"]
 	path = 3rdparty/glslang/glslang
 	url = https://github.com/KhronosGroup/glslang.git
@@ -39,3 +33,6 @@
 [submodule "3rdparty/zstd/zstd"]
 	path = 3rdparty/zstd/zstd
 	url = https://github.com/facebook/zstd.git
+[submodule "3rdparty/rcheevos/rcheevos"]
+	path = 3rdparty/rcheevos/rcheevos
+	url = https://github.com/RetroAchievements/rcheevos.git

.prettierrc.yaml

@@ -0,0 +1,8 @@
+overrides:
+  - files: "**/GameIndex.yaml"
+    options:
+      tabWidth: 2
+      useTabs: false
+      quoteProps: consistent
+      endOfLine: auto
+      proseWrap: preserve

3rdparty/3rdparty.props

@@ -9,10 +9,10 @@
   <ItemDefinitionGroup>
     <ClCompile>
       <AdditionalIncludeDirectories>$(ProjectDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>__WIN32__;WIN32;_WINDOWS;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <StructMemberAlignment>16Bytes</StructMemberAlignment>
+      <PreprocessorDefinitions>__WIN32__;WIN32;_WINDOWS;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE;_HAS_EXCEPTIONS=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <ExceptionHandling>false</ExceptionHandling>
       <WarningLevel>TurnOffAllWarnings</WarningLevel>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <CompileAs>Default</CompileAs>

3rdparty/baseclasses/CMakeLists.txt

@@ -1,55 +0,0 @@
-add_library(baseclasses
-	amextra.cpp
-	amfilter.cpp
-	amvideo.cpp
-	combase.cpp
-	ctlutil.cpp
-	ddmm.cpp
-	mtype.cpp
-	outputq.cpp
-	pstream.cpp
-	pullpin.cpp
-	refclock.cpp
-	renbase.cpp
-	schedule.cpp
-	seekpt.cpp
-	source.cpp
-	strmctl.cpp
-	sysclock.cpp
-	transfrm.cpp
-	transip.cpp
-	vtrans.cpp
-	wxdebug.cpp
-	wxlist.cpp
-	wxutil.cpp
-	amextra.h
-	amfilter.h
-	cache.h
-	combase.h
-	ctlutil.h
-	ddmm.h
-	fourcc.h
-	measure.h
-	msgthrd.h
-	mtype.h
-	outputq.h
-	pstream.h
-	pullpin.h
-	refclock.h
-	reftime.h
-	renbase.h
-	schedule.h
-	seekpt.h
-	source.h
-	streams.h
-	strmctl.h
-	sysclock.h
-	transfrm.h
-	transip.h
-	vtrans.h
-	wxdebug.h
-	wxlist.h
-	wxutil.h
-)
-target_include_directories(baseclasses PUBLIC .)
-target_precompile_headers(baseclasses PRIVATE streams.h)

3rdparty/baseclasses/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) Microsoft Corporation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- THE SOFTWARE.

3rdparty/baseclasses/amextra.cpp

@@ -1,111 +0,0 @@
-//------------------------------------------------------------------------------
-// File: AMExtra.cpp
-//
-// Desc: DirectShow base classes - implements CRenderedInputPin class.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-#include <streams.h>        // DirectShow base class definitions
-#include <mmsystem.h>       // Needed for definition of timeGetTime
-#include <limits.h>         // Standard data type limit definitions
-#include <measure.h>        // Used for time critical log functions
-
-#include "amextra.h"
-
-#pragma warning(disable:4355)
-
-//  Implements CRenderedInputPin class
-
-CRenderedInputPin::CRenderedInputPin(__in_opt LPCTSTR pObjectName,
-                                     __in CBaseFilter *pFilter,
-                                     __in CCritSec *pLock,
-                                     __inout HRESULT *phr,
-                                     __in_opt LPCWSTR pName) :
-    CBaseInputPin(pObjectName, pFilter, pLock, phr, pName),
-    m_bAtEndOfStream(FALSE),
-    m_bCompleteNotified(FALSE)
-{
-}
-#ifdef UNICODE
-CRenderedInputPin::CRenderedInputPin(__in_opt LPCSTR pObjectName,
-                                     __in CBaseFilter *pFilter,
-                                     __in CCritSec *pLock,
-                                     __inout HRESULT *phr,
-                                     __in_opt LPCWSTR pName) :
-    CBaseInputPin(pObjectName, pFilter, pLock, phr, pName),
-    m_bAtEndOfStream(FALSE),
-    m_bCompleteNotified(FALSE)
-{
-}
-#endif
-
-// Flush end of stream condition - caller should do any
-// necessary stream level locking before calling this
-
-STDMETHODIMP CRenderedInputPin::EndOfStream()
-{
-    HRESULT hr = CheckStreaming();
-
-    //  Do EC_COMPLETE handling for rendered pins
-    if (S_OK == hr  && !m_bAtEndOfStream) {
-        m_bAtEndOfStream = TRUE;
-        FILTER_STATE fs;
-        EXECUTE_ASSERT(SUCCEEDED(m_pFilter->GetState(0, &fs)));
-        if (fs == State_Running) {
-            DoCompleteHandling();
-        }
-    }
-    return hr;
-}
-
-
-// Called to complete the flush
-
-STDMETHODIMP CRenderedInputPin::EndFlush()
-{
-    CAutoLock lck(m_pLock);
-
-    // Clean up renderer state
-    m_bAtEndOfStream = FALSE;
-    m_bCompleteNotified = FALSE;
-
-    return CBaseInputPin::EndFlush();
-}
-
-
-// Notify of Run() from filter
-
-HRESULT CRenderedInputPin::Run(REFERENCE_TIME tStart)
-{
-    UNREFERENCED_PARAMETER(tStart);
-    m_bCompleteNotified = FALSE;
-    if (m_bAtEndOfStream) {
-        DoCompleteHandling();
-    }
-    return S_OK;
-}
-
-
-//  Clear status on going into paused state
-
-HRESULT CRenderedInputPin::Active()
-{
-    m_bAtEndOfStream = FALSE;
-    m_bCompleteNotified = FALSE;
-    return CBaseInputPin::Active();
-}
-
-
-//  Do stuff to deliver end of stream
-
-void CRenderedInputPin::DoCompleteHandling()
-{
-    ASSERT(m_bAtEndOfStream);
-    if (!m_bCompleteNotified) {
-        m_bCompleteNotified = TRUE;
-        m_pFilter->NotifyEvent(EC_COMPLETE, S_OK, (LONG_PTR)(IBaseFilter *)m_pFilter);
-    }
-}
-

3rdparty/baseclasses/amextra.h

@@ -1,56 +0,0 @@
-//------------------------------------------------------------------------------
-// File: AMExtra.h
-//
-// Desc: DirectShow base classes.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-#ifndef __AMEXTRA__
-#define __AMEXTRA__
-
-// Simple rendered input pin
-//
-// NOTE if your filter queues stuff before rendering then it may not be
-// appropriate to use this class
-//
-// In that case queue the end of stream condition until the last sample
-// is actually rendered and flush the condition appropriately
-
-class CRenderedInputPin : public CBaseInputPin
-{
-public:
-
-    CRenderedInputPin(__in_opt LPCTSTR pObjectName,
-                      __in CBaseFilter *pFilter,
-                      __in CCritSec *pLock,
-                      __inout HRESULT *phr,
-                      __in_opt LPCWSTR pName);
-#ifdef UNICODE
-    CRenderedInputPin(__in_opt LPCSTR pObjectName,
-                      __in CBaseFilter *pFilter,
-                      __in CCritSec *pLock,
-                      __inout HRESULT *phr,
-                      __in_opt LPCWSTR pName);
-#endif
-
-    // Override methods to track end of stream state
-    STDMETHODIMP EndOfStream();
-    STDMETHODIMP EndFlush();
-
-    HRESULT Active();
-    HRESULT Run(REFERENCE_TIME tStart);
-
-protected:
-
-    // Member variables to track state
-    BOOL m_bAtEndOfStream;      // Set by EndOfStream
-    BOOL m_bCompleteNotified;   // Set when we notify for EC_COMPLETE
-
-private:
-    void DoCompleteHandling();
-};
-
-#endif // __AMEXTRA__
-

3rdparty/baseclasses/amvideo.cpp

@@ -1,275 +0,0 @@
-//------------------------------------------------------------------------------
-// File: AMVideo.cpp
-//
-// Desc: DirectShow base classes - implements helper functions for
-//       bitmap formats.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-#include <streams.h>
-#include <limits.h>
-
-// These are bit field masks for true colour devices
-
-const DWORD bits555[] = {0x007C00,0x0003E0,0x00001F};
-const DWORD bits565[] = {0x00F800,0x0007E0,0x00001F};
-const DWORD bits888[] = {0xFF0000,0x00FF00,0x0000FF};
-
-// This maps bitmap subtypes into a bits per pixel value and also a
-// name. unicode and ansi versions are stored because we have to
-// return a pointer to a static string.
-const struct {
-    const GUID *pSubtype;
-    WORD BitCount;
-    CHAR *pName;
-    WCHAR *wszName;
-} BitCountMap[] =  { &MEDIASUBTYPE_RGB1,        1,   "RGB Monochrome",     L"RGB Monochrome",
-                     &MEDIASUBTYPE_RGB4,        4,   "RGB VGA",            L"RGB VGA",
-                     &MEDIASUBTYPE_RGB8,        8,   "RGB 8",              L"RGB 8",
-                     &MEDIASUBTYPE_RGB565,      16,  "RGB 565 (16 bit)",   L"RGB 565 (16 bit)",
-                     &MEDIASUBTYPE_RGB555,      16,  "RGB 555 (16 bit)",   L"RGB 555 (16 bit)",
-                     &MEDIASUBTYPE_RGB24,       24,  "RGB 24",             L"RGB 24",
-                     &MEDIASUBTYPE_RGB32,       32,  "RGB 32",             L"RGB 32",
-                     &MEDIASUBTYPE_ARGB32,    32,  "ARGB 32",             L"ARGB 32",
-                     &MEDIASUBTYPE_Overlay,     0,   "Overlay",            L"Overlay",
-                     &GUID_NULL,                0,   "UNKNOWN",            L"UNKNOWN"
-};
-
-// Return the size of the bitmap as defined by this header
-
-STDAPI_(DWORD) GetBitmapSize(const BITMAPINFOHEADER *pHeader)
-{
-    return DIBSIZE(*pHeader);
-}
-
-
-// This is called if the header has a 16 bit colour depth and needs to work
-// out the detailed type from the bit fields (either RGB 565 or RGB 555)
-
-STDAPI_(const GUID) GetTrueColorType(const BITMAPINFOHEADER *pbmiHeader)
-{
-    BITMAPINFO *pbmInfo = (BITMAPINFO *) pbmiHeader;
-    ASSERT(pbmiHeader->biBitCount == 16);
-
-    // If its BI_RGB then it's RGB 555 by default
-
-    if (pbmiHeader->biCompression == BI_RGB) {
-        return MEDIASUBTYPE_RGB555;
-    }
-
-    // Compare the bit fields with RGB 555
-
-    DWORD *pMask = (DWORD *) pbmInfo->bmiColors;
-    if (pMask[0] == bits555[0]) {
-        if (pMask[1] == bits555[1]) {
-            if (pMask[2] == bits555[2]) {
-                return MEDIASUBTYPE_RGB555;
-            }
-        }
-    }
-
-    // Compare the bit fields with RGB 565
-
-    pMask = (DWORD *) pbmInfo->bmiColors;
-    if (pMask[0] == bits565[0]) {
-        if (pMask[1] == bits565[1]) {
-            if (pMask[2] == bits565[2]) {
-                return MEDIASUBTYPE_RGB565;
-            }
-        }
-    }
-    return GUID_NULL;
-}
-
-
-// Given a BITMAPINFOHEADER structure this returns the GUID sub type that is
-// used to describe it in format negotiations. For example a video codec fills
-// in the format block with a VIDEOINFO structure, it also fills in the major
-// type with MEDIATYPE_VIDEO and the subtype with a GUID that matches the bit
-// count, for example if it is an eight bit image then MEDIASUBTYPE_RGB8
-
-STDAPI_(const GUID) GetBitmapSubtype(const BITMAPINFOHEADER *pbmiHeader)
-{
-    ASSERT(pbmiHeader);
-
-    // If it's not RGB then create a GUID from the compression type
-
-    if (pbmiHeader->biCompression != BI_RGB) {
-        if (pbmiHeader->biCompression != BI_BITFIELDS) {
-            FOURCCMap FourCCMap(pbmiHeader->biCompression);
-            return (const GUID) FourCCMap;
-        }
-    }
-
-    // Map the RGB DIB bit depth to a image GUID
-
-    switch(pbmiHeader->biBitCount) {
-        case 1    :   return MEDIASUBTYPE_RGB1;
-        case 4    :   return MEDIASUBTYPE_RGB4;
-        case 8    :   return MEDIASUBTYPE_RGB8;
-        case 16   :   return GetTrueColorType(pbmiHeader);
-        case 24   :   return MEDIASUBTYPE_RGB24;
-        case 32   :   return MEDIASUBTYPE_RGB32;
-    }
-    return GUID_NULL;
-}
-
-
-// Given a video bitmap subtype we return the number of bits per pixel it uses
-// We return a WORD bit count as thats what the BITMAPINFOHEADER uses. If the
-// GUID subtype is not found in the table we return an invalid USHRT_MAX
-
-STDAPI_(WORD) GetBitCount(const GUID *pSubtype)
-{
-    ASSERT(pSubtype);
-    const GUID *pMediaSubtype;
-    INT iPosition = 0;
-
-    // Scan the mapping list seeing if the source GUID matches any known
-    // bitmap subtypes, the list is terminated by a GUID_NULL entry
-
-    while (TRUE) {
-        pMediaSubtype = BitCountMap[iPosition].pSubtype;
-        if (IsEqualGUID(*pMediaSubtype,GUID_NULL)) {
-            return USHRT_MAX;
-        }
-        if (IsEqualGUID(*pMediaSubtype,*pSubtype)) {
-            return BitCountMap[iPosition].BitCount;
-        }
-        iPosition++;
-    }
-}
-
-
-// Given a bitmap subtype we return a description name that can be used for
-// debug purposes. In a retail build this function still returns the names
-// If the subtype isn't found in the lookup table we return string UNKNOWN
-
-int LocateSubtype(const GUID *pSubtype)
-{
-    ASSERT(pSubtype);
-    const GUID *pMediaSubtype;
-    INT iPosition = 0;
-
-    // Scan the mapping list seeing if the source GUID matches any known
-    // bitmap subtypes, the list is terminated by a GUID_NULL entry
-
-    while (TRUE) {
-        pMediaSubtype = BitCountMap[iPosition].pSubtype;
-        if (IsEqualGUID(*pMediaSubtype,*pSubtype) ||
-            IsEqualGUID(*pMediaSubtype,GUID_NULL)
-            )
-        {
-            break;
-        }
-
-        iPosition++;
-    }
-
-    return iPosition;
-}
-
-
-
-STDAPI_(WCHAR *) GetSubtypeNameW(const GUID *pSubtype)
-{
-    return BitCountMap[LocateSubtype(pSubtype)].wszName;
-}
-
-STDAPI_(CHAR *) GetSubtypeNameA(const GUID *pSubtype)
-{
-    return BitCountMap[LocateSubtype(pSubtype)].pName;
-}
-
-#ifndef GetSubtypeName
-#error wxutil.h should have defined GetSubtypeName
-#endif
-#undef GetSubtypeName
-
-// this is here for people that linked to it directly; most people
-// would use the header file that picks the A or W version.
-STDAPI_(CHAR *) GetSubtypeName(const GUID *pSubtype)
-{
-    return GetSubtypeNameA(pSubtype);
-}
-
-
-// The mechanism for describing a bitmap format is with the BITMAPINFOHEADER
-// This is really messy to deal with because it invariably has fields that
-// follow it holding bit fields, palettes and the rest. This function gives
-// the number of bytes required to hold a VIDEOINFO that represents it. This
-// count includes the prefix information (like the rcSource rectangle) the
-// BITMAPINFOHEADER field, and any other colour information on the end.
-//
-// WARNING If you want to copy a BITMAPINFOHEADER into a VIDEOINFO always make
-// sure that you use the HEADER macro because the BITMAPINFOHEADER field isn't
-// right at the start of the VIDEOINFO (there are a number of other fields),
-//
-//     CopyMemory(HEADER(pVideoInfo),pbmi,sizeof(BITMAPINFOHEADER));
-//
-
-STDAPI_(LONG) GetBitmapFormatSize(const BITMAPINFOHEADER *pHeader)
-{
-    // Everyone has this to start with this
-    LONG Size = SIZE_PREHEADER + pHeader->biSize;
-
-    ASSERT(pHeader->biSize >= sizeof(BITMAPINFOHEADER));
-
-    // Does this format use a palette, if the number of colours actually used
-    // is zero then it is set to the maximum that are allowed for that colour
-    // depth (an example is 256 for eight bits). Truecolour formats may also
-    // pass a palette with them in which case the used count is non zero
-
-    // This would scare me.
-    ASSERT(pHeader->biBitCount <= iPALETTE || pHeader->biClrUsed == 0);
-
-    if (pHeader->biBitCount <= iPALETTE || pHeader->biClrUsed) {
-        LONG Entries = (DWORD) 1 << pHeader->biBitCount;
-        if (pHeader->biClrUsed) {
-            Entries = pHeader->biClrUsed;
-        }
-        Size += Entries * sizeof(RGBQUAD);
-    }
-
-    // Truecolour formats may have a BI_BITFIELDS specifier for compression
-    // type which means that room for three DWORDs should be allocated that
-    // specify where in each pixel the RGB colour components may be found
-
-    if (pHeader->biCompression == BI_BITFIELDS) {
-        Size += SIZE_MASKS;
-    }
-
-    // A BITMAPINFO for a palettised image may also contain a palette map that
-    // provides the information to map from a source palette to a destination
-    // palette during a BitBlt for example, because this information is only
-    // ever processed during drawing you don't normally store the palette map
-    // nor have any way of knowing if it is present in the data structure
-
-    return Size;
-}
-
-
-// Returns TRUE if the VIDEOINFO contains a palette
-
-STDAPI_(BOOL) ContainsPalette(const VIDEOINFOHEADER *pVideoInfo)
-{
-    if (PALETTISED(pVideoInfo) == FALSE) {
-        if (pVideoInfo->bmiHeader.biClrUsed == 0) {
-            return FALSE;
-        }
-    }
-    return TRUE;
-}
-
-
-// Return a pointer to the first entry in a palette
-
-STDAPI_(const RGBQUAD *) GetBitmapPalette(const VIDEOINFOHEADER *pVideoInfo)
-{
-    if (pVideoInfo->bmiHeader.biCompression == BI_BITFIELDS) {
-        return TRUECOLOR(pVideoInfo)->bmiColors;
-    }
-    return COLORS(pVideoInfo);
-}

3rdparty/baseclasses/baseclasses.vcxproj

@@ -1,97 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(SolutionDir)common\vsprops\BaseProjectConfig.props" />
-  <Import Project="$(SolutionDir)common\vsprops\WinSDK.props" />
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{27F17499-A372-4408-8AFA-4F9F4584FBD3}</ProjectGuid>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <PlatformToolset>$(DefaultPlatformToolset)</PlatformToolset>
-    <CharacterSet>MultiByte</CharacterSet>
-    <WholeProgramOptimization Condition="$(Configuration.Contains(Release))">true</WholeProgramOptimization>
-    <UseDebugLibraries Condition="$(Configuration.Contains(Debug))">true</UseDebugLibraries>
-    <UseDebugLibraries Condition="!$(Configuration.Contains(Debug))">false</UseDebugLibraries>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings" />
-  <ImportGroup Label="PropertySheets">
-    <Import Project="..\..\3rdparty\DefaultProjectRootDir.props" />
-    <Import Project="..\..\3rdparty\3rdparty.props" />
-    <Import Condition="$(Configuration.Contains(Debug))" Project="..\..\common\vsprops\CodeGen_Debug.props" />
-    <Import Condition="$(Configuration.Contains(Release))" Project="..\..\common\vsprops\CodeGen_Release.props" />
-    <Import Condition="!$(Configuration.Contains(Release))" Project="..\..\common\vsprops\IncrementalLinking.props" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup>
-    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <ItemDefinitionGroup>
-    <ClCompile>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>streams.h</PrecompiledHeaderFile>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClInclude Include="amextra.h" />
-    <ClInclude Include="amfilter.h" />
-    <ClInclude Include="cache.h" />
-    <ClInclude Include="combase.h" />
-    <ClInclude Include="ctlutil.h" />
-    <ClInclude Include="ddmm.h" />
-    <ClInclude Include="fourcc.h" />
-    <ClInclude Include="measure.h" />
-    <ClInclude Include="msgthrd.h" />
-    <ClInclude Include="mtype.h" />
-    <ClInclude Include="outputq.h" />
-    <ClInclude Include="pstream.h" />
-    <ClInclude Include="pullpin.h" />
-    <ClInclude Include="refclock.h" />
-    <ClInclude Include="reftime.h" />
-    <ClInclude Include="renbase.h" />
-    <ClInclude Include="schedule.h" />
-    <ClInclude Include="seekpt.h" />
-    <ClInclude Include="source.h" />
-    <ClInclude Include="streams.h" />
-    <ClInclude Include="strmctl.h" />
-    <ClInclude Include="sysclock.h" />
-    <ClInclude Include="transfrm.h" />
-    <ClInclude Include="transip.h" />
-    <ClInclude Include="vtrans.h" />
-    <ClInclude Include="wxdebug.h" />
-    <ClInclude Include="wxlist.h" />
-    <ClInclude Include="wxutil.h" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="amextra.cpp" />
-    <ClCompile Include="amfilter.cpp" />
-    <ClCompile Include="amvideo.cpp" />
-    <ClCompile Include="combase.cpp" />
-    <ClCompile Include="ctlutil.cpp" />
-    <ClCompile Include="ddmm.cpp">
-      <PrecompiledHeader>NotUsing</PrecompiledHeader>
-    </ClCompile>
-    <ClCompile Include="mtype.cpp" />
-    <ClCompile Include="outputq.cpp" />
-    <ClCompile Include="pstream.cpp" />
-    <ClCompile Include="pullpin.cpp" />
-    <ClCompile Include="refclock.cpp" />
-    <ClCompile Include="renbase.cpp" />
-    <ClCompile Include="schedule.cpp" />
-    <ClCompile Include="seekpt.cpp">
-      <PrecompiledHeader>Create</PrecompiledHeader>
-    </ClCompile>
-    <ClCompile Include="source.cpp" />
-    <ClCompile Include="strmctl.cpp" />
-    <ClCompile Include="sysclock.cpp" />
-    <ClCompile Include="transfrm.cpp" />
-    <ClCompile Include="transip.cpp" />
-    <ClCompile Include="vtrans.cpp" />
-    <ClCompile Include="wxdebug.cpp" />
-    <ClCompile Include="wxlist.cpp" />
-    <ClCompile Include="wxutil.cpp" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets" />
-</Project>

3rdparty/baseclasses/baseclasses.vcxproj.filters

@@ -1,174 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
-    </Filter>
-    <Filter Include="Resource Files">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="amextra.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="amfilter.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="cache.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="combase.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="ctlutil.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="ddmm.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="fourcc.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="msgthrd.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="reftime.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="refclock.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="pullpin.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="pstream.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="outputq.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="mtype.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="measure.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="renbase.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="schedule.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="seekpt.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="streams.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="source.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="strmctl.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="sysclock.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="transfrm.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="transip.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="vtrans.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="wxdebug.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="wxlist.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="wxutil.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="amextra.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="amfilter.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="amvideo.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="combase.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="ctlutil.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="ddmm.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="mtype.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="outputq.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="pstream.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="pullpin.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="refclock.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="renbase.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="schedule.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="seekpt.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="source.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="strmctl.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="sysclock.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="transfrm.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="transip.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="vtrans.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="wxdebug.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="wxlist.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="wxutil.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-  </ItemGroup>
-</Project>

3rdparty/baseclasses/cache.h

@@ -1,74 +0,0 @@
-//------------------------------------------------------------------------------
-// File: Cache.h
-//
-// Desc: DirectShow base classes - efines a non-MFC generic cache class.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-/* This class implements a simple cache. A cache object is instantiated
-   with the number of items it is to hold. An item is a pointer to an
-   object derived from CBaseObject (helps reduce memory leaks). The cache
-   can then have objects added to it and removed from it. The cache size
-   is fixed at construction time and may therefore run out or be flooded.
-   If it runs out it returns a NULL pointer, if it fills up it also returns
-   a NULL pointer instead of a pointer to the object just inserted */
-
-/* Making these classes inherit from CBaseObject does nothing for their
-   functionality but it allows us to check there are no memory leaks */
-
-/* WARNING Be very careful when using this class, what it lets you do is
-   store and retrieve objects so that you can minimise object creation
-   which in turns improves efficiency. However the object you store is
-   exactly the same as the object you get back which means that it short
-   circuits the constructor initialisation phase. This means any class
-   variables the object has (eg pointers) are highly likely to be invalid.
-   Therefore ensure you reinitialise the object before using it again */
-
-
-#ifndef __CACHE__
-#define __CACHE__
-
-
-class CCache : CBaseObject {
-
-    /* Make copy constructor and assignment operator inaccessible */
-
-    CCache(const CCache &refCache);
-    CCache &operator=(const CCache &refCache);
-
-private:
-
-    /* These are initialised in the constructor. The first variable points to
-       an array of pointers, each of which points to a CBaseObject derived
-       object. The m_iCacheSize is the static fixed size for the cache and the
-       m_iUsed defines the number of places filled with objects at any time.
-       We fill the array of pointers from the start (ie m_ppObjects[0] first)
-       and then only add and remove objects from the end position, so in this
-       respect the array of object pointers should be treated as a stack */
-
-    CBaseObject **m_ppObjects;
-    const INT m_iCacheSize;
-    INT m_iUsed;
-
-public:
-
-    CCache(__in_opt LPCTSTR pName,INT iItems);
-    virtual ~CCache();
-
-    /* Add an item to the cache */
-    CBaseObject *AddToCache(__in CBaseObject *pObject);
-
-    /* Remove an item from the cache */
-    CBaseObject *RemoveFromCache();
-
-    /* Delete all the objects held in the cache */
-    void RemoveAll(void);
-
-    /* Return the cache size which is set during construction */
-    INT GetCacheSize(void) const {return m_iCacheSize;};
-};
-
-#endif /* __CACHE__ */
-

3rdparty/baseclasses/combase.cpp

@@ -1,265 +0,0 @@
-//------------------------------------------------------------------------------
-// File: ComBase.cpp
-//
-// Desc: DirectShow base classes - implements class hierarchy for creating
-//       COM objects.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-#include <streams.h>
-#pragma warning( disable : 4514 )   // Disable warnings re unused inline functions
-
-
-/* Define the static member variable */
-
-LONG CBaseObject::m_cObjects = 0;
-
-
-/* Constructor */
-
-CBaseObject::CBaseObject(__in_opt LPCTSTR pName)
-{
-    /* Increment the number of active objects */
-    InterlockedIncrement(&m_cObjects);
-
-#ifdef DEBUG
-
-#ifdef UNICODE
-    m_dwCookie = DbgRegisterObjectCreation(0, pName);
-#else
-    m_dwCookie = DbgRegisterObjectCreation(pName, 0);
-#endif
-
-#endif
-}
-
-#ifdef UNICODE
-CBaseObject::CBaseObject(const char *pName)
-{
-    /* Increment the number of active objects */
-    InterlockedIncrement(&m_cObjects);
-
-#ifdef DEBUG
-    m_dwCookie = DbgRegisterObjectCreation(pName, 0);
-#endif
-}
-#endif
-
-HINSTANCE	hlibOLEAut32;
-
-/* Destructor */
-
-CBaseObject::~CBaseObject()
-{
-    /* Decrement the number of objects active */
-    if (InterlockedDecrement(&m_cObjects) == 0) {
-	if (hlibOLEAut32) {
-	    FreeLibrary(hlibOLEAut32);
-
-	    hlibOLEAut32 = 0;
-	}
-    };
-
-
-#ifdef DEBUG
-    DbgRegisterObjectDestruction(m_dwCookie);
-#endif
-}
-
-static const TCHAR szOle32Aut[]   = TEXT("OleAut32.dll");
-
-HINSTANCE LoadOLEAut32()
-{
-    if (hlibOLEAut32 == 0) {
-
-	hlibOLEAut32 = LoadLibrary(szOle32Aut);
-    }
-
-    return hlibOLEAut32;
-}
-
-
-/* Constructor */
-
-// We know we use "this" in the initialization list, we also know we don't modify *phr.
-#pragma warning( disable : 4355 4100 )
-CUnknown::CUnknown(__in_opt LPCTSTR pName, __in_opt LPUNKNOWN pUnk)
-: CBaseObject(pName)
-/* Start the object with a reference count of zero - when the      */
-/* object is queried for it's first interface this may be          */
-/* incremented depending on whether or not this object is          */
-/* currently being aggregated upon                                 */
-, m_cRef(0)
-/* Set our pointer to our IUnknown interface.                      */
-/* If we have an outer, use its, otherwise use ours.               */
-/* This pointer effectivly points to the owner of                  */
-/* this object and can be accessed by the GetOwner() method.       */
-, m_pUnknown( pUnk != 0 ? pUnk : reinterpret_cast<LPUNKNOWN>( static_cast<PNDUNKNOWN>(this) ) )
- /* Why the double cast?  Well, the inner cast is a type-safe cast */
- /* to pointer to a type from which we inherit.  The second is     */
- /* type-unsafe but works because INonDelegatingUnknown "behaves   */
- /* like" IUnknown. (Only the names on the methods change.)        */
-{
-    // Everything we need to do has been done in the initializer list
-}
-
-// This does the same as above except it has a useless HRESULT argument
-// use the previous constructor, this is just left for compatibility...
-CUnknown::CUnknown(__in_opt LPCTSTR pName, __in_opt LPUNKNOWN pUnk, __inout_opt HRESULT *phr) :
-    CBaseObject(pName),
-    m_cRef(0),
-    m_pUnknown( pUnk != 0 ? pUnk : reinterpret_cast<LPUNKNOWN>( static_cast<PNDUNKNOWN>(this) ) )
-{
-}
-
-#ifdef UNICODE
-CUnknown::CUnknown(__in_opt LPCSTR pName, __in_opt LPUNKNOWN pUnk)
-: CBaseObject(pName), m_cRef(0),
-    m_pUnknown( pUnk != 0 ? pUnk : reinterpret_cast<LPUNKNOWN>( static_cast<PNDUNKNOWN>(this) ) )
-{ }
-
-CUnknown::CUnknown(__in_opt LPCSTR pName, __in_opt LPUNKNOWN pUnk, __inout_opt HRESULT *phr) :
-    CBaseObject(pName), m_cRef(0),
-    m_pUnknown( pUnk != 0 ? pUnk : reinterpret_cast<LPUNKNOWN>( static_cast<PNDUNKNOWN>(this) ) )
-{ }
-
-#endif
-
-#pragma warning( default : 4355 4100 )
-
-
-/* QueryInterface */
-
-STDMETHODIMP CUnknown::NonDelegatingQueryInterface(REFIID riid, __deref_out void ** ppv)
-{
-    CheckPointer(ppv,E_POINTER);
-    ValidateReadWritePtr(ppv,sizeof(PVOID));
-
-    /* We know only about IUnknown */
-
-    if (riid == IID_IUnknown) {
-        GetInterface((LPUNKNOWN) (PNDUNKNOWN) this, ppv);
-        return NOERROR;
-    } else {
-        *ppv = NULL;
-        return E_NOINTERFACE;
-    }
-}
-
-/* We have to ensure that we DON'T use a max macro, since these will typically   */
-/* lead to one of the parameters being evaluated twice.  Since we are worried    */
-/* about concurrency, we can't afford to access the m_cRef twice since we can't  */
-/* afford to run the risk that its value having changed between accesses.        */
-
-template<class T> inline static T ourmax( const T & a, const T & b )
-{
-    return a > b ? a : b;
-}
-
-/* AddRef */
-
-STDMETHODIMP_(ULONG) CUnknown::NonDelegatingAddRef()
-{
-    LONG lRef = InterlockedIncrement( &m_cRef );
-    ASSERT(lRef > 0);
-    DbgLog((LOG_MEMORY,3,TEXT("    Obj %d ref++ = %d"),
-           m_dwCookie, m_cRef));
-    return ourmax(ULONG(m_cRef), 1ul);
-}
-
-
-/* Release */
-
-STDMETHODIMP_(ULONG) CUnknown::NonDelegatingRelease()
-{
-    /* If the reference count drops to zero delete ourselves */
-
-    LONG lRef = InterlockedDecrement( &m_cRef );
-    ASSERT(lRef >= 0);
-
-    DbgLog((LOG_MEMORY,3,TEXT("    Object %d ref-- = %d"),
-	    m_dwCookie, m_cRef));
-    if (lRef == 0) {
-
-        // COM rules say we must protect against re-entrancy.
-        // If we are an aggregator and we hold our own interfaces
-        // on the aggregatee, the QI for these interfaces will
-        // addref ourselves. So after doing the QI we must release
-        // a ref count on ourselves. Then, before releasing the
-        // private interface, we must addref ourselves. When we do
-        // this from the destructor here it will result in the ref
-        // count going to 1 and then back to 0 causing us to
-        // re-enter the destructor. Hence we add an extra refcount here
-        // once we know we will delete the object.
-        // for an example aggregator see filgraph\distrib.cpp.
-
-        m_cRef++;
-
-        delete this;
-        return ULONG(0);
-    } else {
-        //  Don't touch m_cRef again even in this leg as the object
-        //  may have just been released on another thread too
-        return ourmax(ULONG(lRef), 1ul);
-    }
-}
-
-
-/* Return an interface pointer to a requesting client
-   performing a thread safe AddRef as necessary */
-
-STDAPI GetInterface(LPUNKNOWN pUnk, __out void **ppv)
-{
-    CheckPointer(ppv, E_POINTER);
-    *ppv = pUnk;
-    pUnk->AddRef();
-    return NOERROR;
-}
-
-
-/* Compares two interfaces and returns TRUE if they are on the same object */
-
-BOOL WINAPI IsEqualObject(IUnknown *pFirst, IUnknown *pSecond)
-{
-    /*  Different objects can't have the same interface pointer for
-        any interface
-    */
-    if (pFirst == pSecond) {
-        return TRUE;
-    }
-    /*  OK - do it the hard way - check if they have the same
-        IUnknown pointers - a single object can only have one of these
-    */
-    LPUNKNOWN pUnknown1;     // Retrieve the IUnknown interface
-    LPUNKNOWN pUnknown2;     // Retrieve the other IUnknown interface
-    HRESULT hr;              // General OLE return code
-
-    ASSERT(pFirst);
-    ASSERT(pSecond);
-
-    /* See if the IUnknown pointers match */
-
-    hr = pFirst->QueryInterface(IID_IUnknown,(void **) &pUnknown1);
-    if (FAILED(hr)) {
-        return FALSE;
-    }
-    ASSERT(pUnknown1);
-
-    /* Release the extra interface we hold */
-
-    pUnknown1->Release();
-
-    hr = pSecond->QueryInterface(IID_IUnknown,(void **) &pUnknown2);
-    if (FAILED(hr)) {
-        return FALSE;
-    }
-    ASSERT(pUnknown2);
-
-    /* Release the extra interface we hold */
-
-    pUnknown2->Release();
-    return (pUnknown1 == pUnknown2);
-}
-

3rdparty/baseclasses/combase.h

@@ -1,305 +0,0 @@
-//------------------------------------------------------------------------------
-// File: ComBase.h
-//
-// Desc: DirectShow base classes - defines a class hierarchy for creating
-//       COM objects.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-/*
-
-a. Derive your COM object from CUnknown
-
-b. Make a static CreateInstance function that takes an LPUNKNOWN, an HRESULT *
-   and a TCHAR *. The LPUNKNOWN defines the object to delegate IUnknown calls
-   to. The HRESULT * allows error codes to be passed around constructors and
-   the TCHAR * is a descriptive name that can be printed on the debugger.
-
-   It is important that constructors only change the HRESULT * if they have
-   to set an ERROR code, if it was successful then leave it alone or you may
-   overwrite an error code from an object previously created.
-
-   When you call a constructor the descriptive name should be in static store
-   as we do not copy the string. To stop large amounts of memory being used
-   in retail builds by all these static strings use the NAME macro,
-
-   CMyFilter = new CImplFilter(NAME("My filter"),pUnknown,phr);
-   if (FAILED(hr)) {
-       return hr;
-   }
-
-   In retail builds NAME(_x_) compiles to NULL, the base CBaseObject class
-   knows not to do anything with objects that don't have a name.
-
-c. Have a constructor for your object that passes the LPUNKNOWN, HRESULT * and
-   TCHAR * to the CUnknown constructor. You can set the HRESULT if you have an
-   error, or just simply pass it through to the constructor.
-
-   The object creation will fail in the class factory if the HRESULT indicates
-   an error (ie FAILED(HRESULT) == TRUE)
-
-d. Create a FactoryTemplate with your object's class id and CreateInstance
-   function.
-
-Then (for each interface) either
-
-Multiple inheritance
-
-1. Also derive it from ISomeInterface
-2. Include DECLARE_IUNKNOWN in your class definition to declare
-   implementations of QueryInterface, AddRef and Release that
-   call the outer unknown
-3. Override NonDelegatingQueryInterface to expose ISomeInterface by
-   code something like
-
-     if (riid == IID_ISomeInterface) {
-         return GetInterface((ISomeInterface *) this, ppv);
-     } else {
-         return CUnknown::NonDelegatingQueryInterface(riid, ppv);
-     }
-
-4. Declare and implement the member functions of ISomeInterface.
-
-or: Nested interfaces
-
-1. Declare a class derived from CUnknown
-2. Include DECLARE_IUNKNOWN in your class definition
-3. Override NonDelegatingQueryInterface to expose ISomeInterface by
-   code something like
-
-     if (riid == IID_ISomeInterface) {
-         return GetInterface((ISomeInterface *) this, ppv);
-     } else {
-         return CUnknown::NonDelegatingQueryInterface(riid, ppv);
-     }
-
-4. Implement the member functions of ISomeInterface. Use GetOwner() to
-   access the COM object class.
-
-And in your COM object class:
-
-5. Make the nested class a friend of the COM object class, and declare
-   an instance of the nested class as a member of the COM object class.
-
-   NOTE that because you must always pass the outer unknown and an hResult
-   to the CUnknown constructor you cannot use a default constructor, in
-   other words you will have to make the member variable a pointer to the
-   class and make a NEW call in your constructor to actually create it.
-
-6. override the NonDelegatingQueryInterface with code like this:
-
-     if (riid == IID_ISomeInterface) {
-         return m_pImplFilter->
-            NonDelegatingQueryInterface(IID_ISomeInterface, ppv);
-     } else {
-         return CUnknown::NonDelegatingQueryInterface(riid, ppv);
-     }
-
-You can have mixed classes which support some interfaces via multiple
-inheritance and some via nested classes
-
-*/
-
-#ifndef __COMBASE__
-#define __COMBASE__
-
-// Filter Setup data structures no defined in axextend.idl
-
-typedef REGPINTYPES
-AMOVIESETUP_MEDIATYPE, * PAMOVIESETUP_MEDIATYPE, * FAR LPAMOVIESETUP_MEDIATYPE;
-
-typedef REGFILTERPINS
-AMOVIESETUP_PIN, * PAMOVIESETUP_PIN, * FAR LPAMOVIESETUP_PIN;
-
-typedef struct _AMOVIESETUP_FILTER
-{
-  const CLSID * clsID;
-  const WCHAR * strName;
-  DWORD      dwMerit;
-  UINT       nPins;
-  const AMOVIESETUP_PIN * lpPin;
-}
-AMOVIESETUP_FILTER, * PAMOVIESETUP_FILTER, * FAR LPAMOVIESETUP_FILTER;
-
-/* The DLLENTRY module initialises the module handle on loading */
-
-extern HINSTANCE g_hInst;
-
-/* On DLL load remember which platform we are running on */
-
-extern DWORD g_amPlatform;
-extern OSVERSIONINFO g_osInfo;     // Filled in by GetVersionEx
-
-/* Version of IUnknown that is renamed to allow a class to support both
-   non delegating and delegating IUnknowns in the same COM object */
-
-#ifndef INONDELEGATINGUNKNOWN_DEFINED
-DECLARE_INTERFACE(INonDelegatingUnknown)
-{
-    STDMETHOD(NonDelegatingQueryInterface) (THIS_ REFIID, LPVOID *) PURE;
-    STDMETHOD_(ULONG, NonDelegatingAddRef)(THIS) PURE;
-    STDMETHOD_(ULONG, NonDelegatingRelease)(THIS) PURE;
-};
-#define INONDELEGATINGUNKNOWN_DEFINED
-#endif
-
-typedef INonDelegatingUnknown *PNDUNKNOWN;
-
-
-/* This is the base object class that supports active object counting. As
-   part of the debug facilities we trace every time a C++ object is created
-   or destroyed. The name of the object has to be passed up through the class
-   derivation list during construction as you cannot call virtual functions
-   in the constructor. The downside of all this is that every single object
-   constructor has to take an object name parameter that describes it */
-
-class CBaseObject
-{
-
-private:
-
-    // Disable the copy constructor and assignment by default so you will get
-    //   compiler errors instead of unexpected behaviour if you pass objects
-    //   by value or assign objects.
-    CBaseObject(const CBaseObject& objectSrc);          // no implementation
-    void operator=(const CBaseObject& objectSrc);       // no implementation
-
-private:
-    static LONG m_cObjects;     /* Total number of objects active */
-
-protected:
-#ifdef DEBUG
-    DWORD m_dwCookie;           /* Cookie identifying this object */
-#endif
-
-
-public:
-
-    /* These increment and decrement the number of active objects */
-
-    CBaseObject(__in_opt LPCTSTR pName);
-#ifdef UNICODE
-    CBaseObject(__in_opt LPCSTR pName);
-#endif
-    ~CBaseObject();
-
-    /* Call this to find if there are any CUnknown derived objects active */
-
-    static LONG ObjectsActive() {
-        return m_cObjects;
-    };
-};
-
-
-/* An object that supports one or more COM interfaces will be based on
-   this class. It supports counting of total objects for DLLCanUnloadNow
-   support, and an implementation of the core non delegating IUnknown */
-
-class AM_NOVTABLE CUnknown : public INonDelegatingUnknown,
-                 public CBaseObject
-{
-private:
-    const LPUNKNOWN m_pUnknown; /* Owner of this object */
-
-protected:                      /* So we can override NonDelegatingRelease() */
-    volatile LONG m_cRef;       /* Number of reference counts */
-
-public:
-
-    CUnknown(__in_opt LPCTSTR pName, __in_opt LPUNKNOWN pUnk);
-    virtual ~CUnknown() {};
-
-    // This is redundant, just use the other constructor
-    //   as we never touch the HRESULT in this anyway
-    CUnknown(__in_opt LPCTSTR Name, __in_opt LPUNKNOWN pUnk, __inout_opt HRESULT *phr);
-#ifdef UNICODE
-    CUnknown(__in_opt LPCSTR pName, __in_opt LPUNKNOWN pUnk);
-    CUnknown(__in_opt LPCSTR pName, __in_opt LPUNKNOWN pUnk,__inout_opt HRESULT *phr);
-#endif
-
-    /* Return the owner of this object */
-
-    LPUNKNOWN GetOwner() const {
-        return m_pUnknown;
-    };
-
-    /* Called from the class factory to create a new instance, it is
-       pure virtual so it must be overriden in your derived class */
-
-    /* static CUnknown *CreateInstance(LPUNKNOWN, HRESULT *) */
-
-    /* Non delegating unknown implementation */
-
-    STDMETHODIMP NonDelegatingQueryInterface(REFIID, __deref_out void **);
-    STDMETHODIMP_(ULONG) NonDelegatingAddRef();
-    STDMETHODIMP_(ULONG) NonDelegatingRelease();
-};
-
-/* Return an interface pointer to a requesting client
-   performing a thread safe AddRef as necessary */
-
-STDAPI GetInterface(LPUNKNOWN pUnk, __out void **ppv);
-
-/* A function that can create a new COM object */
-
-typedef CUnknown *(CALLBACK *LPFNNewCOMObject)(__in_opt LPUNKNOWN pUnkOuter, __inout_opt HRESULT *phr);
-
-/*  A function (can be NULL) which is called from the DLL entrypoint
-    routine for each factory template:
-
-    bLoading - TRUE on DLL load, FALSE on DLL unload
-    rclsid   - the m_ClsID of the entry
-*/
-typedef void (CALLBACK *LPFNInitRoutine)(BOOL bLoading, const CLSID *rclsid);
-
-/* Create one of these per object class in an array so that
-   the default class factory code can create new instances */
-
-class CFactoryTemplate {
-
-public:
-
-    const WCHAR *              m_Name;
-    const CLSID *              m_ClsID;
-    LPFNNewCOMObject           m_lpfnNew;
-    LPFNInitRoutine            m_lpfnInit;
-    const AMOVIESETUP_FILTER * m_pAMovieSetup_Filter;
-
-    BOOL IsClassID(REFCLSID rclsid) const {
-        return (IsEqualCLSID(*m_ClsID,rclsid));
-    };
-
-    CUnknown *CreateInstance(__inout_opt LPUNKNOWN pUnk, __inout_opt HRESULT *phr) const {
-        CheckPointer(phr,NULL);
-        return m_lpfnNew(pUnk, phr);
-    };
-};
-
-
-/* You must override the (pure virtual) NonDelegatingQueryInterface to return
-   interface pointers (using GetInterface) to the interfaces your derived
-   class supports (the default implementation only supports IUnknown) */
-
-#define DECLARE_IUNKNOWN                                        \
-    STDMETHODIMP QueryInterface(REFIID riid, __deref_out void **ppv) {      \
-        return GetOwner()->QueryInterface(riid,ppv);            \
-    };                                                          \
-    STDMETHODIMP_(ULONG) AddRef() {                             \
-        return GetOwner()->AddRef();                            \
-    };                                                          \
-    STDMETHODIMP_(ULONG) Release() {                            \
-        return GetOwner()->Release();                           \
-    };
-
-
-
-HINSTANCE	LoadOLEAut32();
-
-
-#endif /* __COMBASE__ */
-
-
-
-

3rdparty/baseclasses/ctlutil.h

@@ -1,923 +0,0 @@
-//------------------------------------------------------------------------------
-// File: CtlUtil.h
-//
-// Desc: DirectShow base classes.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-// Base classes implementing IDispatch parsing for the basic control dual
-// interfaces. Derive from these and implement just the custom method and
-// property methods. We also implement CPosPassThru that can be used by
-// renderers and transforms to pass by IMediaPosition and IMediaSeeking
-
-#ifndef __CTLUTIL__
-#define __CTLUTIL__
-
-// OLE Automation has different ideas of TRUE and FALSE
-
-#define OATRUE (-1)
-#define OAFALSE (0)
-
-
-// It's possible that we could replace this class with CreateStdDispatch
-
-class CBaseDispatch
-{
-    ITypeInfo * m_pti;
-
-public:
-
-    CBaseDispatch() : m_pti(NULL) {}
-    ~CBaseDispatch();
-
-    /* IDispatch methods */
-    STDMETHODIMP GetTypeInfoCount(__out UINT * pctinfo);
-
-    STDMETHODIMP GetTypeInfo(
-      REFIID riid,
-      UINT itinfo,
-      LCID lcid,
-      __deref_out ITypeInfo ** pptinfo);
-
-    STDMETHODIMP GetIDsOfNames(
-      REFIID riid,
-      __in_ecount(cNames) LPOLESTR * rgszNames,
-      UINT cNames,
-      LCID lcid,
-      __out_ecount(cNames) DISPID * rgdispid);
-};
-
-
-class AM_NOVTABLE CMediaControl :
-    public IMediaControl,
-    public CUnknown
-{
-    CBaseDispatch m_basedisp;
-
-public:
-
-    CMediaControl(const TCHAR *, LPUNKNOWN);
-
-    DECLARE_IUNKNOWN
-
-    // override this to publicise our interfaces
-    STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, __deref_out void **ppv);
-
-    /* IDispatch methods */
-    STDMETHODIMP GetTypeInfoCount(__out UINT * pctinfo);
-
-    STDMETHODIMP GetTypeInfo(
-      UINT itinfo,
-      LCID lcid,
-      __deref_out ITypeInfo ** pptinfo);
-
-    STDMETHODIMP GetIDsOfNames(
-      REFIID riid,
-      __in_ecount(cNames) LPOLESTR * rgszNames,
-      UINT cNames,
-      LCID lcid,
-      __out_ecount(cNames) DISPID * rgdispid);
-
-    STDMETHODIMP Invoke(
-      DISPID dispidMember,
-      REFIID riid,
-      LCID lcid,
-      WORD wFlags,
-      __in DISPPARAMS * pdispparams,
-      __out_opt VARIANT * pvarResult,
-      __out_opt EXCEPINFO * pexcepinfo,
-      __out_opt UINT * puArgErr);
-};
-
-
-class AM_NOVTABLE CMediaEvent :
-    public IMediaEventEx,
-    public CUnknown
-{
-    CBaseDispatch m_basedisp;
-
-public:
-
-    CMediaEvent(__in_opt LPCTSTR, __in_opt LPUNKNOWN);
-
-    DECLARE_IUNKNOWN
-
-    // override this to publicise our interfaces
-    STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, __deref_out void **ppv);
-
-    /* IDispatch methods */
-    STDMETHODIMP GetTypeInfoCount(__out UINT * pctinfo);
-
-    STDMETHODIMP GetTypeInfo(
-      UINT itinfo,
-      LCID lcid,
-      __deref_out ITypeInfo ** pptinfo);
-
-    STDMETHODIMP GetIDsOfNames(
-      REFIID riid,
-      __in_ecount(cNames) LPOLESTR * rgszNames,
-      UINT cNames,
-      LCID lcid,
-      __out_ecount(cNames) DISPID * rgdispid);
-
-    STDMETHODIMP Invoke(
-      DISPID dispidMember,
-      REFIID riid,
-      LCID lcid,
-      WORD wFlags,
-      __in DISPPARAMS * pdispparams,
-      __out_opt VARIANT * pvarResult,
-      __out_opt EXCEPINFO * pexcepinfo,
-      __out_opt UINT * puArgErr);
-};
-
-
-class AM_NOVTABLE CMediaPosition :
-    public IMediaPosition,
-    public CUnknown
-{
-    CBaseDispatch m_basedisp;
-
-
-public:
-
-    CMediaPosition(__in_opt LPCTSTR, __in_opt LPUNKNOWN);
-    CMediaPosition(__in_opt LPCTSTR, __in_opt LPUNKNOWN, __inout HRESULT *phr);
-
-    DECLARE_IUNKNOWN
-
-    // override this to publicise our interfaces
-    STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, __deref_out void **ppv);
-
-    /* IDispatch methods */
-    STDMETHODIMP GetTypeInfoCount(__out UINT * pctinfo);
-
-    STDMETHODIMP GetTypeInfo(
-      UINT itinfo,
-      LCID lcid,
-      __deref_out ITypeInfo ** pptinfo);
-
-    STDMETHODIMP GetIDsOfNames(
-      REFIID riid,
-      __in_ecount(cNames) LPOLESTR * rgszNames,
-      UINT cNames,
-      LCID lcid,
-      __out_ecount(cNames) DISPID * rgdispid);
-
-    STDMETHODIMP Invoke(
-      DISPID dispidMember,
-      REFIID riid,
-      LCID lcid,
-      WORD wFlags,
-      __in DISPPARAMS * pdispparams,
-      __out_opt VARIANT * pvarResult,
-      __out_opt EXCEPINFO * pexcepinfo,
-      __out_opt UINT * puArgErr);
-
-};
-
-
-// OA-compatibility means that we must use double as the RefTime value,
-// and REFERENCE_TIME (essentially a LONGLONG) within filters.
-// this class converts between the two
-
-class COARefTime : public CRefTime {
-public:
-
-    COARefTime() {
-    };
-
-    COARefTime(CRefTime t)
-        : CRefTime(t)
-    {
-    };
-
-    COARefTime(REFERENCE_TIME t)
-        : CRefTime(t)
-    {
-    };
-
-    COARefTime(double d) {
-        m_time = (LONGLONG) (d * 10000000);
-    };
-
-    operator double() {
-        return double(m_time) / 10000000;
-    };
-
-    operator REFERENCE_TIME() {
-        return m_time;
-    };
-
-    COARefTime& operator=(const double& rd)  {
-        m_time = (LONGLONG) (rd * 10000000);
-        return *this;
-    }
-
-    COARefTime& operator=(const REFERENCE_TIME& rt)  {
-        m_time = rt;
-        return *this;
-    }
-
-    inline BOOL operator==(const COARefTime& rt)
-    {
-        return m_time == rt.m_time;
-    };
-
-    inline BOOL operator!=(const COARefTime& rt)
-    {
-        return m_time != rt.m_time;
-    };
-
-    inline BOOL operator < (const COARefTime& rt)
-    {
-        return m_time < rt.m_time;
-    };
-
-    inline BOOL operator > (const COARefTime& rt)
-    {
-        return m_time > rt.m_time;
-    };
-
-    inline BOOL operator >= (const COARefTime& rt)
-    {
-        return m_time >= rt.m_time;
-    };
-
-    inline BOOL operator <= (const COARefTime& rt)
-    {
-        return m_time <= rt.m_time;
-    };
-
-    inline COARefTime operator+(const COARefTime& rt)
-    {
-        return COARefTime(m_time + rt.m_time);
-    };
-
-    inline COARefTime operator-(const COARefTime& rt)
-    {
-        return COARefTime(m_time - rt.m_time);
-    };
-
-    inline COARefTime operator*(LONG l)
-    {
-        return COARefTime(m_time * l);
-    };
-
-    inline COARefTime operator/(LONG l)
-    {
-        return COARefTime(m_time / l);
-    };
-
-private:
-    //  Prevent bugs from constructing from LONG (which gets
-    //  converted to double and then multiplied by 10000000
-    COARefTime(LONG);
-    LONG operator=(LONG);
-};
-
-
-// A utility class that handles IMediaPosition and IMediaSeeking on behalf
-// of single-input pin renderers, or transform filters.
-//
-// Renderers will expose this from the filter; transform filters will
-// expose it from the output pin and not the renderer.
-//
-// Create one of these, giving it your IPin* for your input pin, and delegate
-// all IMediaPosition methods to it. It will query the input pin for
-// IMediaPosition and respond appropriately.
-//
-// Call ForceRefresh if the pin connection changes.
-//
-// This class no longer caches the upstream IMediaPosition or IMediaSeeking
-// it acquires it on each method call. This means ForceRefresh is not needed.
-// The method is kept for source compatibility and to minimise the changes
-// if we need to put it back later for performance reasons.
-
-class CPosPassThru : public IMediaSeeking, public CMediaPosition
-{
-    IPin *m_pPin;
-
-    HRESULT GetPeer(__deref_out IMediaPosition **ppMP);
-    HRESULT GetPeerSeeking(__deref_out IMediaSeeking **ppMS);
-
-public:
-
-    CPosPassThru(__in_opt LPCTSTR, __in_opt LPUNKNOWN, __inout HRESULT*, IPin *);
-    DECLARE_IUNKNOWN
-
-    HRESULT ForceRefresh() {
-        return S_OK;
-    };
-
-    // override to return an accurate current position
-    virtual HRESULT GetMediaTime(__out LONGLONG *pStartTime, __out_opt LONGLONG *pEndTime) {
-        return E_FAIL;
-    }
-
-    STDMETHODIMP NonDelegatingQueryInterface(REFIID riid,__deref_out void **ppv);
-
-    // IMediaSeeking methods
-    STDMETHODIMP GetCapabilities( __out DWORD * pCapabilities );
-    STDMETHODIMP CheckCapabilities( __inout DWORD * pCapabilities );
-    STDMETHODIMP SetTimeFormat(const GUID * pFormat);
-    STDMETHODIMP GetTimeFormat(__out GUID *pFormat);
-    STDMETHODIMP IsUsingTimeFormat(const GUID * pFormat);
-    STDMETHODIMP IsFormatSupported( const GUID * pFormat);
-    STDMETHODIMP QueryPreferredFormat( __out GUID *pFormat);
-    STDMETHODIMP ConvertTimeFormat(__out LONGLONG * pTarget,
-                                   __in_opt const GUID * pTargetFormat,
-                                   LONGLONG Source,
-                                   __in_opt const GUID * pSourceFormat );
-    STDMETHODIMP SetPositions( __inout_opt LONGLONG * pCurrent, DWORD CurrentFlags
-                             , __inout_opt LONGLONG * pStop, DWORD StopFlags );
-
-    STDMETHODIMP GetPositions( __out_opt LONGLONG * pCurrent, __out_opt LONGLONG * pStop );
-    STDMETHODIMP GetCurrentPosition( __out LONGLONG * pCurrent );
-    STDMETHODIMP GetStopPosition( __out LONGLONG * pStop );
-    STDMETHODIMP SetRate( double dRate);
-    STDMETHODIMP GetRate( __out double * pdRate);
-    STDMETHODIMP GetDuration( __out LONGLONG *pDuration);
-    STDMETHODIMP GetAvailable( __out_opt LONGLONG *pEarliest, __out_opt LONGLONG *pLatest );
-    STDMETHODIMP GetPreroll( __out LONGLONG *pllPreroll );
-
-    // IMediaPosition properties
-    STDMETHODIMP get_Duration(__out REFTIME * plength);
-    STDMETHODIMP put_CurrentPosition(REFTIME llTime);
-    STDMETHODIMP get_StopTime(__out REFTIME * pllTime);
-    STDMETHODIMP put_StopTime(REFTIME llTime);
-    STDMETHODIMP get_PrerollTime(__out REFTIME * pllTime);
-    STDMETHODIMP put_PrerollTime(REFTIME llTime);
-    STDMETHODIMP get_Rate(__out double * pdRate);
-    STDMETHODIMP put_Rate(double dRate);
-    STDMETHODIMP get_CurrentPosition(__out REFTIME * pllTime);
-    STDMETHODIMP CanSeekForward(__out LONG *pCanSeekForward);
-    STDMETHODIMP CanSeekBackward(__out LONG *pCanSeekBackward);
-
-private:
-    HRESULT GetSeekingLongLong( HRESULT (__stdcall IMediaSeeking::*pMethod)( LONGLONG * ),
-                                __out LONGLONG * pll );
-};
-
-
-// Adds the ability to return a current position
-
-class CRendererPosPassThru : public CPosPassThru
-{
-    CCritSec m_PositionLock;    // Locks access to our position
-    LONGLONG m_StartMedia;      // Start media time last seen
-    LONGLONG m_EndMedia;        // And likewise the end media
-    BOOL m_bReset;              // Have media times been set
-
-public:
-
-    // Used to help with passing media times through graph
-
-    CRendererPosPassThru(__in_opt LPCTSTR, __in_opt LPUNKNOWN, __inout HRESULT*, IPin *);
-    HRESULT RegisterMediaTime(IMediaSample *pMediaSample);
-    HRESULT RegisterMediaTime(LONGLONG StartTime,LONGLONG EndTime);
-    HRESULT GetMediaTime(__out LONGLONG *pStartTime,__out_opt LONGLONG *pEndTime);
-    HRESULT ResetMediaTime();
-    HRESULT EOS();
-};
-
-STDAPI CreatePosPassThru(
-    __in_opt LPUNKNOWN pAgg,
-    BOOL bRenderer,
-    IPin *pPin,
-    __deref_out IUnknown **ppPassThru
-);
-
-// A class that handles the IDispatch part of IBasicAudio and leaves the
-// properties and methods themselves pure virtual.
-
-class AM_NOVTABLE CBasicAudio : public IBasicAudio, public CUnknown
-{
-    CBaseDispatch m_basedisp;
-
-public:
-
-    CBasicAudio(__in_opt LPCTSTR, __in_opt LPUNKNOWN);
-
-    DECLARE_IUNKNOWN
-
-    // override this to publicise our interfaces
-    STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, __deref_out void **ppv);
-
-    /* IDispatch methods */
-    STDMETHODIMP GetTypeInfoCount(__out UINT * pctinfo);
-
-    STDMETHODIMP GetTypeInfo(
-      UINT itinfo,
-      LCID lcid,
-      __deref_out ITypeInfo ** pptinfo);
-
-    STDMETHODIMP GetIDsOfNames(
-      REFIID riid,
-      __in_ecount(cNames) LPOLESTR * rgszNames,
-      UINT cNames,
-      LCID lcid,
-      __out_ecount(cNames) DISPID * rgdispid);
-
-    STDMETHODIMP Invoke(
-      DISPID dispidMember,
-      REFIID riid,
-      LCID lcid,
-      WORD wFlags,
-      __in DISPPARAMS * pdispparams,
-      __out_opt VARIANT * pvarResult,
-      __out_opt EXCEPINFO * pexcepinfo,
-      __out_opt UINT * puArgErr);
-};
-
-
-// A class that handles the IDispatch part of IBasicVideo and leaves the
-// properties and methods themselves pure virtual.
-
-class AM_NOVTABLE CBaseBasicVideo : public IBasicVideo2, public CUnknown
-{
-    CBaseDispatch m_basedisp;
-
-public:
-
-    CBaseBasicVideo(__in_opt LPCTSTR, __in_opt LPUNKNOWN);
-
-    DECLARE_IUNKNOWN
-
-    // override this to publicise our interfaces
-    STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, __deref_out void **ppv);
-
-    /* IDispatch methods */
-    STDMETHODIMP GetTypeInfoCount(__out UINT * pctinfo);
-
-    STDMETHODIMP GetTypeInfo(
-      UINT itinfo,
-      LCID lcid,
-      __deref_out ITypeInfo ** pptinfo);
-
-    STDMETHODIMP GetIDsOfNames(
-      REFIID riid,
-      __in_ecount(cNames) LPOLESTR * rgszNames,
-      UINT cNames,
-      LCID lcid,
-      __out_ecount(cNames) DISPID * rgdispid);
-
-    STDMETHODIMP Invoke(
-      DISPID dispidMember,
-      REFIID riid,
-      LCID lcid,
-      WORD wFlags,
-      __in DISPPARAMS * pdispparams,
-      __out_opt VARIANT * pvarResult,
-      __out_opt EXCEPINFO * pexcepinfo,
-      __out_opt UINT * puArgErr);
-
-    STDMETHODIMP GetPreferredAspectRatio(
-      __out long *plAspectX,
-      __out long *plAspectY)
-    {
-        return E_NOTIMPL;
-    }
-};
-
-
-// A class that handles the IDispatch part of IVideoWindow and leaves the
-// properties and methods themselves pure virtual.
-
-class AM_NOVTABLE CBaseVideoWindow : public IVideoWindow, public CUnknown
-{
-    CBaseDispatch m_basedisp;
-
-public:
-
-    CBaseVideoWindow(__in_opt LPCTSTR, __in_opt LPUNKNOWN);
-
-    DECLARE_IUNKNOWN
-
-    // override this to publicise our interfaces
-    STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, __deref_out void **ppv);
-
-    /* IDispatch methods */
-    STDMETHODIMP GetTypeInfoCount(__out UINT * pctinfo);
-
-    STDMETHODIMP GetTypeInfo(
-      UINT itinfo,
-      LCID lcid,
-      __deref_out ITypeInfo ** pptinfo);
-
-    STDMETHODIMP GetIDsOfNames(
-      REFIID riid,
-      __in_ecount(cNames) LPOLESTR * rgszNames,
-      UINT cNames,
-      LCID lcid,
-      __out_ecount(cNames) DISPID * rgdispid);
-
-    STDMETHODIMP Invoke(
-      DISPID dispidMember,
-      REFIID riid,
-      LCID lcid,
-      WORD wFlags,
-      __in DISPPARAMS * pdispparams,
-      __out_opt VARIANT * pvarResult,
-      __out_opt EXCEPINFO * pexcepinfo,
-      __out_opt UINT * puArgErr);
-};
-
-
-// abstract class to help source filters with their implementation
-// of IMediaPosition. Derive from this and set the duration (and stop
-// position). Also override NotifyChange to do something when the properties
-// change.
-
-class AM_NOVTABLE CSourcePosition : public CMediaPosition
-{
-
-public:
-    CSourcePosition(__in_opt LPCTSTR, __in_opt LPUNKNOWN, __inout HRESULT*, __in CCritSec *);
-
-    // IMediaPosition methods
-    STDMETHODIMP get_Duration(__out REFTIME * plength);
-    STDMETHODIMP put_CurrentPosition(REFTIME llTime);
-    STDMETHODIMP get_StopTime(__out REFTIME * pllTime);
-    STDMETHODIMP put_StopTime(REFTIME llTime);
-    STDMETHODIMP get_PrerollTime(__out REFTIME * pllTime);
-    STDMETHODIMP put_PrerollTime(REFTIME llTime);
-    STDMETHODIMP get_Rate(__out double * pdRate);
-    STDMETHODIMP put_Rate(double dRate);
-    STDMETHODIMP CanSeekForward(__out LONG *pCanSeekForward);
-    STDMETHODIMP CanSeekBackward(__out LONG *pCanSeekBackward);
-
-    // override if you can return the data you are actually working on
-    STDMETHODIMP get_CurrentPosition(__out REFTIME * pllTime) {
-        return E_NOTIMPL;
-    };
-
-protected:
-
-    // we call this to notify changes. Override to handle them
-    virtual HRESULT ChangeStart() PURE;
-    virtual HRESULT ChangeStop() PURE;
-    virtual HRESULT ChangeRate() PURE;
-
-    COARefTime m_Duration;
-    COARefTime m_Start;
-    COARefTime m_Stop;
-    double m_Rate;
-
-    CCritSec * m_pLock;
-};
-
-class AM_NOVTABLE CSourceSeeking :
-    public IMediaSeeking,
-    public CUnknown
-{
-
-public:
-
-    DECLARE_IUNKNOWN;
-    STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, __deref_out void **ppv);
-
-    // IMediaSeeking methods
-
-    STDMETHODIMP IsFormatSupported(const GUID * pFormat);
-    STDMETHODIMP QueryPreferredFormat(__out GUID *pFormat);
-    STDMETHODIMP SetTimeFormat(const GUID * pFormat);
-    STDMETHODIMP IsUsingTimeFormat(const GUID * pFormat);
-    STDMETHODIMP GetTimeFormat(__out GUID *pFormat);
-    STDMETHODIMP GetDuration(__out LONGLONG *pDuration);
-    STDMETHODIMP GetStopPosition(__out LONGLONG *pStop);
-    STDMETHODIMP GetCurrentPosition(__out LONGLONG *pCurrent);
-    STDMETHODIMP GetCapabilities( __out DWORD * pCapabilities );
-    STDMETHODIMP CheckCapabilities( __inout DWORD * pCapabilities );
-    STDMETHODIMP ConvertTimeFormat( __out LONGLONG * pTarget,
-                                    __in_opt const GUID * pTargetFormat,
-                                    LONGLONG Source,
-                                    __in_opt const GUID * pSourceFormat );
-
-    STDMETHODIMP SetPositions( __inout_opt LONGLONG * pCurrent,  DWORD CurrentFlags
-			     , __inout_opt LONGLONG * pStop,  DWORD StopFlags );
-
-    STDMETHODIMP GetPositions( __out_opt LONGLONG * pCurrent, __out_opt LONGLONG * pStop );
-
-    STDMETHODIMP GetAvailable( __out_opt LONGLONG * pEarliest, __out_opt LONGLONG * pLatest );
-    STDMETHODIMP SetRate( double dRate);
-    STDMETHODIMP GetRate( __out double * pdRate);
-    STDMETHODIMP GetPreroll(__out LONGLONG *pPreroll);
-
-
-protected:
-
-    // ctor
-    CSourceSeeking(__in_opt LPCTSTR, __in_opt LPUNKNOWN, __inout HRESULT*, __in CCritSec *);
-
-    // we call this to notify changes. Override to handle them
-    virtual HRESULT ChangeStart() PURE;
-    virtual HRESULT ChangeStop() PURE;
-    virtual HRESULT ChangeRate() PURE;
-
-    CRefTime m_rtDuration;      // length of stream
-    CRefTime m_rtStart;         // source will start here
-    CRefTime m_rtStop;          // source will stop here
-    double m_dRateSeeking;
-
-    // seeking capabilities
-    DWORD m_dwSeekingCaps;
-
-    CCritSec * m_pLock;
-};
-
-
-// Base classes supporting Deferred commands.
-
-// Deferred commands are queued by calls to methods on the IQueueCommand
-// interface, exposed by the filtergraph and by some filters. A successful
-// call to one of these methods will return an IDeferredCommand interface
-// representing the queued command.
-//
-// A CDeferredCommand object represents a single deferred command, and exposes
-// the IDeferredCommand interface as well as other methods permitting time
-// checks and actual execution. It contains a reference to the CCommandQueue
-// object on which it is queued.
-//
-// CCommandQueue is a base class providing a queue of CDeferredCommand
-// objects, and methods to add, remove, check status and invoke the queued
-// commands. A CCommandQueue object would be part of an object that
-// implemented IQueueCommand.
-
-class CCmdQueue;
-
-// take a copy of the params and store them. Release any allocated
-// memory in destructor
-
-class CDispParams : public DISPPARAMS
-{
-public:
-    CDispParams(UINT nArgs, __in_ecount(nArgs) VARIANT* pArgs, __inout_opt HRESULT *phr = NULL);
-    ~CDispParams();
-};
-
-
-// CDeferredCommand lifetime is controlled by refcounts. Caller of
-// InvokeAt.. gets a refcounted interface pointer, and the CCmdQueue
-// object also holds a refcount on us. Calling Cancel or Invoke takes
-// us off the CCmdQueue and thus reduces the refcount by 1. Once taken
-// off the queue we cannot be put back on the queue.
-
-class CDeferredCommand
-    : public CUnknown,
-      public IDeferredCommand
-{
-public:
-
-    CDeferredCommand(
-        __inout CCmdQueue * pQ,
-        __in_opt LPUNKNOWN   pUnk,               // aggregation outer unk
-        __inout HRESULT *   phr,
-        __in LPUNKNOWN   pUnkExecutor,       // object that will execute this cmd
-        REFTIME     time,
-        __in GUID*       iid,
-        long        dispidMethod,
-        short       wFlags,
-        long        cArgs,
-        __in_ecount(cArgs) VARIANT*    pDispParams,
-        __out VARIANT*    pvarResult,
-        __out short*      puArgErr,
-        BOOL        bStream
-        );
-
-    DECLARE_IUNKNOWN
-
-    // override this to publicise our interfaces
-    STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, __out void **ppv);
-
-    // IDeferredCommand methods
-    STDMETHODIMP Cancel();
-    STDMETHODIMP Confidence(
-                    __out LONG* pConfidence);
-    STDMETHODIMP Postpone(
-                    REFTIME newtime);
-    STDMETHODIMP GetHResult(
-                    __out HRESULT* phrResult);
-
-    // other public methods
-
-    HRESULT Invoke();
-
-    // access methods
-
-    // returns TRUE if streamtime, FALSE if presentation time
-    BOOL IsStreamTime() {
-       return m_bStream;
-    };
-
-    CRefTime GetTime() {
-        return m_time;
-    };
-
-    REFIID GetIID() {
-        return *m_iid;
-    };
-
-    long GetMethod() {
-        return m_dispidMethod;
-    };
-
-    short GetFlags() {
-        return m_wFlags;
-    };
-
-    DISPPARAMS* GetParams() {
-        return &m_DispParams;
-    };
-
-    VARIANT* GetResult() {
-        return m_pvarResult;
-    };
-
-protected:
-
-    CCmdQueue* m_pQueue;
-
-    // pUnk for the interface that we will execute the command on
-    LPUNKNOWN   m_pUnk;
-
-    // stored command data
-    REFERENCE_TIME     m_time;
-    GUID*       m_iid;
-    long        m_dispidMethod;
-    short       m_wFlags;
-    VARIANT*    m_pvarResult;
-    BOOL        m_bStream;
-    CDispParams m_DispParams;
-    DISPID      m_DispId;         //  For get and put
-
-    // we use this for ITypeInfo access
-    CBaseDispatch   m_Dispatch;
-
-    // save retval here
-    HRESULT     m_hrResult;
-};
-
-
-// a list of CDeferredCommand objects. this is a base class providing
-// the basics of access to the list. If you want to use CDeferredCommand
-// objects then your queue needs to be derived from this class.
-
-class AM_NOVTABLE CCmdQueue
-{
-public:
-    CCmdQueue(__inout_opt HRESULT *phr = NULL);
-    virtual ~CCmdQueue();
-
-    // returns a new CDeferredCommand object that will be initialised with
-    // the parameters and will be added to the queue during construction.
-    // returns S_OK if successfully created otherwise an error and
-    // no object has been queued.
-    virtual HRESULT  New(
-        __out CDeferredCommand **ppCmd,
-        __in LPUNKNOWN   pUnk,
-        REFTIME     time,
-        __in GUID*       iid,
-        long        dispidMethod,
-        short       wFlags,
-        long        cArgs,
-        __in_ecount(cArgs) VARIANT*    pDispParams,
-        __out VARIANT*    pvarResult,
-        __out short*      puArgErr,
-        BOOL        bStream
-    );
-
-    // called by the CDeferredCommand object to add and remove itself
-    // from the queue
-    virtual HRESULT Insert(__in CDeferredCommand* pCmd);
-    virtual HRESULT Remove(__in CDeferredCommand* pCmd);
-
-    // Command-Due Checking
-    //
-    // There are two schemes of synchronisation: coarse and accurate. In
-    // coarse mode, you wait till the time arrives and then execute the cmd.
-    // In accurate mode, you wait until you are processing the sample that
-    // will appear at the time, and then execute the command. It's up to the
-    // filter which one it will implement. The filtergraph will always
-    // implement coarse mode for commands queued at the filtergraph.
-    //
-    // If you want coarse sync, you probably want to wait until there is a
-    // command due, and then execute it. You can do this by calling
-    // GetDueCommand. If you have several things to wait for, get the
-    // event handle from GetDueHandle() and when this is signalled then call
-    // GetDueCommand. Stream time will only advance between calls to Run and
-    // EndRun. Note that to avoid an extra thread there is no guarantee that
-    // if the handle is set there will be a command ready. Each time the
-    // event is signalled, call GetDueCommand (probably with a 0 timeout);
-    // This may return E_ABORT.
-    //
-    // If you want accurate sync, you must call GetCommandDueFor, passing
-    // as a parameter the stream time of the samples you are about to process.
-    // This will return:
-    //   -- a stream-time command due at or before that stream time
-    //   -- a presentation-time command due at or before the
-    //      time that stream time will be presented (only between Run
-    //      and EndRun calls, since outside of this, the mapping from
-    //      stream time to presentation time is not known.
-    //   -- any presentation-time command due now.
-    // This means that if you want accurate synchronisation on samples that
-    // might be processed during Paused mode, you need to use
-    // stream-time commands.
-    //
-    // In all cases, commands remain queued until Invoked or Cancelled. The
-    // setting and resetting of the event handle is managed entirely by this
-    // queue object.
-
-    // set the clock used for timing
-    virtual HRESULT SetSyncSource(__in_opt IReferenceClock*);
-
-    // switch to run mode. Streamtime to Presentation time mapping known.
-    virtual HRESULT Run(REFERENCE_TIME tStreamTimeOffset);
-
-    // switch to Stopped or Paused mode. Time mapping not known.
-    virtual HRESULT EndRun();
-
-    // return a pointer to the next due command. Blocks for msTimeout
-    // milliseconds until there is a due command.
-    // Stream-time commands will only become due between Run and Endrun calls.
-    // The command remains queued until invoked or cancelled.
-    // Returns E_ABORT if timeout occurs, otherwise S_OK (or other error).
-    // Returns an AddRef-ed object
-    virtual HRESULT GetDueCommand(__out CDeferredCommand ** ppCmd, long msTimeout);
-
-    // return the event handle that will be signalled whenever
-    // there are deferred commands due for execution (when GetDueCommand
-    // will not block).
-    HANDLE GetDueHandle() {
-        return HANDLE(m_evDue);
-    };
-
-    // return a pointer to a command that will be due for a given time.
-    // Pass in a stream time here. The stream time offset will be passed
-    // in via the Run method.
-    // Commands remain queued until invoked or cancelled.
-    // This method will not block. It will report VFW_E_NOT_FOUND if there
-    // are no commands due yet.
-    // Returns an AddRef-ed object
-    virtual HRESULT GetCommandDueFor(REFERENCE_TIME tStream, __out CDeferredCommand**ppCmd);
-
-    // check if a given time is due (TRUE if it is due yet)
-    BOOL CheckTime(CRefTime time, BOOL bStream) {
-
-        // if no clock, nothing is due!
-        if (!m_pClock) {
-            return FALSE;
-        }
-
-        // stream time
-        if (bStream) {
-
-            // not valid if not running
-            if (!m_bRunning) {
-                return FALSE;
-            }
-            // add on known stream time offset to get presentation time
-            time += m_StreamTimeOffset;
-        }
-
-        CRefTime Now;
-        m_pClock->GetTime((REFERENCE_TIME*)&Now);
-        return (time <= Now);
-    };
-
-protected:
-
-    // protect access to lists etc
-    CCritSec m_Lock;
-
-    // commands queued in presentation time are stored here
-    CGenericList<CDeferredCommand> m_listPresentation;
-
-    // commands queued in stream time are stored here
-    CGenericList<CDeferredCommand> m_listStream;
-
-    // set when any commands are due
-    CAMEvent m_evDue;
-
-    // creates an advise for the earliest time required, if any
-    void SetTimeAdvise(void);
-
-    // advise id from reference clock (0 if no outstanding advise)
-    DWORD_PTR m_dwAdvise;
-
-    // advise time is for this presentation time
-    CRefTime m_tCurrentAdvise;
-
-    // the reference clock we are using (addrefed)
-    IReferenceClock* m_pClock;
-
-    // true when running
-    BOOL m_bRunning;
-
-    // contains stream time offset when m_bRunning is true
-    CRefTime m_StreamTimeOffset;
-};
-
-#endif // __CTLUTIL__

3rdparty/baseclasses/ddmm.cpp

@@ -1,129 +0,0 @@
-//------------------------------------------------------------------------------
-// File: DDMM.cpp
-//
-// Desc: DirectShow base classes - implements routines for using DirectDraw
-//       on a multimonitor system.
-//
-// Copyright (c) 1995-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-#include <streams.h>
-#include <ddraw.h>
-#include "ddmm.h"
-
-/*
- * FindDeviceCallback
- */
-typedef struct {
-	LPSTR   szDevice;
-	GUID*   lpGUID;
-	GUID    GUID;
-	BOOL    fFound;
-}   FindDeviceData;
-
-BOOL CALLBACK FindDeviceCallback(__in_opt GUID* lpGUID, __in LPSTR szName, __in LPSTR szDevice, __in LPVOID lParam)
-{
-	FindDeviceData *p = (FindDeviceData*)lParam;
-
-	if (lstrcmpiA(p->szDevice, szDevice) == 0) {
-	    if (lpGUID) {
-		p->GUID = *lpGUID;
-		p->lpGUID = &p->GUID;
-	    } else {
-		p->lpGUID = NULL;
-	    }
-	    p->fFound = TRUE;
-	    return FALSE;
-	}
-	return TRUE;
-}
-
-
-BOOL CALLBACK FindDeviceCallbackEx(__in_opt GUID* lpGUID, __in LPSTR szName, __in LPSTR szDevice, __in LPVOID lParam, HMONITOR hMonitor)
-{
-	FindDeviceData *p = (FindDeviceData*)lParam;
-
-	if (lstrcmpiA(p->szDevice, szDevice) == 0) {
-	    if (lpGUID) {
-		p->GUID = *lpGUID;
-		p->lpGUID = &p->GUID;
-	    } else {
-		p->lpGUID = NULL;
-	    }
-	    p->fFound = TRUE;
-	    return FALSE;
-	}
-	return TRUE;
-}
-
-
-/*
- * DirectDrawCreateFromDevice
- *
- * create a DirectDraw object for a particular device
- */
-IDirectDraw * DirectDrawCreateFromDevice(__in_opt LPSTR szDevice, PDRAWCREATE DirectDrawCreateP, PDRAWENUM DirectDrawEnumerateP)
-{
-	IDirectDraw*    pdd = NULL;
-	FindDeviceData  find;
-
-	if (szDevice == NULL) {
-		DirectDrawCreateP(NULL, &pdd, NULL);
-		return pdd;
-	}
-
-	find.szDevice = szDevice;
-	find.fFound   = FALSE;
-	DirectDrawEnumerateP(FindDeviceCallback, (LPVOID)&find);
-
-	if (find.fFound)
-	{
-		//
-		// In 4bpp mode the following DDraw call causes a message box to be popped
-		// up by DDraw (!?!).  It's DDraw's fault, but we don't like it.  So we
-		// make sure it doesn't happen.
-		//
-		UINT ErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
-		DirectDrawCreateP(find.lpGUID, &pdd, NULL);
-		SetErrorMode(ErrorMode);
-	}
-
-	return pdd;
-}
-
-
-/*
- * DirectDrawCreateFromDeviceEx
- *
- * create a DirectDraw object for a particular device
- */
-IDirectDraw * DirectDrawCreateFromDeviceEx(__in_opt LPSTR szDevice, PDRAWCREATE DirectDrawCreateP, LPDIRECTDRAWENUMERATEEXA DirectDrawEnumerateExP)
-{
-	IDirectDraw*    pdd = NULL;
-	FindDeviceData  find;
-
-	if (szDevice == NULL) {
-		DirectDrawCreateP(NULL, &pdd, NULL);
-		return pdd;
-	}
-
-	find.szDevice = szDevice;
-	find.fFound   = FALSE;
-	DirectDrawEnumerateExP(FindDeviceCallbackEx, (LPVOID)&find,
-					DDENUM_ATTACHEDSECONDARYDEVICES);
-
-	if (find.fFound)
-	{
-		//
-		// In 4bpp mode the following DDraw call causes a message box to be popped
-		// up by DDraw (!?!).  It's DDraw's fault, but we don't like it.  So we
-		// make sure it doesn't happen.
-		//
-		UINT ErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
-		DirectDrawCreateP(find.lpGUID, &pdd, NULL);
-		SetErrorMode(ErrorMode);
-	}
-
-	return pdd;
-}

3rdparty/baseclasses/ddmm.h

@@ -1,28 +0,0 @@
-//------------------------------------------------------------------------------
-// File: DDMM.h
-//
-// Desc: DirectShow base classes - efines routines for using DirectDraw
-//       on a multimonitor system.
-//
-// Copyright (c) 1995-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-#ifdef __cplusplus
-extern "C" {            /* Assume C declarations for C++ */
-#endif  /* __cplusplus */
-
-// DDRAW.H might not include these
-#ifndef DDENUM_ATTACHEDSECONDARYDEVICES
-#define DDENUM_ATTACHEDSECONDARYDEVICES     0x00000001L
-#endif
-
-typedef HRESULT (*PDRAWCREATE)(IID *,LPDIRECTDRAW *,LPUNKNOWN);
-typedef HRESULT (*PDRAWENUM)(LPDDENUMCALLBACKA, LPVOID);
-
-IDirectDraw * DirectDrawCreateFromDevice(__in_opt LPSTR, PDRAWCREATE, PDRAWENUM);
-IDirectDraw * DirectDrawCreateFromDeviceEx(__in_opt LPSTR, PDRAWCREATE, LPDIRECTDRAWENUMERATEEXA);
-
-#ifdef __cplusplus
-}
-#endif	/* __cplusplus */

3rdparty/baseclasses/fourcc.h

@@ -1,101 +0,0 @@
-//------------------------------------------------------------------------------
-// File: FourCC.h
-//
-// Desc: DirectShow base classes.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-// FOURCCMap
-//
-// provides a mapping between old-style multimedia format DWORDs
-// and new-style GUIDs.
-//
-// A range of 4 billion GUIDs has been allocated to ensure that this
-// mapping can be done straightforwardly one-to-one in both directions.
-//
-// January 95
-
-
-#ifndef __FOURCC__
-#define __FOURCC__
-
-
-// Multimedia format types are marked with DWORDs built from four 8-bit
-// chars and known as FOURCCs. New multimedia AM_MEDIA_TYPE definitions include
-// a subtype GUID. In order to simplify the mapping, GUIDs in the range:
-//    XXXXXXXX-0000-0010-8000-00AA00389B71
-// are reserved for FOURCCs.
-
-class FOURCCMap : public GUID
-{
-
-public:
-    FOURCCMap();
-    FOURCCMap(DWORD Fourcc);
-    FOURCCMap(const GUID *);
-
-
-    DWORD GetFOURCC(void);
-    void SetFOURCC(DWORD fourcc);
-    void SetFOURCC(const GUID *);
-
-private:
-    void InitGUID();
-};
-
-#define GUID_Data2      0
-#define GUID_Data3     0x10
-#define GUID_Data4_1   0xaa000080
-#define GUID_Data4_2   0x719b3800
-
-inline void
-FOURCCMap::InitGUID() {
-    Data2 = GUID_Data2;
-    Data3 = GUID_Data3;
-    ((DWORD *)Data4)[0] = GUID_Data4_1;
-    ((DWORD *)Data4)[1] = GUID_Data4_2;
-}
-
-inline
-FOURCCMap::FOURCCMap() {
-    InitGUID();
-    SetFOURCC( DWORD(0));
-}
-
-inline
-FOURCCMap::FOURCCMap(DWORD fourcc)
-{
-    InitGUID();
-    SetFOURCC(fourcc);
-}
-
-inline
-FOURCCMap::FOURCCMap(const GUID * pGuid)
-{
-    InitGUID();
-    SetFOURCC(pGuid);
-}
-
-inline void
-FOURCCMap::SetFOURCC(const GUID * pGuid)
-{
-    FOURCCMap * p = (FOURCCMap*) pGuid;
-    SetFOURCC(p->GetFOURCC());
-}
-
-inline void
-FOURCCMap::SetFOURCC(DWORD fourcc)
-{
-    Data1 = fourcc;
-}
-
-inline DWORD
-FOURCCMap::GetFOURCC(void)
-{
-    return Data1;
-}
-
-#endif /* __FOURCC__ */
-

3rdparty/baseclasses/measure.h

@@ -1,222 +0,0 @@
-//------------------------------------------------------------------------------
-// File: Measure.h
-//
-// Desc: DirectShow base classes.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-/*
-   The idea is to pepper the source code with interesting measurements and
-   have the last few thousand of these recorded in a circular buffer that
-   can be post-processed to give interesting numbers.
-
-   WHAT THE LOG LOOKS LIKE:
-
-  Time (sec)   Type        Delta  Incident_Name
-    0.055,41  NOTE      -.       Incident Nine  - Another note
-    0.055,42  NOTE      0.000,01 Incident Nine  - Another note
-    0.055,44  NOTE      0.000,02 Incident Nine  - Another note
-    0.055,45  STOP      -.       Incident Eight - Also random
-    0.055,47  START     -.       Incident Seven - Random
-    0.055,49  NOTE      0.000,05 Incident Nine  - Another note
-    ------- <etc.  there is a lot of this> ----------------
-    0.125,60  STOP      0.000,03 Msr_Stop
-    0.125,62  START     -.       Msr_Start
-    0.125,63  START     -.       Incident Two   - Start/Stop
-    0.125,65  STOP      0.000,03 Msr_Start
-    0.125,66  START     -.       Msr_Stop
-    0.125,68  STOP      0.000,05 Incident Two   - Start/Stop
-    0.125,70  STOP      0.000,04 Msr_Stop
-    0.125,72  START     -.       Msr_Start
-    0.125,73  START     -.       Incident Two   - Start/Stop
-    0.125,75  STOP      0.000,03 Msr_Start
-    0.125,77  START     -.       Msr_Stop
-    0.125,78  STOP      0.000,05 Incident Two   - Start/Stop
-    0.125,80  STOP      0.000,03 Msr_Stop
-    0.125,81  NOTE      -.       Incident Three - single Note
-    0.125,83  START     -.       Incident Four  - Start, no stop
-    0.125,85  START     -.       Incident Five  - Single Start/Stop
-    0.125,87  STOP      0.000,02 Incident Five  - Single Start/Stop
-
-Number      Average       StdDev     Smallest      Largest Incident_Name
-    10     0.000,58     0.000,10     0.000,55     0.000,85 Incident One   - Note
-    50     0.000,05     0.000,00     0.000,05     0.000,05 Incident Two   - Start/Stop
-     1     -.           -.           -.           -.       Incident Three - single Note
-     0     -.           -.           -.           -.       Incident Four  - Start, no stop
-     1     0.000,02     -.           0.000,02     0.000,02 Incident Five  - Single Start/Stop
-     0     -.           -.           -.           -.       Incident Six   - zero occurrences
-   100     0.000,25     0.000,12     0.000,02     0.000,62 Incident Seven - Random
-   100     0.000,79     0.000,48     0.000,02     0.001,92 Incident Eight - Also random
-  5895     0.000,01     0.000,01     0.000,01     0.000,56 Incident Nine  - Another note
-    10     0.000,03     0.000,00     0.000,03     0.000,04 Msr_Note
-    50     0.000,03     0.000,00     0.000,03     0.000,04 Msr_Start
-    50     0.000,04     0.000,03     0.000,03     0.000,31 Msr_Stop
-
-  WHAT IT MEANS:
-    The log shows what happened and when.  Each line shows the time at which
-    something happened (see WHAT YOU CODE below) what it was that happened
-    and (if approporate) the time since the corresponding previous event
-    (that's the delta column).
-
-    The statistics show how many times each event occurred, what the average
-    delta time was, also the standard deviation, largest and smalles delta.
-
-   WHAT YOU CODE:
-
-   Before anything else executes: - register your ids
-
-    int id1     = Msr_Register("Incident One   - Note");
-    int id2     = Msr_Register("Incident Two   - Start/Stop");
-    int id3     = Msr_Register("Incident Three - single Note");
-    etc.
-
-   At interesting moments:
-
-       // To measure a repetitive event - e.g. end of bitblt to screen
-       Msr_Note(Id9);             // e.g. "video frame hiting the screen NOW!"
-
-           or
-
-       // To measure an elapsed time e.g. time taken to decode an MPEG B-frame
-       Msr_Start(Id2);            // e.g. "Starting to decode MPEG B-frame"
-         . . .
-       MsrStop(Id2);              //      "Finished MPEG decode"
-
-   At the end:
-
-       HANDLE hFile;
-       hFile = CreateFile("Perf.log", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
-       Msr_Dump(hFile);           // This writes the log out to the file
-       CloseHandle(hFile);
-
-           or
-
-       Msr_Dump(NULL);            // This writes it to DbgLog((LOG_TRACE,0, ... ));
-                                  // but if you are writing it out to the debugger
-                                  // then the times are probably all garbage because
-                                  // the debugger can make things run awfully slow.
-
-    A given id should be used either for start / stop or Note calls.  If Notes
-    are mixed in with Starts and Stops their statistics will be gibberish.
-
-    If you code the calls in upper case i.e. MSR_START(idMunge); then you get
-    macros which will turn into nothing unless PERF is defined.
-
-    You can reset the statistical counts for a given id by calling Reset(Id).
-    They are reset by default at the start.
-    It logs Reset as a special incident, so you can see it in the log.
-
-    The log is a circular buffer in storage (to try to minimise disk I/O).
-    It overwrites the oldest entries once full.  The statistics include ALL
-    incidents since the last Reset, whether still visible in the log or not.
-*/
-
-#ifndef __MEASURE__
-#define __MEASURE__
-
-#ifdef PERF
-#define MSR_INIT() Msr_Init()
-#define MSR_TERMINATE() Msr_Terminate()
-#define MSR_REGISTER(a) Msr_Register(a)
-#define MSR_RESET(a) Msr_Reset(a)
-#define MSR_CONTROL(a) Msr_Control(a)
-#define MSR_START(a) Msr_Start(a)
-#define MSR_STOP(a) Msr_Stop(a)
-#define MSR_NOTE(a) Msr_Note(a)
-#define MSR_INTEGER(a,b) Msr_Integer(a,b)
-#define MSR_DUMP(a) Msr_Dump(a)
-#define MSR_DUMPSTATS(a) Msr_DumpStats(a)
-#else
-#define MSR_INIT() ((void)0)
-#define MSR_TERMINATE() ((void)0)
-#define MSR_REGISTER(a) 0
-#define MSR_RESET(a) ((void)0)
-#define MSR_CONTROL(a) ((void)0)
-#define MSR_START(a) ((void)0)
-#define MSR_STOP(a) ((void)0)
-#define MSR_NOTE(a) ((void)0)
-#define MSR_INTEGER(a,b) ((void)0)
-#define MSR_DUMP(a) ((void)0)
-#define MSR_DUMPSTATS(a) ((void)0)
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// This must be called first - (called by the DllEntry)
-
-void WINAPI Msr_Init(void);
-
-
-// Call this last to clean up (or just let it fall off the end - who cares?)
-
-void WINAPI Msr_Terminate(void);
-
-
-// Call this to get an Id for an "incident" that you can pass to Start, Stop or Note
-// everything that's logged is called an "incident".
-
-int  WINAPI Msr_Register(__in LPTSTR Incident);
-
-
-// Reset the statistical counts for an incident
-
-void WINAPI Msr_Reset(int Id);
-
-
-// Reset all the counts for all incidents
-#define MSR_RESET_ALL 0
-#define MSR_PAUSE 1
-#define MSR_RUN 2
-
-void WINAPI Msr_Control(int iAction);
-
-
-// log the start of an operation
-
-void WINAPI Msr_Start(int Id);
-
-
-// log the end of an operation
-
-void WINAPI Msr_Stop(int Id);
-
-
-// log a one-off or repetitive operation
-
-void WINAPI Msr_Note(int Id);
-
-
-// log an integer (on which we can see statistics later)
-void WINAPI Msr_Integer(int Id, int n);
-
-
-// print out all the vaialable log (it may have wrapped) and then the statistics.
-// When the log wraps you lose log but the statistics are still complete.
-// hFIle==NULL => use DbgLog
-// otherwise hFile must have come from CreateFile or OpenFile.
-
-void WINAPI Msr_Dump(HANDLE hFile);
-
-
-// just dump the statistics - never mind the log
-
-void WINAPI Msr_DumpStats(HANDLE hFile);
-
-// Type definitions in case you want to declare a pointer to the dump functions
-// (makes it a trifle easier to do dynamic linking
-// i.e. LoadModule, GetProcAddress and call that)
-
-// Typedefs so can declare MSR_DUMPPROC *MsrDumpStats; or whatever
-typedef void WINAPI MSR_DUMPPROC(HANDLE hFile);
-typedef void WINAPI MSR_CONTROLPROC(int iAction);
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // __MEASURE__

3rdparty/baseclasses/msgthrd.h

@@ -1,120 +0,0 @@
-//------------------------------------------------------------------------------
-// File: MsgThrd.h
-//
-// Desc: DirectShow base classes - provides support for a worker thread
-//       class to which one can asynchronously post messages.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-// Message class - really just a structure.
-//
-class CMsg {
-public:
-    UINT uMsg;
-    DWORD dwFlags;
-    LPVOID lpParam;
-    CAMEvent *pEvent;
-
-    CMsg(UINT u, DWORD dw, __inout_opt LPVOID lp, __in_opt CAMEvent *pEvnt)
-        : uMsg(u), dwFlags(dw), lpParam(lp), pEvent(pEvnt) {}
-
-    CMsg()
-        : uMsg(0), dwFlags(0L), lpParam(NULL), pEvent(NULL) {}
-};
-
-// This is the actual thread class.  It exports all the usual thread control
-// functions.  The created thread is different from a normal WIN32 thread in
-// that it is prompted to perform particaular tasks by responding to messages
-// posted to its message queue.
-//
-class AM_NOVTABLE CMsgThread {
-private:
-    static DWORD WINAPI DefaultThreadProc(__inout LPVOID lpParam);
-    DWORD               m_ThreadId;
-    HANDLE              m_hThread;
-
-protected:
-
-    // if you want to override GetThreadMsg to block on other things
-    // as well as this queue, you need access to this
-    CGenericList<CMsg>        m_ThreadQueue;
-    CCritSec                  m_Lock;
-    HANDLE                    m_hSem;
-    LONG                      m_lWaiting;
-
-public:
-    CMsgThread()
-        : m_ThreadId(0),
-        m_hThread(NULL),
-        m_lWaiting(0),
-        m_hSem(NULL),
-        // make a list with a cache of 5 items
-        m_ThreadQueue(NAME("MsgThread list"), 5)
-        {
-        }
-
-    ~CMsgThread();
-    // override this if you want to block on other things as well
-    // as the message loop
-    void virtual GetThreadMsg(__out CMsg *msg);
-
-    // override this if you want to do something on thread startup
-    virtual void OnThreadInit() {
-    };
-
-    BOOL CreateThread();
-
-    BOOL WaitForThreadExit(__out LPDWORD lpdwExitCode) {
-        if (m_hThread != NULL) {
-            WaitForSingleObject(m_hThread, INFINITE);
-            return GetExitCodeThread(m_hThread, lpdwExitCode);
-        }
-        return FALSE;
-    }
-
-    DWORD ResumeThread() {
-        return ::ResumeThread(m_hThread);
-    }
-
-    DWORD SuspendThread() {
-        return ::SuspendThread(m_hThread);
-    }
-
-    int GetThreadPriority() {
-        return ::GetThreadPriority(m_hThread);
-    }
-
-    BOOL SetThreadPriority(int nPriority) {
-        return ::SetThreadPriority(m_hThread, nPriority);
-    }
-
-    HANDLE GetThreadHandle() {
-        return m_hThread;
-    }
-
-    DWORD GetThreadId() {
-        return m_ThreadId;
-    }
-
-
-    void PutThreadMsg(UINT uMsg, DWORD dwMsgFlags,
-                      __in_opt LPVOID lpMsgParam, __in_opt CAMEvent *pEvent = NULL) {
-        CAutoLock lck(&m_Lock);
-        CMsg* pMsg = new CMsg(uMsg, dwMsgFlags, lpMsgParam, pEvent);
-        m_ThreadQueue.AddTail(pMsg);
-        if (m_lWaiting != 0) {
-            ReleaseSemaphore(m_hSem, m_lWaiting, 0);
-            m_lWaiting = 0;
-        }
-    }
-
-    // This is the function prototype of the function that the client
-    // supplies.  It is always called on the created thread, never on
-    // the creator thread.
-    //
-    virtual LRESULT ThreadMessageProc(
-        UINT uMsg, DWORD dwFlags, __inout_opt LPVOID lpParam, __in_opt CAMEvent *pEvent) = 0;
-};
-

3rdparty/baseclasses/mtype.cpp

@@ -1,478 +0,0 @@
-//------------------------------------------------------------------------------
-// File: MType.cpp
-//
-// Desc: DirectShow base classes - implements a class that holds and
-//       manages media type information.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-// helper class that derived pin objects can use to compare media
-// types etc. Has same data members as the struct AM_MEDIA_TYPE defined
-// in the streams IDL file, but also has (non-virtual) functions
-
-#include <streams.h>
-#include <mmreg.h>
-
-CMediaType::~CMediaType(){
-    FreeMediaType(*this);
-}
-
-
-CMediaType::CMediaType()
-{
-    InitMediaType();
-}
-
-
-CMediaType::CMediaType(const GUID * type)
-{
-    InitMediaType();
-    majortype = *type;
-}
-
-
-// copy constructor does a deep copy of the format block
-
-CMediaType::CMediaType(const AM_MEDIA_TYPE& rt, __out_opt HRESULT* phr)
-{
-    HRESULT hr = CopyMediaType(this, &rt);
-    if (FAILED(hr) && (NULL != phr)) {
-        *phr = hr;
-    }
-}
-
-
-CMediaType::CMediaType(const CMediaType& rt, __out_opt HRESULT* phr)
-{
-    HRESULT hr = CopyMediaType(this, &rt);
-    if (FAILED(hr) && (NULL != phr)) {
-        *phr = hr;
-    }
-}
-
-
-// this class inherits publicly from AM_MEDIA_TYPE so the compiler could generate
-// the following assignment operator itself, however it could introduce some
-// memory conflicts and leaks in the process because the structure contains
-// a dynamically allocated block (pbFormat) which it will not copy correctly
-
-CMediaType&
-CMediaType::operator=(const AM_MEDIA_TYPE& rt)
-{
-    Set(rt);
-    return *this;
-}
-
-CMediaType&
-CMediaType::operator=(const CMediaType& rt)
-{
-    *this = (AM_MEDIA_TYPE &) rt;
-    return *this;
-}
-
-BOOL
-CMediaType::operator == (const CMediaType& rt) const
-{
-    // I don't believe we need to check sample size or
-    // temporal compression flags, since I think these must
-    // be represented in the type, subtype and format somehow. They
-    // are pulled out as separate flags so that people who don't understand
-    // the particular format representation can still see them, but
-    // they should duplicate information in the format block.
-
-    return ((IsEqualGUID(majortype,rt.majortype) == TRUE) &&
-        (IsEqualGUID(subtype,rt.subtype) == TRUE) &&
-        (IsEqualGUID(formattype,rt.formattype) == TRUE) &&
-        (cbFormat == rt.cbFormat) &&
-        ( (cbFormat == 0) ||
-          pbFormat != NULL && rt.pbFormat != NULL &&
-          (memcmp(pbFormat, rt.pbFormat, cbFormat) == 0)));
-}
-
-
-BOOL
-CMediaType::operator != (const CMediaType& rt) const
-{
-    /* Check to see if they are equal */
-
-    if (*this == rt) {
-        return FALSE;
-    }
-    return TRUE;
-}
-
-
-HRESULT
-CMediaType::Set(const CMediaType& rt)
-{
-    return Set((AM_MEDIA_TYPE &) rt);
-}
-
-
-HRESULT
-CMediaType::Set(const AM_MEDIA_TYPE& rt)
-{
-    if (&rt != this) {
-        FreeMediaType(*this);
-        HRESULT hr = CopyMediaType(this, &rt);
-        if (FAILED(hr)) {
-            return E_OUTOFMEMORY;
-        }
-    }
-
-    return S_OK;
-}
-
-
-BOOL
-CMediaType::IsValid() const
-{
-    return (!IsEqualGUID(majortype,GUID_NULL));
-}
-
-
-void
-CMediaType::SetType(const GUID* ptype)
-{
-    majortype = *ptype;
-}
-
-
-void
-CMediaType::SetSubtype(const GUID* ptype)
-{
-    subtype = *ptype;
-}
-
-
-ULONG
-CMediaType::GetSampleSize() const {
-    if (IsFixedSize()) {
-        return lSampleSize;
-    } else {
-        return 0;
-    }
-}
-
-
-void
-CMediaType::SetSampleSize(ULONG sz) {
-    if (sz == 0) {
-        SetVariableSize();
-    } else {
-        bFixedSizeSamples = TRUE;
-        lSampleSize = sz;
-    }
-}
-
-
-void
-CMediaType::SetVariableSize() {
-    bFixedSizeSamples = FALSE;
-}
-
-
-void
-CMediaType::SetTemporalCompression(BOOL bCompressed) {
-    bTemporalCompression = bCompressed;
-}
-
-BOOL
-CMediaType::SetFormat(__in_bcount(cb) BYTE * pformat, ULONG cb)
-{
-    if (NULL == AllocFormatBuffer(cb))
-	return(FALSE);
-
-    ASSERT(pbFormat);
-    memcpy(pbFormat, pformat, cb);
-    return(TRUE);
-}
-
-
-// set the type of the media type format block, this type defines what you
-// will actually find in the format pointer. For example FORMAT_VideoInfo or
-// FORMAT_WaveFormatEx. In the future this may be an interface pointer to a
-// property set. Before sending out media types this should be filled in.
-
-void
-CMediaType::SetFormatType(const GUID *pformattype)
-{
-    formattype = *pformattype;
-}
-
-
-// reset the format buffer
-
-void CMediaType::ResetFormatBuffer()
-{
-    if (cbFormat) {
-        CoTaskMemFree((PVOID)pbFormat);
-    }
-    cbFormat = 0;
-    pbFormat = NULL;
-}
-
-
-// allocate length bytes for the format and return a read/write pointer
-// If we cannot allocate the new block of memory we return NULL leaving
-// the original block of memory untouched (as does ReallocFormatBuffer)
-
-BYTE*
-CMediaType::AllocFormatBuffer(ULONG length)
-{
-    ASSERT(length);
-
-    // do the types have the same buffer size
-
-    if (cbFormat == length) {
-        return pbFormat;
-    }
-
-    // allocate the new format buffer
-
-    BYTE *pNewFormat = (PBYTE)CoTaskMemAlloc(length);
-    if (pNewFormat == NULL) {
-        if (length <= cbFormat) return pbFormat; //reuse the old block anyway.
-        return NULL;
-    }
-
-    // delete the old format
-
-    if (cbFormat != 0) {
-        ASSERT(pbFormat);
-        CoTaskMemFree((PVOID)pbFormat);
-    }
-
-    cbFormat = length;
-    pbFormat = pNewFormat;
-    return pbFormat;
-}
-
-
-// reallocate length bytes for the format and return a read/write pointer
-// to it. We keep as much information as we can given the new buffer size
-// if this fails the original format buffer is left untouched. The caller
-// is responsible for ensuring the size of memory required is non zero
-
-BYTE*
-CMediaType::ReallocFormatBuffer(ULONG length)
-{
-    ASSERT(length);
-
-    // do the types have the same buffer size
-
-    if (cbFormat == length) {
-        return pbFormat;
-    }
-
-    // allocate the new format buffer
-
-    BYTE *pNewFormat = (PBYTE)CoTaskMemAlloc(length);
-    if (pNewFormat == NULL) {
-        if (length <= cbFormat) return pbFormat; //reuse the old block anyway.
-        return NULL;
-    }
-
-    // copy any previous format (or part of if new is smaller)
-    // delete the old format and replace with the new one
-
-    if (cbFormat != 0) {
-        ASSERT(pbFormat);
-        memcpy(pNewFormat,pbFormat,min(length,cbFormat));
-        CoTaskMemFree((PVOID)pbFormat);
-    }
-
-    cbFormat = length;
-    pbFormat = pNewFormat;
-    return pNewFormat;
-}
-
-// initialise a media type structure
-
-void CMediaType::InitMediaType()
-{
-    ZeroMemory((PVOID)this, sizeof(*this));
-    lSampleSize = 1;
-    bFixedSizeSamples = TRUE;
-}
-
-
-// a partially specified media type can be passed to IPin::Connect
-// as a constraint on the media type used in the connection.
-// the type, subtype or format type can be null.
-BOOL
-CMediaType::IsPartiallySpecified(void) const
-{
-    if ((majortype == GUID_NULL) ||
-        (formattype == GUID_NULL)) {
-            return TRUE;
-    } else {
-        return FALSE;
-    }
-}
-
-BOOL
-CMediaType::MatchesPartial(const CMediaType* ppartial) const
-{
-    if ((ppartial->majortype != GUID_NULL) &&
-        (majortype != ppartial->majortype)) {
-            return FALSE;
-    }
-    if ((ppartial->subtype != GUID_NULL) &&
-        (subtype != ppartial->subtype)) {
-            return FALSE;
-    }
-
-    if (ppartial->formattype != GUID_NULL) {
-        // if the format block is specified then it must match exactly
-        if (formattype != ppartial->formattype) {
-            return FALSE;
-        }
-        if (cbFormat != ppartial->cbFormat) {
-            return FALSE;
-        }
-        if ((cbFormat != 0) &&
-            (memcmp(pbFormat, ppartial->pbFormat, cbFormat) != 0)) {
-                return FALSE;
-        }
-    }
-
-    return TRUE;
-
-}
-
-
-
-// general purpose function to delete a heap allocated AM_MEDIA_TYPE structure
-// which is useful when calling IEnumMediaTypes::Next as the interface
-// implementation allocates the structures which you must later delete
-// the format block may also be a pointer to an interface to release
-
-void WINAPI DeleteMediaType(__inout_opt AM_MEDIA_TYPE *pmt)
-{
-    // allow NULL pointers for coding simplicity
-
-    if (pmt == NULL) {
-        return;
-    }
-
-    FreeMediaType(*pmt);
-    CoTaskMemFree((PVOID)pmt);
-}
-
-
-// this also comes in useful when using the IEnumMediaTypes interface so
-// that you can copy a media type, you can do nearly the same by creating
-// a CMediaType object but as soon as it goes out of scope the destructor
-// will delete the memory it allocated (this takes a copy of the memory)
-
-AM_MEDIA_TYPE * WINAPI CreateMediaType(AM_MEDIA_TYPE const *pSrc)
-{
-    ASSERT(pSrc);
-
-    // Allocate a block of memory for the media type
-
-    AM_MEDIA_TYPE *pMediaType =
-        (AM_MEDIA_TYPE *)CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
-
-    if (pMediaType == NULL) {
-        return NULL;
-    }
-    // Copy the variable length format block
-
-    HRESULT hr = CopyMediaType(pMediaType,pSrc);
-    if (FAILED(hr)) {
-        CoTaskMemFree((PVOID)pMediaType);
-        return NULL;
-    }
-
-    return pMediaType;
-}
-
-
-//  Copy 1 media type to another
-
-HRESULT WINAPI CopyMediaType(__out AM_MEDIA_TYPE *pmtTarget, const AM_MEDIA_TYPE *pmtSource)
-{
-    //  We'll leak if we copy onto one that already exists - there's one
-    //  case we can check like that - copying to itself.
-    ASSERT(pmtSource != pmtTarget);
-    *pmtTarget = *pmtSource;
-    if (pmtSource->cbFormat != 0) {
-        ASSERT(pmtSource->pbFormat != NULL);
-        pmtTarget->pbFormat = (PBYTE)CoTaskMemAlloc(pmtSource->cbFormat);
-        if (pmtTarget->pbFormat == NULL) {
-            pmtTarget->cbFormat = 0;
-            return E_OUTOFMEMORY;
-        } else {
-            CopyMemory((PVOID)pmtTarget->pbFormat, (PVOID)pmtSource->pbFormat,
-                       pmtTarget->cbFormat);
-        }
-    }
-    if (pmtTarget->pUnk != NULL) {
-        pmtTarget->pUnk->AddRef();
-    }
-
-    return S_OK;
-}
-
-//  Free an existing media type (ie free resources it holds)
-
-void WINAPI FreeMediaType(__inout AM_MEDIA_TYPE& mt)
-{
-    if (mt.cbFormat != 0) {
-        CoTaskMemFree((PVOID)mt.pbFormat);
-
-        // Strictly unnecessary but tidier
-        mt.cbFormat = 0;
-        mt.pbFormat = NULL;
-    }
-    if (mt.pUnk != NULL) {
-        mt.pUnk->Release();
-        mt.pUnk = NULL;
-    }
-}
-
-//  Initialize a media type from a WAVEFORMATEX
-
-STDAPI CreateAudioMediaType(
-    const WAVEFORMATEX *pwfx,
-    __out AM_MEDIA_TYPE *pmt,
-    BOOL bSetFormat
-)
-{
-    pmt->majortype            = MEDIATYPE_Audio;
-    if (pwfx->wFormatTag == WAVE_FORMAT_EXTENSIBLE) {
-        pmt->subtype = ((PWAVEFORMATEXTENSIBLE)pwfx)->SubFormat;
-    } else {
-        pmt->subtype              = FOURCCMap(pwfx->wFormatTag);
-    }
-    pmt->formattype           = FORMAT_WaveFormatEx;
-    pmt->bFixedSizeSamples    = TRUE;
-    pmt->bTemporalCompression = FALSE;
-    pmt->lSampleSize          = pwfx->nBlockAlign;
-    pmt->pUnk                 = NULL;
-    if (bSetFormat) {
-        if (pwfx->wFormatTag == WAVE_FORMAT_PCM) {
-            pmt->cbFormat         = sizeof(WAVEFORMATEX);
-        } else {
-            pmt->cbFormat         = sizeof(WAVEFORMATEX) + pwfx->cbSize;
-        }
-        pmt->pbFormat             = (PBYTE)CoTaskMemAlloc(pmt->cbFormat);
-        if (pmt->pbFormat == NULL) {
-            return E_OUTOFMEMORY;
-        }
-        if (pwfx->wFormatTag == WAVE_FORMAT_PCM) {
-            CopyMemory(pmt->pbFormat, pwfx, sizeof(PCMWAVEFORMAT));
-            ((WAVEFORMATEX *)pmt->pbFormat)->cbSize = 0;
-        } else {
-            CopyMemory(pmt->pbFormat, pwfx, pmt->cbFormat);
-        }
-    }
-    return S_OK;
-}
-
-// eliminate very many spurious warnings from MS compiler
-#pragma warning(disable:4514)

3rdparty/baseclasses/mtype.h

@@ -1,89 +0,0 @@
-//------------------------------------------------------------------------------
-// File: MtType.h
-//
-// Desc: DirectShow base classes - defines a class that holds and manages
-//       media type information.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-#ifndef __MTYPE__
-#define __MTYPE__
-
-/* Helper class that derived pin objects can use to compare media
-   types etc. Has same data members as the struct AM_MEDIA_TYPE defined
-   in the streams IDL file, but also has (non-virtual) functions */
-
-class CMediaType : public _AMMediaType {
-
-public:
-
-    ~CMediaType();
-    CMediaType();
-    CMediaType(const GUID * majortype);
-    CMediaType(const AM_MEDIA_TYPE&, __out_opt HRESULT* phr = NULL);
-    CMediaType(const CMediaType&, __out_opt HRESULT* phr = NULL);
-
-    CMediaType& operator=(const CMediaType&);
-    CMediaType& operator=(const AM_MEDIA_TYPE&);
-
-    BOOL operator == (const CMediaType&) const;
-    BOOL operator != (const CMediaType&) const;
-
-    HRESULT Set(const CMediaType& rt);
-    HRESULT Set(const AM_MEDIA_TYPE& rt);
-
-    BOOL IsValid() const;
-
-    const GUID *Type() const { return &majortype;} ;
-    void SetType(const GUID *);
-    const GUID *Subtype() const { return &subtype;} ;
-    void SetSubtype(const GUID *);
-
-    BOOL IsFixedSize() const {return bFixedSizeSamples; };
-    BOOL IsTemporalCompressed() const {return bTemporalCompression; };
-    ULONG GetSampleSize() const;
-
-    void SetSampleSize(ULONG sz);
-    void SetVariableSize();
-    void SetTemporalCompression(BOOL bCompressed);
-
-    // read/write pointer to format - can't change length without
-    // calling SetFormat, AllocFormatBuffer or ReallocFormatBuffer
-
-    BYTE*   Format() const {return pbFormat; };
-    ULONG   FormatLength() const { return cbFormat; };
-
-    void SetFormatType(const GUID *);
-    const GUID *FormatType() const {return &formattype; };
-    BOOL SetFormat(__in_bcount(length) BYTE *pFormat, ULONG length);
-    void ResetFormatBuffer();
-    BYTE* AllocFormatBuffer(ULONG length);
-    BYTE* ReallocFormatBuffer(ULONG length);
-
-    void InitMediaType();
-
-    BOOL MatchesPartial(const CMediaType* ppartial) const;
-    BOOL IsPartiallySpecified(void) const;
-};
-
-
-/* General purpose functions to copy and delete a task allocated AM_MEDIA_TYPE
-   structure which is useful when using the IEnumMediaFormats interface as
-   the implementation allocates the structures which you must later delete */
-
-void WINAPI DeleteMediaType(__inout_opt AM_MEDIA_TYPE *pmt);
-AM_MEDIA_TYPE * WINAPI CreateMediaType(AM_MEDIA_TYPE const *pSrc);
-HRESULT WINAPI CopyMediaType(__out AM_MEDIA_TYPE *pmtTarget, const AM_MEDIA_TYPE *pmtSource);
-void WINAPI FreeMediaType(__inout AM_MEDIA_TYPE& mt);
-
-//  Initialize a media type from a WAVEFORMATEX
-
-STDAPI CreateAudioMediaType(
-    const WAVEFORMATEX *pwfx,
-    __out AM_MEDIA_TYPE *pmt,
-    BOOL bSetFormat);
-
-#endif /* __MTYPE__ */
-

3rdparty/baseclasses/outputq.cpp

@@ -1,801 +0,0 @@
-//------------------------------------------------------------------------------
-// File: OutputQ.cpp
-//
-// Desc: DirectShow base classes - implements COutputQueue class used by an
-//       output pin which may sometimes want to queue output samples on a
-//       separate thread and sometimes call Receive() directly on the input
-//       pin.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-#include <streams.h>
-
-
-//
-//  COutputQueue Constructor :
-//
-//  Determines if a thread is to be created and creates resources
-//
-//     pInputPin  - the downstream input pin we're queueing samples to
-//
-//     phr        - changed to a failure code if this function fails
-//                  (otherwise unchanges)
-//
-//     bAuto      - Ask pInputPin if it can block in Receive by calling
-//                  its ReceiveCanBlock method and create a thread if
-//                  it can block, otherwise not.
-//
-//     bQueue     - if bAuto == FALSE then we create a thread if and only
-//                  if bQueue == TRUE
-//
-//     lBatchSize - work in batches of lBatchSize
-//
-//     bBatchEact - Use exact batch sizes so don't send until the
-//                  batch is full or SendAnyway() is called
-//
-//     lListSize  - If we create a thread make the list of samples queued
-//                  to the thread have this size cache
-//
-//     dwPriority - If we create a thread set its priority to this
-//
-COutputQueue::COutputQueue(
-             IPin         *pInputPin,          //  Pin to send stuff to
-             __inout HRESULT      *phr,        //  'Return code'
-             BOOL          bAuto,              //  Ask pin if queue or not
-             BOOL          bQueue,             //  Send through queue
-             LONG          lBatchSize,         //  Batch
-             BOOL          bBatchExact,        //  Batch exactly to BatchSize
-             LONG          lListSize,
-             DWORD         dwPriority,
-             bool          bFlushingOpt        // flushing optimization
-            ) : m_lBatchSize(lBatchSize),
-                m_bBatchExact(bBatchExact && (lBatchSize > 1)),
-                m_hThread(NULL),
-                m_hSem(NULL),
-                m_List(NULL),
-                m_pPin(pInputPin),
-                m_ppSamples(NULL),
-                m_lWaiting(0),
-                m_evFlushComplete(FALSE, phr),
-                m_pInputPin(NULL),
-                m_bSendAnyway(FALSE),
-                m_nBatched(0),
-                m_bFlushing(FALSE),
-                m_bFlushed(TRUE),
-                m_bFlushingOpt(bFlushingOpt),
-                m_bTerminate(FALSE),
-                m_hEventPop(NULL),
-                m_hr(S_OK)
-{
-    ASSERT(m_lBatchSize > 0);
-
-
-    if (FAILED(*phr)) {
-        return;
-    }
-
-    //  Check the input pin is OK and cache its IMemInputPin interface
-
-    *phr = pInputPin->QueryInterface(IID_IMemInputPin, (void **)&m_pInputPin);
-    if (FAILED(*phr)) {
-        return;
-    }
-
-    // See if we should ask the downstream pin
-
-    if (bAuto) {
-        HRESULT hr = m_pInputPin->ReceiveCanBlock();
-        if (SUCCEEDED(hr)) {
-            bQueue = hr == S_OK;
-        }
-    }
-
-    //  Create our sample batch
-
-    m_ppSamples = new PMEDIASAMPLE[m_lBatchSize];
-    if (m_ppSamples == NULL) {
-        *phr = E_OUTOFMEMORY;
-        return;
-    }
-
-    //  If we're queueing allocate resources
-
-    if (bQueue) {
-        DbgLog((LOG_TRACE, 2, TEXT("Creating thread for output pin")));
-        m_hSem = CreateSemaphore(NULL, 0, 0x7FFFFFFF, NULL);
-        if (m_hSem == NULL) {
-            DWORD dwError = GetLastError();
-            *phr = AmHresultFromWin32(dwError);
-            return;
-        }
-        m_List = new CSampleList(NAME("Sample Queue List"),
-                                 lListSize,
-                                 FALSE         // No lock
-                                );
-        if (m_List == NULL) {
-            *phr = E_OUTOFMEMORY;
-            return;
-        }
-
-
-        DWORD dwThreadId;
-        m_hThread = CreateThread(NULL,
-                                 0,
-                                 InitialThreadProc,
-                                 (LPVOID)this,
-                                 0,
-                                 &dwThreadId);
-        if (m_hThread == NULL) {
-            DWORD dwError = GetLastError();
-            *phr = AmHresultFromWin32(dwError);
-            return;
-        }
-        SetThreadPriority(m_hThread, dwPriority);
-    } else {
-        DbgLog((LOG_TRACE, 2, TEXT("Calling input pin directly - no thread")));
-    }
-}
-
-//
-//  COutputQueuee Destructor :
-//
-//  Free all resources -
-//
-//      Thread,
-//      Batched samples
-//
-COutputQueue::~COutputQueue()
-{
-    DbgLog((LOG_TRACE, 3, TEXT("COutputQueue::~COutputQueue")));
-    /*  Free our pointer */
-    if (m_pInputPin != NULL) {
-        m_pInputPin->Release();
-    }
-    if (m_hThread != NULL) {
-        {
-            CAutoLock lck(this);
-            m_bTerminate = TRUE;
-            m_hr = S_FALSE;
-            NotifyThread();
-        }
-        DbgWaitForSingleObject(m_hThread);
-        EXECUTE_ASSERT(CloseHandle(m_hThread));
-
-        //  The thread frees the samples when asked to terminate
-
-        ASSERT(m_List->GetCount() == 0);
-        delete m_List;
-    } else {
-        FreeSamples();
-    }
-    if (m_hSem != NULL) {
-        EXECUTE_ASSERT(CloseHandle(m_hSem));
-    }
-    delete [] m_ppSamples;
-}
-
-//
-//  Call the real thread proc as a member function
-//
-DWORD WINAPI COutputQueue::InitialThreadProc(__in LPVOID pv)
-{
-    HRESULT hrCoInit = CAMThread::CoInitializeHelper();
-
-    COutputQueue *pSampleQueue = (COutputQueue *)pv;
-    DWORD dwReturn = pSampleQueue->ThreadProc();
-
-    if(hrCoInit == S_OK) {
-        CoUninitialize();
-    }
-
-    return dwReturn;
-}
-
-//
-//  Thread sending the samples downstream :
-//
-//  When there is nothing to do the thread sets m_lWaiting (while
-//  holding the critical section) and then waits for m_hSem to be
-//  set (not holding the critical section)
-//
-DWORD COutputQueue::ThreadProc()
-{
-    while (TRUE) {
-        BOOL          bWait = FALSE;
-        IMediaSample *pSample;
-        LONG          lNumberToSend; // Local copy
-        NewSegmentPacket* ppacket;
-
-        //
-        //  Get a batch of samples and send it if possible
-        //  In any case exit the loop if there is a control action
-        //  requested
-        //
-        {
-            CAutoLock lck(this);
-            while (TRUE) {
-
-                if (m_bTerminate) {
-                    FreeSamples();
-                    return 0;
-                }
-                if (m_bFlushing) {
-                    FreeSamples();
-                    SetEvent(m_evFlushComplete);
-                }
-
-                //  Get a sample off the list
-
-                pSample = m_List->RemoveHead();
-		// inform derived class we took something off the queue
-		if (m_hEventPop) {
-                    //DbgLog((LOG_TRACE,3,TEXT("Queue: Delivered  SET EVENT")));
-		    SetEvent(m_hEventPop);
-		}
-
-                if (pSample != NULL &&
-                    !IsSpecialSample(pSample)) {
-
-                    //  If its just a regular sample just add it to the batch
-                    //  and exit the loop if the batch is full
-
-                    m_ppSamples[m_nBatched++] = pSample;
-                    if (m_nBatched == m_lBatchSize) {
-                        break;
-                    }
-                } else {
-
-                    //  If there was nothing in the queue and there's nothing
-                    //  to send (either because there's nothing or the batch
-                    //  isn't full) then prepare to wait
-
-                    if (pSample == NULL &&
-                        (m_bBatchExact || m_nBatched == 0)) {
-
-                        //  Tell other thread to set the event when there's
-                        //  something do to
-
-                        ASSERT(m_lWaiting == 0);
-                        m_lWaiting++;
-                        bWait      = TRUE;
-                    } else {
-
-                        //  We break out of the loop on SEND_PACKET unless
-                        //  there's nothing to send
-
-                        if (pSample == SEND_PACKET && m_nBatched == 0) {
-                            continue;
-                        }
-
-                        if (pSample == NEW_SEGMENT) {
-                            // now we need the parameters - we are
-                            // guaranteed that the next packet contains them
-                            ppacket = (NewSegmentPacket *) m_List->RemoveHead();
-			    // we took something off the queue
-			    if (m_hEventPop) {
-                    	        //DbgLog((LOG_TRACE,3,TEXT("Queue: Delivered  SET EVENT")));
-		    	        SetEvent(m_hEventPop);
-			    }
-
-                            ASSERT(ppacket);
-                        }
-                        //  EOS_PACKET falls through here and we exit the loop
-                        //  In this way it acts like SEND_PACKET
-                    }
-                    break;
-                }
-            }
-            if (!bWait) {
-                // We look at m_nBatched from the client side so keep
-                // it up to date inside the critical section
-                lNumberToSend = m_nBatched;  // Local copy
-                m_nBatched = 0;
-            }
-        }
-
-        //  Wait for some more data
-
-        if (bWait) {
-            DbgWaitForSingleObject(m_hSem);
-            continue;
-        }
-
-
-
-        //  OK - send it if there's anything to send
-        //  We DON'T check m_bBatchExact here because either we've got
-        //  a full batch or we dropped through because we got
-        //  SEND_PACKET or EOS_PACKET - both of which imply we should
-        //  flush our batch
-
-        if (lNumberToSend != 0) {
-            long nProcessed;
-            if (m_hr == S_OK) {
-                ASSERT(!m_bFlushed);
-                HRESULT hr = m_pInputPin->ReceiveMultiple(m_ppSamples,
-                                                          lNumberToSend,
-                                                          &nProcessed);
-                /*  Don't overwrite a flushing state HRESULT */
-                CAutoLock lck(this);
-                if (m_hr == S_OK) {
-                    m_hr = hr;
-                }
-                ASSERT(!m_bFlushed);
-            }
-            while (lNumberToSend != 0) {
-                m_ppSamples[--lNumberToSend]->Release();
-            }
-            if (m_hr != S_OK) {
-
-                //  In any case wait for more data - S_OK just
-                //  means there wasn't an error
-
-                DbgLog((LOG_ERROR, 2, TEXT("ReceiveMultiple returned %8.8X"),
-                       m_hr));
-            }
-        }
-
-        //  Check for end of stream
-
-        if (pSample == EOS_PACKET) {
-
-            //  We don't send even end of stream on if we've previously
-            //  returned something other than S_OK
-            //  This is because in that case the pin which returned
-            //  something other than S_OK should have either sent
-            //  EndOfStream() or notified the filter graph
-
-            if (m_hr == S_OK) {
-                DbgLog((LOG_TRACE, 2, TEXT("COutputQueue sending EndOfStream()")));
-                HRESULT hr = m_pPin->EndOfStream();
-                if (FAILED(hr)) {
-                    DbgLog((LOG_ERROR, 2, TEXT("COutputQueue got code 0x%8.8X from EndOfStream()")));
-                }
-            }
-        }
-
-        //  Data from a new source
-
-        if (pSample == RESET_PACKET) {
-            m_hr = S_OK;
-            SetEvent(m_evFlushComplete);
-        }
-
-        if (pSample == NEW_SEGMENT) {
-            m_pPin->NewSegment(ppacket->tStart, ppacket->tStop, ppacket->dRate);
-            delete ppacket;
-        }
-    }
-}
-
-//  Send batched stuff anyway
-void COutputQueue::SendAnyway()
-{
-    if (!IsQueued()) {
-
-        //  m_bSendAnyway is a private parameter checked in ReceiveMultiple
-
-        m_bSendAnyway = TRUE;
-        LONG nProcessed;
-        ReceiveMultiple(NULL, 0, &nProcessed);
-        m_bSendAnyway = FALSE;
-
-    } else {
-        CAutoLock lck(this);
-        QueueSample(SEND_PACKET);
-        NotifyThread();
-    }
-}
-
-void
-COutputQueue::NewSegment(
-    REFERENCE_TIME tStart,
-    REFERENCE_TIME tStop,
-    double dRate)
-{
-    if (!IsQueued()) {
-        if (S_OK == m_hr) {
-            if (m_bBatchExact) {
-                SendAnyway();
-            }
-            m_pPin->NewSegment(tStart, tStop, dRate);
-        }
-    } else {
-        if (m_hr == S_OK) {
-            //
-            // we need to queue the new segment to appear in order in the
-            // data, but we need to pass parameters to it. Rather than
-            // take the hit of wrapping every single sample so we can tell
-            // special ones apart, we queue special pointers to indicate
-            // special packets, and we guarantee (by holding the
-            // critical section) that the packet immediately following a
-            // NEW_SEGMENT value is a NewSegmentPacket containing the
-            // parameters.
-            NewSegmentPacket * ppack = new NewSegmentPacket;
-            if (ppack == NULL) {
-                return;
-            }
-            ppack->tStart = tStart;
-            ppack->tStop = tStop;
-            ppack->dRate = dRate;
-
-            CAutoLock lck(this);
-            QueueSample(NEW_SEGMENT);
-            QueueSample( (IMediaSample*) ppack);
-            NotifyThread();
-        }
-    }
-}
-
-
-//
-//  End of Stream is queued to output device
-//
-void COutputQueue::EOS()
-{
-    CAutoLock lck(this);
-    if (!IsQueued()) {
-        if (m_bBatchExact) {
-            SendAnyway();
-        }
-        if (m_hr == S_OK) {
-            DbgLog((LOG_TRACE, 2, TEXT("COutputQueue sending EndOfStream()")));
-            m_bFlushed = FALSE;
-            HRESULT hr = m_pPin->EndOfStream();
-            if (FAILED(hr)) {
-                DbgLog((LOG_ERROR, 2, TEXT("COutputQueue got code 0x%8.8X from EndOfStream()")));
-            }
-        }
-    } else {
-        if (m_hr == S_OK) {
-            m_bFlushed = FALSE;
-            QueueSample(EOS_PACKET);
-            NotifyThread();
-        }
-    }
-}
-
-//
-//  Flush all the samples in the queue
-//
-void COutputQueue::BeginFlush()
-{
-    if (IsQueued()) {
-        {
-            CAutoLock lck(this);
-
-            // block receives -- we assume this is done by the
-            // filter in which we are a component
-
-            // discard all queued data
-
-            m_bFlushing = TRUE;
-
-            //  Make sure we discard all samples from now on
-
-            if (m_hr == S_OK) {
-                m_hr = S_FALSE;
-            }
-
-            // Optimize so we don't keep calling downstream all the time
-
-            if (m_bFlushed && m_bFlushingOpt) {
-                return;
-            }
-
-            // Make sure we really wait for the flush to complete
-            m_evFlushComplete.Reset();
-
-            NotifyThread();
-        }
-
-        // pass this downstream
-
-        m_pPin->BeginFlush();
-    } else {
-        // pass downstream first to avoid deadlocks
-        m_pPin->BeginFlush();
-        CAutoLock lck(this);
-        // discard all queued data
-
-        m_bFlushing = TRUE;
-
-        //  Make sure we discard all samples from now on
-
-        if (m_hr == S_OK) {
-            m_hr = S_FALSE;
-        }
-    }
-
-}
-
-//
-// leave flush mode - pass this downstream
-void COutputQueue::EndFlush()
-{
-    {
-        CAutoLock lck(this);
-        ASSERT(m_bFlushing);
-        if (m_bFlushingOpt && m_bFlushed && IsQueued()) {
-            m_bFlushing = FALSE;
-            m_hr = S_OK;
-            return;
-        }
-    }
-
-    // sync with pushing thread -- done in BeginFlush
-    // ensure no more data to go downstream -- done in BeginFlush
-    //
-    // Because we are synching here there is no need to hold the critical
-    // section (in fact we'd deadlock if we did!)
-
-    if (IsQueued()) {
-        m_evFlushComplete.Wait();
-    } else {
-        FreeSamples();
-    }
-
-    //  Be daring - the caller has guaranteed no samples will arrive
-    //  before EndFlush() returns
-
-    m_bFlushing = FALSE;
-    m_bFlushed  = TRUE;
-
-    // call EndFlush on downstream pins
-
-    m_pPin->EndFlush();
-
-    m_hr = S_OK;
-}
-
-//  COutputQueue::QueueSample
-//
-//  private method to Send a sample to the output queue
-//  The critical section MUST be held when this is called
-
-void COutputQueue::QueueSample(IMediaSample *pSample)
-{
-    if (NULL == m_List->AddTail(pSample)) {
-        if (!IsSpecialSample(pSample)) {
-            pSample->Release();
-        }
-    }
-}
-
-//
-//  COutputQueue::Receive()
-//
-//  Send a single sample by the multiple sample route
-//  (NOTE - this could be optimized if necessary)
-//
-//  On return the sample will have been Release()'d
-//
-
-HRESULT COutputQueue::Receive(IMediaSample *pSample)
-{
-    LONG nProcessed;
-    return ReceiveMultiple(&pSample, 1, &nProcessed);
-}
-
-//
-//  COutputQueue::ReceiveMultiple()
-//
-//  Send a set of samples to the downstream pin
-//
-//      ppSamples           - array of samples
-//      nSamples            - how many
-//      nSamplesProcessed   - How many were processed
-//
-//  On return all samples will have been Release()'d
-//
-
-HRESULT COutputQueue::ReceiveMultiple (
-    __in_ecount(nSamples) IMediaSample **ppSamples,
-    long nSamples,
-    __out long *nSamplesProcessed)
-{
-    if (nSamples < 0) {
-        return E_INVALIDARG;
-    }
-
-    CAutoLock lck(this);
-    //  Either call directly or queue up the samples
-
-    if (!IsQueued()) {
-
-        //  If we already had a bad return code then just return
-
-        if (S_OK != m_hr) {
-
-            //  If we've never received anything since the last Flush()
-            //  and the sticky return code is not S_OK we must be
-            //  flushing
-            //  ((!A || B) is equivalent to A implies B)
-            ASSERT(!m_bFlushed || m_bFlushing);
-
-            //  We're supposed to Release() them anyway!
-            *nSamplesProcessed = 0;
-            for (int i = 0; i < nSamples; i++) {
-                DbgLog((LOG_TRACE, 3, TEXT("COutputQueue (direct) : Discarding %d samples code 0x%8.8X"),
-                        nSamples, m_hr));
-                ppSamples[i]->Release();
-            }
-
-            return m_hr;
-        }
-        //
-        //  If we're flushing the sticky return code should be S_FALSE
-        //
-        ASSERT(!m_bFlushing);
-        m_bFlushed = FALSE;
-
-        ASSERT(m_nBatched < m_lBatchSize);
-        ASSERT(m_nBatched == 0 || m_bBatchExact);
-
-        //  Loop processing the samples in batches
-
-        LONG iLost = 0;
-        long iDone = 0;
-        for (iDone = 0;
-             iDone < nSamples || (m_nBatched != 0 && m_bSendAnyway);
-            ) {
-
-//pragma message (REMIND("Implement threshold scheme"))
-            ASSERT(m_nBatched < m_lBatchSize);
-            if (iDone < nSamples) {
-                m_ppSamples[m_nBatched++] = ppSamples[iDone++];
-            }
-            if (m_nBatched == m_lBatchSize ||
-                nSamples == 0 && (m_bSendAnyway || !m_bBatchExact)) {
-                LONG nDone;
-                DbgLog((LOG_TRACE, 4, TEXT("Batching %d samples"),
-                       m_nBatched));
-
-                if (m_hr == S_OK) {
-                    m_hr = m_pInputPin->ReceiveMultiple(m_ppSamples,
-                                                        m_nBatched,
-                                                        &nDone);
-                } else {
-                    nDone = 0;
-                }
-                iLost += m_nBatched - nDone;
-                for (LONG i = 0; i < m_nBatched; i++) {
-                    m_ppSamples[i]->Release();
-                }
-                m_nBatched = 0;
-            }
-        }
-        *nSamplesProcessed = iDone - iLost;
-        if (*nSamplesProcessed < 0) {
-            *nSamplesProcessed = 0;
-        }
-        return m_hr;
-    } else {
-        /*  We're sending to our thread */
-
-        if (m_hr != S_OK) {
-            *nSamplesProcessed = 0;
-            DbgLog((LOG_TRACE, 3, TEXT("COutputQueue (queued) : Discarding %d samples code 0x%8.8X"),
-                    nSamples, m_hr));
-            for (int i = 0; i < nSamples; i++) {
-                ppSamples[i]->Release();
-            }
-            return m_hr;
-        }
-        m_bFlushed = FALSE;
-        for (long i = 0; i < nSamples; i++) {
-            QueueSample(ppSamples[i]);
-        }
-        *nSamplesProcessed = nSamples;
-        if (!m_bBatchExact ||
-            m_nBatched + m_List->GetCount() >= m_lBatchSize) {
-            NotifyThread();
-        }
-        return S_OK;
-    }
-}
-
-//  Get ready for new data - cancels sticky m_hr
-void COutputQueue::Reset()
-{
-    if (!IsQueued()) {
-        m_hr = S_OK;
-    } else {
-        {
-            CAutoLock lck(this);
-            QueueSample(RESET_PACKET);
-            NotifyThread();
-        }
-        m_evFlushComplete.Wait();
-    }
-}
-
-//  Remove and Release() all queued and Batched samples
-void COutputQueue::FreeSamples()
-{
-    CAutoLock lck(this);
-    if (IsQueued()) {
-        while (TRUE) {
-            IMediaSample *pSample = m_List->RemoveHead();
-	    // inform derived class we took something off the queue
-	    if (m_hEventPop) {
-                //DbgLog((LOG_TRACE,3,TEXT("Queue: Delivered  SET EVENT")));
-	        SetEvent(m_hEventPop);
-	    }
-
-            if (pSample == NULL) {
-                break;
-            }
-            if (!IsSpecialSample(pSample)) {
-                pSample->Release();
-            } else {
-                if (pSample == NEW_SEGMENT) {
-                    //  Free NEW_SEGMENT packet
-                    NewSegmentPacket *ppacket =
-                        (NewSegmentPacket *) m_List->RemoveHead();
-		    // inform derived class we took something off the queue
-		    if (m_hEventPop) {
-                        //DbgLog((LOG_TRACE,3,TEXT("Queue: Delivered  SET EVENT")));
-		        SetEvent(m_hEventPop);
-		    }
-
-                    ASSERT(ppacket != NULL);
-                    delete ppacket;
-                }
-            }
-        }
-    }
-    for (int i = 0; i < m_nBatched; i++) {
-        m_ppSamples[i]->Release();
-    }
-    m_nBatched = 0;
-}
-
-//  Notify the thread if there is something to do
-//
-//  The critical section MUST be held when this is called
-void COutputQueue::NotifyThread()
-{
-    //  Optimize - no need to signal if it's not waiting
-    ASSERT(IsQueued());
-    if (m_lWaiting) {
-        ReleaseSemaphore(m_hSem, m_lWaiting, NULL);
-        m_lWaiting = 0;
-    }
-}
-
-//  See if there's any work to do
-//  Returns
-//      TRUE  if there is nothing on the queue and nothing in the batch
-//            and all data has been sent
-//      FALSE otherwise
-//
-BOOL COutputQueue::IsIdle()
-{
-    CAutoLock lck(this);
-
-    //  We're idle if
-    //      there is no thread (!IsQueued()) OR
-    //      the thread is waiting for more work  (m_lWaiting != 0)
-    //  AND
-    //      there's nothing in the current batch (m_nBatched == 0)
-
-    if (IsQueued() && m_lWaiting == 0 || m_nBatched != 0) {
-        return FALSE;
-    } else {
-
-        //  If we're idle it shouldn't be possible for there
-        //  to be anything on the work queue
-
-        ASSERT(!IsQueued() || m_List->GetCount() == 0);
-        return TRUE;
-    }
-}
-
-
-void COutputQueue::SetPopEvent(HANDLE hEvent)
-{
-    m_hEventPop = hEvent;
-}

3rdparty/baseclasses/outputq.h

@@ -1,137 +0,0 @@
-//------------------------------------------------------------------------------
-// File: OutputQ.h
-//
-// Desc: DirectShow base classes -  defines the COutputQueue class, which
-//       makes a queue of samples and sends them to an output pin.  The
-//       class will optionally send the samples to the pin directly.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-typedef CGenericList<IMediaSample> CSampleList;
-
-class COutputQueue : public CCritSec
-{
-public:
-    //  Constructor
-    COutputQueue(IPin      *pInputPin,          //  Pin to send stuff to
-                 __inout HRESULT *phr,          //  'Return code'
-                 BOOL       bAuto = TRUE,       //  Ask pin if blocks
-                 BOOL       bQueue = TRUE,      //  Send through queue (ignored if
-                                                //  bAuto set)
-                 LONG       lBatchSize = 1,     //  Batch
-                 BOOL       bBatchExact = FALSE,//  Batch exactly to BatchSize
-                 LONG       lListSize =         //  Likely number in the list
-                                DEFAULTCACHE,
-                 DWORD      dwPriority =        //  Priority of thread to create
-                                THREAD_PRIORITY_NORMAL,
-                 bool       bFlushingOpt = false // flushing optimization
-                );
-    ~COutputQueue();
-
-    // enter flush state - discard all data
-    void BeginFlush();      // Begin flushing samples
-
-    // re-enable receives (pass this downstream)
-    void EndFlush();        // Complete flush of samples - downstream
-                            // pin guaranteed not to block at this stage
-
-    void EOS();             // Call this on End of stream
-
-    void SendAnyway();      // Send batched samples anyway (if bBatchExact set)
-
-    void NewSegment(
-            REFERENCE_TIME tStart,
-            REFERENCE_TIME tStop,
-            double dRate);
-
-    HRESULT Receive(IMediaSample *pSample);
-
-    // do something with these media samples
-    HRESULT ReceiveMultiple (
-        __in_ecount(nSamples) IMediaSample **pSamples,
-        long nSamples,
-        __out long *nSamplesProcessed);
-
-    void Reset();           // Reset m_hr ready for more data
-
-    //  See if its idle or not
-    BOOL IsIdle();
-
-    // give the class an event to fire after everything removed from the queue
-    void SetPopEvent(HANDLE hEvent);
-
-protected:
-    static DWORD WINAPI InitialThreadProc(__in LPVOID pv);
-    DWORD ThreadProc();
-    BOOL  IsQueued()
-    {
-        return m_List != NULL;
-    };
-
-    //  The critical section MUST be held when this is called
-    void QueueSample(IMediaSample *pSample);
-
-    BOOL IsSpecialSample(IMediaSample *pSample)
-    {
-        return (DWORD_PTR)pSample > (DWORD_PTR)(LONG_PTR)(-16);
-    };
-
-    //  Remove and Release() batched and queued samples
-    void FreeSamples();
-
-    //  Notify the thread there is something to do
-    void NotifyThread();
-
-
-protected:
-    //  Queue 'messages'
-    #define SEND_PACKET      ((IMediaSample *)(LONG_PTR)(-2))  // Send batch
-    #define EOS_PACKET       ((IMediaSample *)(LONG_PTR)(-3))  // End of stream
-    #define RESET_PACKET     ((IMediaSample *)(LONG_PTR)(-4))  // Reset m_hr
-    #define NEW_SEGMENT      ((IMediaSample *)(LONG_PTR)(-5))  // send NewSegment
-
-    // new segment packet is always followed by one of these
-    struct NewSegmentPacket {
-        REFERENCE_TIME tStart;
-        REFERENCE_TIME tStop;
-        double dRate;
-    };
-
-    // Remember input stuff
-    IPin          * const m_pPin;
-    IMemInputPin  *       m_pInputPin;
-    BOOL            const m_bBatchExact;
-    LONG            const m_lBatchSize;
-
-    CSampleList   *       m_List;
-    HANDLE                m_hSem;
-    CAMEvent                m_evFlushComplete;
-    HANDLE                m_hThread;
-    __field_ecount_opt(m_lBatchSize) IMediaSample  **      m_ppSamples;
-    __range(0, m_lBatchSize)         LONG                  m_nBatched;
-
-    //  Wait optimization
-    LONG                  m_lWaiting;
-    //  Flush synchronization
-    BOOL                  m_bFlushing;
-
-    // flushing optimization. some downstream filters have trouble
-    // with the queue's flushing optimization. other rely on it
-    BOOL                  m_bFlushed;
-    bool                  m_bFlushingOpt;
-
-    //  Terminate now
-    BOOL                  m_bTerminate;
-
-    //  Send anyway flag for batching
-    BOOL                  m_bSendAnyway;
-
-    //  Deferred 'return code'
-    HRESULT volatile         m_hr;
-
-    // an event that can be fired after every deliver
-    HANDLE m_hEventPop;
-};
-

3rdparty/baseclasses/pstream.cpp

@@ -1,197 +0,0 @@
-//------------------------------------------------------------------------------
-// File: PStream.cpp
-//
-// Desc: DirectShow base classes.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-#include <streams.h>
-#include <strsafe.h>
-
-#ifdef PERF
-#include <measure.h>
-#endif
-// #include "pstream.h"  in streams.h
-
-//
-// Constructor
-//
-CPersistStream::CPersistStream(IUnknown *punk, __inout HRESULT *phr)
-    : mPS_fDirty(FALSE)
-{
-    mPS_dwFileVersion = GetSoftwareVersion();
-}
-
-
-//
-// Destructor
-//
-CPersistStream::~CPersistStream() {
-    // Nothing to do
-}
-
-#if 0
-SAMPLE CODE TO COPY - not active at the moment
-
-//
-// NonDelegatingQueryInterface
-//
-// This object supports IPersist & IPersistStream
-STDMETHODIMP CPersistStream::NonDelegatingQueryInterface(REFIID riid, __deref_out void **ppv)
-{
-    if (riid == IID_IPersist) {
-        return GetInterface((IPersist *) this, ppv);      // ???
-    }
-    else if (riid == IID_IPersistStream) {
-        return GetInterface((IPersistStream *) this, ppv);
-    }
-    else {
-        return CUnknown::NonDelegatingQueryInterface(riid, ppv);
-    }
-}
-#endif
-
-
-//
-// WriteToStream
-//
-// Writes to the stream (default action is to write nothing)
-HRESULT CPersistStream::WriteToStream(IStream *pStream)
-{
-    // You can override this to do things like
-    // hr = pStream->Write(MyStructure, sizeof(MyStructure), NULL);
-
-    return NOERROR;
-}
-
-
-
-HRESULT CPersistStream::ReadFromStream(IStream * pStream)
-{
-    // You can override this to do things like
-    // hr = pStream->Read(MyStructure, sizeof(MyStructure), NULL);
-
-    return NOERROR;
-}
-
-
-//
-// Load
-//
-// Load all the data from the given stream
-STDMETHODIMP CPersistStream::Load(LPSTREAM pStm)
-{
-    HRESULT hr;
-    // Load the version number then the data
-    mPS_dwFileVersion = ReadInt(pStm, hr);
-    if (FAILED(hr)) {
-        return hr;
-    }
-
-    return ReadFromStream(pStm);
-}  // Load
-
-
-
-//
-// Save
-//
-// Save the contents of this Stream.
-STDMETHODIMP CPersistStream::Save(LPSTREAM pStm, BOOL fClearDirty)
-{
-
-    HRESULT hr = WriteInt(pStm, GetSoftwareVersion());
-    if (FAILED(hr)) {
-        return hr;
-    }
-
-    hr = WriteToStream(pStm);
-    if (FAILED(hr)) {
-        return hr;
-    }
-
-    mPS_fDirty = !fClearDirty;
-
-    return hr;
-} // Save
-
-
-// WriteInt
-//
-// Writes an integer to an IStream as 11 UNICODE characters followed by one space.
-// You could use this for shorts or unsigneds or anything (up to 32 bits)
-// where the value isn't actually truncated by squeezing it into 32 bits.
-// Values such as (unsigned) 0x80000000 would come out as -2147483648
-// but would then load as 0x80000000 through ReadInt.  Cast as you please.
-
-STDAPI WriteInt(IStream *pIStream, int n)
-{
-    WCHAR Buff[13];  // Allows for trailing null that we don't write
-    (void)StringCchPrintfW(Buff, NUMELMS(Buff),L"%011d ",n);
-    return pIStream->Write(&(Buff[0]), 12*sizeof(WCHAR), NULL);
-} // WriteInt
-
-
-// ReadInt
-//
-// Reads an integer from an IStream.
-// Read as 4 bytes.  You could use this for shorts or unsigneds or anything
-// where the value isn't actually truncated by squeezing it into 32 bits
-// Striped down subset of what sscanf can do (without dragging in the C runtime)
-
-STDAPI_(int) ReadInt(IStream *pIStream, __out HRESULT &hr)
-{
-
-    int Sign = 1;
-    unsigned int n = 0;    // result wil be n*Sign
-    WCHAR wch;
-
-    hr = pIStream->Read( &wch, sizeof(wch), NULL);
-    if (FAILED(hr)) {
-        return 0;
-    }
-
-    if (wch==L'-'){
-        Sign = -1;
-        hr = pIStream->Read( &wch, sizeof(wch), NULL);
-        if (FAILED(hr)) {
-            return 0;
-        }
-    }
-
-    for( ; ; ) {
-        if (wch>=L'0' && wch<=L'9') {
-            n = 10*n+(int)(wch-L'0');
-        } else if (  wch == L' '
-                  || wch == L'\t'
-                  || wch == L'\r'
-                  || wch == L'\n'
-                  || wch == L'\0'
-                  ) {
-            break;
-        } else {
-            hr = VFW_E_INVALID_FILE_FORMAT;
-            return 0;
-        }
-
-        hr = pIStream->Read( &wch, sizeof(wch), NULL);
-        if (FAILED(hr)) {
-            return 0;
-        }
-    }
-
-    if (n==0x80000000 && Sign==-1) {
-        // This is the negative number that has no positive version!
-        return (int)n;
-    }
-    else return (int)n * Sign;
-} // ReadInt
-
-
-// The microsoft C/C++ compile generates level 4 warnings to the effect that
-// a particular inline function (from some base class) was not needed.
-// This line gets rid of hundreds of such unwanted messages and makes
-// -W4 compilation feasible:
-#pragma warning(disable: 4514)

3rdparty/baseclasses/pstream.h

@@ -1,114 +0,0 @@
-//------------------------------------------------------------------------------
-// File: PStream.h
-//
-// Desc: DirectShow base classes - defines a class for persistent properties
-//       of filters.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-#ifndef __PSTREAM__
-#define __PSTREAM__
-
-// Base class for persistent properties of filters
-// (i.e. filter properties in saved graphs)
-
-// The simplest way to use this is:
-// 1. Arrange for your filter to inherit this class
-// 2. Implement in your class WriteToStream and ReadFromStream
-//    These will override the "do nothing" functions here.
-// 3. Change your NonDelegatingQueryInterface to handle IPersistStream
-// 4. Implement SizeMax to return the number of bytes of data you save.
-//    If you save UNICODE data, don't forget a char is 2 bytes.
-// 5. Whenever your data changes, call SetDirty()
-//
-// At some point you may decide to alter, or extend the format of your data.
-// At that point you will wish that you had a version number in all the old
-// saved graphs, so that you can tell, when you read them, whether they
-// represent the old or new form.  To assist you in this, this class
-// writes and reads a version number.
-// When it writes, it calls GetSoftwareVersion()  to enquire what version
-// of the software we have at the moment.  (In effect this is a version number
-// of the data layout in the file).  It writes this as the first thing in the data.
-// If you want to change the version, implement (override) GetSoftwareVersion().
-// It reads this from the file into mPS_dwFileVersion before calling ReadFromStream,
-// so in ReadFromStream you can check mPS_dwFileVersion to see if you are reading
-// an old version file.
-// Normally you should accept files whose version is no newer than the software
-// version that's reading them.
-
-
-// CPersistStream
-//
-// Implements IPersistStream.
-// See 'OLE Programmers Reference (Vol 1):Structured Storage Overview' for
-// more implementation information.
-class CPersistStream : public IPersistStream {
-    private:
-
-        // Internal state:
-
-    protected:
-        DWORD     mPS_dwFileVersion;         // version number of file (being read)
-        BOOL      mPS_fDirty;
-
-    public:
-
-        // IPersistStream methods
-
-        STDMETHODIMP IsDirty()
-            {return (mPS_fDirty ? S_OK : S_FALSE);}  // note FALSE means clean
-        STDMETHODIMP Load(LPSTREAM pStm);
-        STDMETHODIMP Save(LPSTREAM pStm, BOOL fClearDirty);
-        STDMETHODIMP GetSizeMax(__out ULARGE_INTEGER * pcbSize)
-                         // Allow 24 bytes for version.
-                         { pcbSize->QuadPart = 12*sizeof(WCHAR)+SizeMax(); return NOERROR; }
-
-        // implementation
-
-        CPersistStream(IUnknown *punk, __inout HRESULT *phr);
-        ~CPersistStream();
-
-        HRESULT SetDirty(BOOL fDirty)
-            { mPS_fDirty = fDirty; return NOERROR;}
-
-
-        // override to reveal IPersist & IPersistStream
-        // STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void **ppv);
-
-        // --- IPersist ---
-
-        // You must override this to provide your own class id
-        STDMETHODIMP GetClassID(__out CLSID *pClsid) PURE;
-
-        // overrideable if you want
-        // file version number.  Override it if you ever change format
-        virtual DWORD GetSoftwareVersion(void) { return 0; }
-
-
-        //=========================================================================
-        // OVERRIDE THESE to read and write your data
-        // OVERRIDE THESE to read and write your data
-        // OVERRIDE THESE to read and write your data
-
-        virtual int SizeMax() {return 0;}
-        virtual HRESULT WriteToStream(IStream *pStream);
-        virtual HRESULT ReadFromStream(IStream *pStream);
-        //=========================================================================
-
-    private:
-
-};
-
-
-// --- Useful helpers ---
-
-
-// Writes an int to an IStream as UNICODE.
-STDAPI WriteInt(IStream *pIStream, int n);
-
-// inverse of WriteInt
-STDAPI_(int) ReadInt(IStream *pIStream, __out HRESULT &hr);
-
-#endif // __PSTREAM__

3rdparty/baseclasses/pullpin.cpp

@@ -1,588 +0,0 @@
-//------------------------------------------------------------------------------
-// File: PullPin.cpp
-//
-// Desc: DirectShow base classes - implements CPullPin class that pulls data
-//       from IAsyncReader.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-#include <streams.h>
-#include "pullpin.h"
-
-#ifdef DXMPERF
-#include "dxmperf.h"
-#endif // DXMPERF
-
-
-CPullPin::CPullPin()
-  : m_pReader(NULL),
-    m_pAlloc(NULL),
-    m_State(TM_Exit)
-{
-#ifdef DXMPERF
-	PERFLOG_CTOR( L"CPullPin", this );
-#endif // DXMPERF
-
-}
-
-CPullPin::~CPullPin()
-{
-    Disconnect();
-
-#ifdef DXMPERF
-	PERFLOG_DTOR( L"CPullPin", this );
-#endif // DXMPERF
-
-}
-
-// returns S_OK if successfully connected to an IAsyncReader interface
-// from this object
-// Optional allocator should be proposed as a preferred allocator if
-// necessary
-HRESULT
-CPullPin::Connect(IUnknown* pUnk, IMemAllocator* pAlloc, BOOL bSync)
-{
-    CAutoLock lock(&m_AccessLock);
-
-    if (m_pReader) {
-	return VFW_E_ALREADY_CONNECTED;
-    }
-
-    HRESULT hr = pUnk->QueryInterface(IID_IAsyncReader, (void**)&m_pReader);
-    if (FAILED(hr)) {
-
-#ifdef DXMPERF
-		{
-		AM_MEDIA_TYPE *	pmt = NULL;
-		PERFLOG_CONNECT( this, pUnk, hr, pmt );
-		}
-#endif // DXMPERF
-
-	return(hr);
-    }
-
-    hr = DecideAllocator(pAlloc, NULL);
-    if (FAILED(hr)) {
-	Disconnect();
-
-#ifdef DXMPERF
-		{
-		AM_MEDIA_TYPE *	pmt = NULL;
-		PERFLOG_CONNECT( this, pUnk, hr, pmt );
-		}
-#endif // DXMPERF
-
-	return hr;
-    }
-
-    LONGLONG llTotal, llAvail;
-    hr = m_pReader->Length(&llTotal, &llAvail);
-    if (FAILED(hr)) {
-	Disconnect();
-
-#ifdef DXMPERF
-		{
-		AM_MEDIA_TYPE *	pmt = NULL;
-		PERFLOG_CONNECT( this, pUnk, hr, pmt );
-		}
-#endif
-
-	return hr;
-    }
-
-    // convert from file position to reference time
-    m_tDuration = llTotal * UNITS;
-    m_tStop = m_tDuration;
-    m_tStart = 0;
-
-    m_bSync = bSync;
-
-#ifdef DXMPERF
-	{
-	AM_MEDIA_TYPE *	pmt = NULL;
-	PERFLOG_CONNECT( this, pUnk, S_OK, pmt );
-	}
-#endif // DXMPERF
-
-
-    return S_OK;
-}
-
-// disconnect any connection made in Connect
-HRESULT
-CPullPin::Disconnect()
-{
-    CAutoLock lock(&m_AccessLock);
-
-    StopThread();
-
-
-#ifdef DXMPERF
-	PERFLOG_DISCONNECT( this, m_pReader, S_OK );
-#endif // DXMPERF
-
-
-    if (m_pReader) {
-	m_pReader->Release();
-	m_pReader = NULL;
-    }
-
-    if (m_pAlloc) {
-	m_pAlloc->Release();
-	m_pAlloc = NULL;
-    }
-
-    return S_OK;
-}
-
-// agree an allocator using RequestAllocator - optional
-// props param specifies your requirements (non-zero fields).
-// returns an error code if fail to match requirements.
-// optional IMemAllocator interface is offered as a preferred allocator
-// but no error occurs if it can't be met.
-HRESULT
-CPullPin::DecideAllocator(
-    IMemAllocator * pAlloc,
-    __inout_opt ALLOCATOR_PROPERTIES * pProps)
-{
-    ALLOCATOR_PROPERTIES *pRequest;
-    ALLOCATOR_PROPERTIES Request;
-    if (pProps == NULL) {
-	Request.cBuffers = 3;
-	Request.cbBuffer = 64*1024;
-	Request.cbAlign = 0;
-	Request.cbPrefix = 0;
-	pRequest = &Request;
-    } else {
-	pRequest = pProps;
-    }
-    HRESULT hr = m_pReader->RequestAllocator(
-		    pAlloc,
-		    pRequest,
-		    &m_pAlloc);
-    return hr;
-}
-
-// start pulling data
-HRESULT
-CPullPin::Active(void)
-{
-    ASSERT(!ThreadExists());
-    return StartThread();
-}
-
-// stop pulling data
-HRESULT
-CPullPin::Inactive(void)
-{
-    StopThread();
-
-    return S_OK;
-}
-
-HRESULT
-CPullPin::Seek(REFERENCE_TIME tStart, REFERENCE_TIME tStop)
-{
-    CAutoLock lock(&m_AccessLock);
-
-    ThreadMsg AtStart = m_State;
-
-    if (AtStart == TM_Start) {
-	BeginFlush();
-	PauseThread();
-	EndFlush();
-    }
-
-    m_tStart = tStart;
-    m_tStop = tStop;
-
-    HRESULT hr = S_OK;
-    if (AtStart == TM_Start) {
-	hr = StartThread();
-    }
-
-    return hr;
-}
-
-HRESULT
-CPullPin::Duration(__out REFERENCE_TIME* ptDuration)
-{
-    *ptDuration = m_tDuration;
-    return S_OK;
-}
-
-
-HRESULT
-CPullPin::StartThread()
-{
-    CAutoLock lock(&m_AccessLock);
-
-    if (!m_pAlloc || !m_pReader) {
-	return E_UNEXPECTED;
-    }
-
-    HRESULT hr;
-    if (!ThreadExists()) {
-
-	// commit allocator
-	hr = m_pAlloc->Commit();
-	if (FAILED(hr)) {
-	    return hr;
-	}
-
-	// start thread
-	if (!Create()) {
-	    return E_FAIL;
-	}
-    }
-
-    m_State = TM_Start;
-    hr = (HRESULT) CallWorker(m_State);
-    return hr;
-}
-
-HRESULT
-CPullPin::PauseThread()
-{
-    CAutoLock lock(&m_AccessLock);
-
-    if (!ThreadExists()) {
-	return E_UNEXPECTED;
-    }
-
-    // need to flush to ensure the thread is not blocked
-    // in WaitForNext
-    HRESULT hr = m_pReader->BeginFlush();
-    if (FAILED(hr)) {
-	return hr;
-    }
-
-    m_State = TM_Pause;
-    hr = CallWorker(TM_Pause);
-
-    m_pReader->EndFlush();
-    return hr;
-}
-
-HRESULT
-CPullPin::StopThread()
-{
-    CAutoLock lock(&m_AccessLock);
-
-    if (!ThreadExists()) {
-	return S_FALSE;
-    }
-
-    // need to flush to ensure the thread is not blocked
-    // in WaitForNext
-    HRESULT hr = m_pReader->BeginFlush();
-    if (FAILED(hr)) {
-	return hr;
-    }
-
-    m_State = TM_Exit;
-    hr = CallWorker(TM_Exit);
-
-    m_pReader->EndFlush();
-
-    // wait for thread to completely exit
-    Close();
-
-    // decommit allocator
-    if (m_pAlloc) {
-	m_pAlloc->Decommit();
-    }
-
-    return S_OK;
-}
-
-
-DWORD
-CPullPin::ThreadProc(void)
-{
-    while(1) {
-	DWORD cmd = GetRequest();
-	switch(cmd) {
-	case TM_Exit:
-	    Reply(S_OK);
-	    return 0;
-
-	case TM_Pause:
-	    // we are paused already
-	    Reply(S_OK);
-	    break;
-
-	case TM_Start:
-	    Reply(S_OK);
-	    Process();
-	    break;
-	}
-
-	// at this point, there should be no outstanding requests on the
-	// upstream filter.
-	// We should force begin/endflush to ensure that this is true.
-	// !!!Note that we may currently be inside a BeginFlush/EndFlush pair
-	// on another thread, but the premature EndFlush will do no harm now
-	// that we are idle.
-	m_pReader->BeginFlush();
-	CleanupCancelled();
-	m_pReader->EndFlush();
-    }
-}
-
-HRESULT
-CPullPin::QueueSample(
-    __inout REFERENCE_TIME& tCurrent,
-    REFERENCE_TIME tAlignStop,
-    BOOL bDiscontinuity
-    )
-{
-    IMediaSample* pSample;
-
-    HRESULT hr = m_pAlloc->GetBuffer(&pSample, NULL, NULL, 0);
-    if (FAILED(hr)) {
-	return hr;
-    }
-
-    LONGLONG tStopThis = tCurrent + (pSample->GetSize() * UNITS);
-    if (tStopThis > tAlignStop) {
-	tStopThis = tAlignStop;
-    }
-    pSample->SetTime(&tCurrent, &tStopThis);
-    tCurrent = tStopThis;
-
-    pSample->SetDiscontinuity(bDiscontinuity);
-
-    hr = m_pReader->Request(
-			pSample,
-			0);
-    if (FAILED(hr)) {
-	pSample->Release();
-
-	CleanupCancelled();
-	OnError(hr);
-    }
-    return hr;
-}
-
-HRESULT
-CPullPin::CollectAndDeliver(
-    REFERENCE_TIME tStart,
-    REFERENCE_TIME tStop)
-{
-    IMediaSample* pSample = NULL;   // better be sure pSample is set
-    DWORD_PTR dwUnused;
-    HRESULT hr = m_pReader->WaitForNext(
-			INFINITE,
-			&pSample,
-			&dwUnused);
-    if (FAILED(hr)) {
-	if (pSample) {
-	    pSample->Release();
-	}
-    } else {
-	hr = DeliverSample(pSample, tStart, tStop);
-    }
-    if (FAILED(hr)) {
-	CleanupCancelled();
-	OnError(hr);
-    }
-    return hr;
-
-}
-
-HRESULT
-CPullPin::DeliverSample(
-    IMediaSample* pSample,
-    REFERENCE_TIME tStart,
-    REFERENCE_TIME tStop
-    )
-{
-    // fix up sample if past actual stop (for sector alignment)
-    REFERENCE_TIME t1, t2;
-    if (S_OK == pSample->GetTime(&t1, &t2)) {
-        if (t2 > tStop) {
-            t2 = tStop;
-        }
-
-        // adjust times to be relative to (aligned) start time
-        t1 -= tStart;
-        t2 -= tStart;
-        HRESULT hr = pSample->SetTime(&t1, &t2);
-        if (FAILED(hr)) {
-            return hr;
-        }
-    }
-
-#ifdef DXMPERF
-	{
-	AM_MEDIA_TYPE *	pmt = NULL;
-	pSample->GetMediaType( &pmt );
-	PERFLOG_RECEIVE( L"CPullPin", m_pReader, this, pSample, pmt );
-	}
-#endif
-
-    HRESULT hr = Receive(pSample);
-    pSample->Release();
-    return hr;
-}
-
-void
-CPullPin::Process(void)
-{
-    // is there anything to do?
-    if (m_tStop <= m_tStart) {
-	EndOfStream();
-	return;
-    }
-
-    BOOL bDiscontinuity = TRUE;
-
-    // if there is more than one sample at the allocator,
-    // then try to queue 2 at once in order to overlap.
-    // -- get buffer count and required alignment
-    ALLOCATOR_PROPERTIES Actual;
-    HRESULT hr = m_pAlloc->GetProperties(&Actual);
-
-    // align the start position downwards
-    REFERENCE_TIME tStart = AlignDown(m_tStart / UNITS, Actual.cbAlign) * UNITS;
-    REFERENCE_TIME tCurrent = tStart;
-
-    REFERENCE_TIME tStop = m_tStop;
-    if (tStop > m_tDuration) {
-	tStop = m_tDuration;
-    }
-
-    // align the stop position - may be past stop, but that
-    // doesn't matter
-    REFERENCE_TIME tAlignStop = AlignUp(tStop / UNITS, Actual.cbAlign) * UNITS;
-
-
-    DWORD dwRequest;
-
-    if (!m_bSync) {
-
-	//  Break out of the loop either if we get to the end or we're asked
-	//  to do something else
-	while (tCurrent < tAlignStop) {
-
-	    // Break out without calling EndOfStream if we're asked to
-	    // do something different
-	    if (CheckRequest(&dwRequest)) {
-		return;
-	    }
-
-	    // queue a first sample
-	    if (Actual.cBuffers > 1) {
-
-		hr = QueueSample(tCurrent, tAlignStop, TRUE);
-		bDiscontinuity = FALSE;
-
-		if (FAILED(hr)) {
-		    return;
-		}
-	    }
-
-
-
-	    // loop queueing second and waiting for first..
-	    while (tCurrent < tAlignStop) {
-
-		hr = QueueSample(tCurrent, tAlignStop, bDiscontinuity);
-		bDiscontinuity = FALSE;
-
-		if (FAILED(hr)) {
-		    return;
-		}
-
-		hr = CollectAndDeliver(tStart, tStop);
-		if (S_OK != hr) {
-
-		    // stop if error, or if downstream filter said
-		    // to stop.
-		    return;
-		}
-	    }
-
-	    if (Actual.cBuffers > 1) {
-		hr = CollectAndDeliver(tStart, tStop);
-		if (FAILED(hr)) {
-		    return;
-		}
-	    }
-	}
-    } else {
-
-	// sync version of above loop
-	while (tCurrent < tAlignStop) {
-
-	    // Break out without calling EndOfStream if we're asked to
-	    // do something different
-	    if (CheckRequest(&dwRequest)) {
-		return;
-	    }
-
-	    IMediaSample* pSample;
-
-	    hr = m_pAlloc->GetBuffer(&pSample, NULL, NULL, 0);
-	    if (FAILED(hr)) {
-		OnError(hr);
-		return;
-	    }
-
-	    LONGLONG tStopThis = tCurrent + (pSample->GetSize() * UNITS);
-	    if (tStopThis > tAlignStop) {
-		tStopThis = tAlignStop;
-	    }
-	    pSample->SetTime(&tCurrent, &tStopThis);
-	    tCurrent = tStopThis;
-
-	    if (bDiscontinuity) {
-		pSample->SetDiscontinuity(TRUE);
-		bDiscontinuity = FALSE;
-	    }
-
-	    hr = m_pReader->SyncReadAligned(pSample);
-
-	    if (FAILED(hr)) {
-		pSample->Release();
-		OnError(hr);
-		return;
-	    }
-
-	    hr = DeliverSample(pSample, tStart, tStop);
-	    if (hr != S_OK) {
-		if (FAILED(hr)) {
-		    OnError(hr);
-		}
-		return;
-	    }
-	}
-    }
-
-    EndOfStream();
-}
-
-// after a flush, cancelled i/o will be waiting for collection
-// and release
-void
-CPullPin::CleanupCancelled(void)
-{
-    while (1) {
-	IMediaSample * pSample;
-	DWORD_PTR dwUnused;
-
-	HRESULT hr = m_pReader->WaitForNext(
-			    0,          // no wait
-			    &pSample,
-			    &dwUnused);
-	if(pSample) {
-	    pSample->Release();
-	} else {
-	    // no more samples
-	    return;
-	}
-    }
-}

3rdparty/baseclasses/pullpin.h

@@ -1,152 +0,0 @@
-//------------------------------------------------------------------------------
-// File: PullPin.h
-//
-// Desc: DirectShow base classes - defines CPullPin class.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-#ifndef __PULLPIN_H__
-#define __PULLPIN_H__
-
-//
-// CPullPin
-//
-// object supporting pulling data from an IAsyncReader interface.
-// Given a start/stop position, calls a pure Receive method with each
-// IMediaSample received.
-//
-// This is essentially for use in a MemInputPin when it finds itself
-// connected to an IAsyncReader pin instead of a pushing pin.
-//
-
-class CPullPin : public CAMThread
-{
-    IAsyncReader*       m_pReader;
-    REFERENCE_TIME      m_tStart;
-    REFERENCE_TIME      m_tStop;
-    REFERENCE_TIME      m_tDuration;
-    BOOL                m_bSync;
-
-    enum ThreadMsg {
-	TM_Pause,       // stop pulling and wait for next message
-	TM_Start,       // start pulling
-	TM_Exit,        // stop and exit
-    };
-
-    ThreadMsg m_State;
-
-    // override pure thread proc from CAMThread
-    DWORD ThreadProc(void);
-
-    // running pull method (check m_bSync)
-    void Process(void);
-
-    // clean up any cancelled i/o after a flush
-    void CleanupCancelled(void);
-
-    // suspend thread from pulling, eg during seek
-    HRESULT PauseThread();
-
-    // start thread pulling - create thread if necy
-    HRESULT StartThread();
-
-    // stop and close thread
-    HRESULT StopThread();
-
-    // called from ProcessAsync to queue and collect requests
-    HRESULT QueueSample(
-		__inout REFERENCE_TIME& tCurrent,
-		REFERENCE_TIME tAlignStop,
-		BOOL bDiscontinuity);
-
-    HRESULT CollectAndDeliver(
-		REFERENCE_TIME tStart,
-		REFERENCE_TIME tStop);
-
-    HRESULT DeliverSample(
-		IMediaSample* pSample,
-		REFERENCE_TIME tStart,
-		REFERENCE_TIME tStop);
-
-protected:
-    IMemAllocator *     m_pAlloc;
-
-public:
-    CPullPin();
-    virtual ~CPullPin();
-
-    // returns S_OK if successfully connected to an IAsyncReader interface
-    // from this object
-    // Optional allocator should be proposed as a preferred allocator if
-    // necessary
-    // bSync is TRUE if we are to use sync reads instead of the
-    // async methods.
-    HRESULT Connect(IUnknown* pUnk, IMemAllocator* pAlloc, BOOL bSync);
-
-    // disconnect any connection made in Connect
-    HRESULT Disconnect();
-
-    // agree an allocator using RequestAllocator - optional
-    // props param specifies your requirements (non-zero fields).
-    // returns an error code if fail to match requirements.
-    // optional IMemAllocator interface is offered as a preferred allocator
-    // but no error occurs if it can't be met.
-    virtual HRESULT DecideAllocator(
-		IMemAllocator* pAlloc,
-		__inout_opt ALLOCATOR_PROPERTIES * pProps);
-
-    // set start and stop position. if active, will start immediately at
-    // the new position. Default is 0 to duration
-    HRESULT Seek(REFERENCE_TIME tStart, REFERENCE_TIME tStop);
-
-    // return the total duration
-    HRESULT Duration(__out REFERENCE_TIME* ptDuration);
-
-    // start pulling data
-    HRESULT Active(void);
-
-    // stop pulling data
-    HRESULT Inactive(void);
-
-    // helper functions
-    LONGLONG AlignDown(LONGLONG ll, LONG lAlign) {
-	// aligning downwards is just truncation
-	return ll & ~(lAlign-1);
-    };
-
-    LONGLONG AlignUp(LONGLONG ll, LONG lAlign) {
-	// align up: round up to next boundary
-	return (ll + (lAlign -1)) & ~(lAlign -1);
-    };
-
-    // GetReader returns the (addrefed) IAsyncReader interface
-    // for SyncRead etc
-    IAsyncReader* GetReader() {
-	m_pReader->AddRef();
-	return m_pReader;
-    };
-
-    // -- pure --
-
-    // override this to handle data arrival
-    // return value other than S_OK will stop data
-    virtual HRESULT Receive(IMediaSample*) PURE;
-
-    // override this to handle end-of-stream
-    virtual HRESULT EndOfStream(void) PURE;
-
-    // called on runtime errors that will have caused pulling
-    // to stop
-    // these errors are all returned from the upstream filter, who
-    // will have already reported any errors to the filtergraph.
-    virtual void OnError(HRESULT hr) PURE;
-
-    // flush this pin and all downstream
-    virtual HRESULT BeginFlush() PURE;
-    virtual HRESULT EndFlush() PURE;
-
-};
-
-#endif //__PULLPIN_H__

3rdparty/baseclasses/refclock.cpp

@@ -1,402 +0,0 @@
-//------------------------------------------------------------------------------
-// File: RefClock.cpp
-//
-// Desc: DirectShow base classes - implements the IReferenceClock interface.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-#include <streams.h>
-#include <limits.h>
-
-#ifdef DXMPERF
-#include "dxmperf.h"
-#endif // DXMPERF
-
-
-// 'this' used in constructor list
-#pragma warning(disable:4355)
-
-
-STDMETHODIMP CBaseReferenceClock::NonDelegatingQueryInterface(
-    REFIID riid,
-    __deref_out void ** ppv)
-{
-    HRESULT hr;
-
-    if (riid == IID_IReferenceClock)
-    {
-        hr = GetInterface((IReferenceClock *) this, ppv);
-    }
-    else if (riid == IID_IReferenceClockTimerControl)
-    {
-        hr = GetInterface((IReferenceClockTimerControl *) this, ppv);
-    }
-    else
-    {
-        hr = CUnknown::NonDelegatingQueryInterface(riid, ppv);
-    }
-    return hr;
-}
-
-CBaseReferenceClock::~CBaseReferenceClock()
-{
-#ifdef DXMPERF
-    PERFLOG_DTOR( L"CBaseReferenceClock", (IReferenceClock *) this );
-#endif // DXMPERF
-
-    if (m_TimerResolution) timeEndPeriod(m_TimerResolution);
-
-    if (m_pSchedule)
-    {
-        m_pSchedule->DumpLinkedList();
-    }
-
-    if (m_hThread)
-    {
-        m_bAbort = TRUE;
-        TriggerThread();
-        WaitForSingleObject( m_hThread, INFINITE );
-        EXECUTE_ASSERT( CloseHandle(m_hThread) );
-        m_hThread = 0;
-        EXECUTE_ASSERT( CloseHandle(m_pSchedule->GetEvent()) );
-	delete m_pSchedule;
-    }
-}
-
-// A derived class may supply a hThreadEvent if it has its own thread that will take care
-// of calling the schedulers Advise method.  (Refere to CBaseReferenceClock::AdviseThread()
-// to see what such a thread has to do.)
-CBaseReferenceClock::CBaseReferenceClock( __in_opt LPCTSTR pName,
-                                          __inout_opt LPUNKNOWN pUnk,
-                                          __inout HRESULT *phr,
-                                          __inout_opt CAMSchedule * pShed )
-: CUnknown( pName, pUnk )
-, m_rtLastGotTime(0)
-, m_TimerResolution(0)
-, m_bAbort( FALSE )
-, m_pSchedule( pShed ? pShed : new CAMSchedule(CreateEvent(NULL, FALSE, FALSE, NULL)) )
-, m_hThread(0)
-{
-
-#ifdef DXMPERF
-    PERFLOG_CTOR( pName ? pName : L"CBaseReferenceClock", (IReferenceClock *) this );
-#endif // DXMPERF
-
-    ASSERT(m_pSchedule);
-    if (!m_pSchedule)
-    {
-        *phr = E_OUTOFMEMORY;
-    }
-    else
-    {
-        // Set up the highest resolution timer we can manage
-        TIMECAPS tc;
-        m_TimerResolution = (TIMERR_NOERROR == timeGetDevCaps(&tc, sizeof(tc)))
-                            ? tc.wPeriodMin
-                            : 1;
-
-        timeBeginPeriod(m_TimerResolution);
-
-        /* Initialise our system times - the derived clock should set the right values */
-        m_dwPrevSystemTime = timeGetTime();
-        m_rtPrivateTime = (UNITS / MILLISECONDS) * m_dwPrevSystemTime;
-
-        #ifdef PERF
-            m_idGetSystemTime = MSR_REGISTER(TEXT("CBaseReferenceClock::GetTime"));
-        #endif
-
-        if ( !pShed )
-        {
-            DWORD ThreadID;
-            m_hThread = ::CreateThread(NULL,                  // Security attributes
-                                       (DWORD) 0,             // Initial stack size
-                                       AdviseThreadFunction,  // Thread start address
-                                       (LPVOID) this,         // Thread parameter
-                                       (DWORD) 0,             // Creation flags
-                                       &ThreadID);            // Thread identifier
-
-            if (m_hThread)
-            {
-                SetThreadPriority( m_hThread, THREAD_PRIORITY_TIME_CRITICAL );
-            }
-            else
-            {
-                *phr = E_FAIL;
-                EXECUTE_ASSERT( CloseHandle(m_pSchedule->GetEvent()) );
-                delete m_pSchedule;
-                m_pSchedule = NULL;
-            }
-        }
-    }
-}
-
-void CBaseReferenceClock::Restart (IN REFERENCE_TIME rtMinTime)
-{
-    Lock();
-    m_rtLastGotTime = rtMinTime ;
-    Unlock();
-}
-
-STDMETHODIMP CBaseReferenceClock::GetTime(__out REFERENCE_TIME *pTime)
-{
-    HRESULT hr;
-    if (pTime)
-    {
-        REFERENCE_TIME rtNow;
-        Lock();
-        rtNow = GetPrivateTime();
-        if (rtNow > m_rtLastGotTime)
-        {
-            m_rtLastGotTime = rtNow;
-            hr = S_OK;
-        }
-        else
-        {
-            hr = S_FALSE;
-        }
-        *pTime = m_rtLastGotTime;
-        Unlock();
-        MSR_INTEGER(m_idGetSystemTime, LONG((*pTime) / (UNITS/MILLISECONDS)) );
-
-#ifdef DXMPERF
-        PERFLOG_GETTIME( (IReferenceClock *) this, *pTime );
-#endif // DXMPERF
-
-    }
-    else hr = E_POINTER;
-
-    return hr;
-}
-
-/* Ask for an async notification that a time has elapsed */
-
-STDMETHODIMP CBaseReferenceClock::AdviseTime(
-    REFERENCE_TIME baseTime,         // base reference time
-    REFERENCE_TIME streamTime,       // stream offset time
-    HEVENT hEvent,                   // advise via this event
-    __out DWORD_PTR *pdwAdviseCookie)// where your cookie goes
-{
-    CheckPointer(pdwAdviseCookie, E_POINTER);
-    *pdwAdviseCookie = 0;
-
-    // Check that the event is not already set
-    ASSERT(WAIT_TIMEOUT == WaitForSingleObject(HANDLE(hEvent),0));
-
-    HRESULT hr;
-
-    const REFERENCE_TIME lRefTime = baseTime + streamTime;
-    if ( lRefTime <= 0 || lRefTime == MAX_TIME )
-    {
-        hr = E_INVALIDARG;
-    }
-    else
-    {
-        *pdwAdviseCookie = m_pSchedule->AddAdvisePacket( lRefTime, 0, HANDLE(hEvent), FALSE );
-        hr = *pdwAdviseCookie ? NOERROR : E_OUTOFMEMORY;
-    }
-    return hr;
-}
-
-
-/* Ask for an asynchronous periodic notification that a time has elapsed */
-
-STDMETHODIMP CBaseReferenceClock::AdvisePeriodic(
-    REFERENCE_TIME StartTime,         // starting at this time
-    REFERENCE_TIME PeriodTime,        // time between notifications
-    HSEMAPHORE hSemaphore,            // advise via a semaphore
-    __out DWORD_PTR *pdwAdviseCookie) // where your cookie goes
-{
-    CheckPointer(pdwAdviseCookie, E_POINTER);
-    *pdwAdviseCookie = 0;
-
-    HRESULT hr;
-    if (StartTime > 0 && PeriodTime > 0 && StartTime != MAX_TIME )
-    {
-        *pdwAdviseCookie = m_pSchedule->AddAdvisePacket( StartTime, PeriodTime, HANDLE(hSemaphore), TRUE );
-        hr = *pdwAdviseCookie ? NOERROR : E_OUTOFMEMORY;
-    }
-    else hr = E_INVALIDARG;
-
-    return hr;
-}
-
-
-STDMETHODIMP CBaseReferenceClock::Unadvise(DWORD_PTR dwAdviseCookie)
-{
-    return m_pSchedule->Unadvise(dwAdviseCookie);
-}
-
-
-REFERENCE_TIME CBaseReferenceClock::GetPrivateTime()
-{
-    CAutoLock cObjectLock(this);
-
-
-    /* If the clock has wrapped then the current time will be less than
-     * the last time we were notified so add on the extra milliseconds
-     *
-     * The time period is long enough so that the likelihood of
-     * successive calls spanning the clock cycle is not considered.
-     */
-
-    DWORD dwTime = timeGetTime();
-    {
-        m_rtPrivateTime += Int32x32To64(UNITS / MILLISECONDS, (DWORD)(dwTime - m_dwPrevSystemTime));
-        m_dwPrevSystemTime = dwTime;
-    }
-
-    return m_rtPrivateTime;
-}
-
-
-/* Adjust the current time by the input value.  This allows an
-   external time source to work out some of the latency of the clock
-   system and adjust the "current" time accordingly.  The intent is
-   that the time returned to the user is synchronised to a clock
-   source and allows drift to be catered for.
-
-   For example: if the clock source detects a drift it can pass a delta
-   to the current time rather than having to set an explicit time.
-*/
-
-STDMETHODIMP CBaseReferenceClock::SetTimeDelta(const REFERENCE_TIME & TimeDelta)
-{
-#ifdef DEBUG
-
-    // Just break if passed an improper time delta value
-    LONGLONG llDelta = TimeDelta > 0 ? TimeDelta : -TimeDelta;
-    if (llDelta > UNITS * 1000) {
-        DbgLog((LOG_TRACE, 0, TEXT("Bad Time Delta")));
-        //DebugBreak();
-    }
-
-    // We're going to calculate a "severity" for the time change. Max -1
-    // min 8.  We'll then use this as the debug logging level for a
-    // debug log message.
-    const LONG usDelta = LONG(TimeDelta/10);      // Delta in micro-secs
-
-    DWORD delta        = abs(usDelta);            // varying delta
-    // Severity == 8 - ceil(log<base 8>(abs( micro-secs delta)))
-    int   Severity     = 8;
-    while ( delta > 0 )
-    {
-        delta >>= 3;                              // div 8
-        Severity--;
-    }
-
-    // Sev == 0 => > 2 second delta!
-    DbgLog((LOG_TIMING, Severity < 0 ? 0 : Severity,
-        TEXT("Sev %2i: CSystemClock::SetTimeDelta(%8ld us) %lu -> %lu ms."),
-        Severity, usDelta, DWORD(ConvertToMilliseconds(m_rtPrivateTime)),
-        DWORD(ConvertToMilliseconds(TimeDelta+m_rtPrivateTime)) ));
-
-    // Don't want the DbgBreak to fire when running stress on debug-builds.
-    #ifdef BREAK_ON_SEVERE_TIME_DELTA
-        if (Severity < 0)
-            DbgBreakPoint(TEXT("SetTimeDelta > 16 seconds!"),
-                          TEXT(__FILE__),__LINE__);
-    #endif
-
-#endif
-
-    CAutoLock cObjectLock(this);
-    m_rtPrivateTime += TimeDelta;
-    // If time goes forwards, and we have advises, then we need to
-    // trigger the thread so that it can re-evaluate its wait time.
-    // Since we don't want the cost of the thread switches if the change
-    // is really small, only do it if clock goes forward by more than
-    // 0.5 millisecond.  If the time goes backwards, the thread will
-    // wake up "early" (relativly speaking) and will re-evaluate at
-    // that time.
-    if ( TimeDelta > 5000 && m_pSchedule->GetAdviseCount() > 0 ) TriggerThread();
-    return NOERROR;
-}
-
-// Thread stuff
-
-DWORD __stdcall CBaseReferenceClock::AdviseThreadFunction(__in LPVOID p)
-{
-    return DWORD(reinterpret_cast<CBaseReferenceClock*>(p)->AdviseThread());
-}
-
-HRESULT CBaseReferenceClock::AdviseThread()
-{
-    DWORD dwWait = INFINITE;
-
-    // The first thing we do is wait until something interesting happens
-    // (meaning a first advise or shutdown).  This prevents us calling
-    // GetPrivateTime immediately which is goodness as that is a virtual
-    // routine and the derived class may not yet be constructed.  (This
-    // thread is created in the base class constructor.)
-
-    while ( !m_bAbort )
-    {
-        // Wait for an interesting event to happen
-        DbgLog((LOG_TIMING, 3, TEXT("CBaseRefClock::AdviseThread() Delay: %lu ms"), dwWait ));
-        WaitForSingleObject(m_pSchedule->GetEvent(), dwWait);
-        if (m_bAbort) break;
-
-        // There are several reasons why we need to work from the internal
-        // time, mainly to do with what happens when time goes backwards.
-        // Mainly, it stop us looping madly if an event is just about to
-        // expire when the clock goes backward (i.e. GetTime stop for a
-        // while).
-        const REFERENCE_TIME  rtNow = GetPrivateTime();
-
-        DbgLog((LOG_TIMING, 3,
-              TEXT("CBaseRefClock::AdviseThread() Woke at = %lu ms"),
-              ConvertToMilliseconds(rtNow) ));
-
-        // We must add in a millisecond, since this is the resolution of our
-        // WaitForSingleObject timer.  Failure to do so will cause us to loop
-        // franticly for (approx) 1 a millisecond.
-        m_rtNextAdvise = m_pSchedule->Advise( 10000 + rtNow );
-        LONGLONG llWait = m_rtNextAdvise - rtNow;
-
-        ASSERT( llWait > 0 );
-
-        llWait = ConvertToMilliseconds(llWait);
-        // DON'T replace this with a max!! (The type's of these things is VERY important)
-        dwWait = (llWait > REFERENCE_TIME(UINT_MAX)) ? UINT_MAX : DWORD(llWait);
-    };
-    return NOERROR;
-}
-
-HRESULT CBaseReferenceClock::SetDefaultTimerResolution(
-        REFERENCE_TIME timerResolution // in 100ns
-    )
-{
-    CAutoLock cObjectLock(this);
-    if( 0 == timerResolution  ) {
-        if( m_TimerResolution ) {
-           timeEndPeriod( m_TimerResolution );
-           m_TimerResolution = 0;
-        }
-    } else {
-        TIMECAPS tc;
-        DWORD dwMinResolution = (TIMERR_NOERROR == timeGetDevCaps(&tc, sizeof(tc)))
-                            ? tc.wPeriodMin
-                            : 1;
-        DWORD dwResolution = max( dwMinResolution, DWORD(timerResolution / 10000) );
-        if( dwResolution != m_TimerResolution ) {
-            timeEndPeriod(m_TimerResolution);
-            m_TimerResolution = dwResolution;
-            timeBeginPeriod( m_TimerResolution );
-        }
-    }
-    return S_OK;
-}
-
-HRESULT CBaseReferenceClock::GetDefaultTimerResolution(
-        __out REFERENCE_TIME* pTimerResolution // in 100ns
-    )
-{
-    if( !pTimerResolution ) {
-        return E_POINTER;
-    }
-    CAutoLock cObjectLock(this);
-    *pTimerResolution = m_TimerResolution * 10000;
-    return S_OK;
-}

3rdparty/baseclasses/refclock.h

@@ -1,184 +0,0 @@
-//------------------------------------------------------------------------------
-// File: RefClock.h
-//
-// Desc: DirectShow base classes - defines the IReferenceClock interface.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-#ifndef __BASEREFCLOCK__
-#define __BASEREFCLOCK__
-
-#include <Schedule.h>
-
-const UINT RESOLUTION = 1;                      /* High resolution timer */
-const INT ADVISE_CACHE = 4;                     /* Default cache size */
-const LONGLONG MAX_TIME = 0x7FFFFFFFFFFFFFFF;   /* Maximum LONGLONG value */
-
-inline LONGLONG WINAPI ConvertToMilliseconds(const REFERENCE_TIME& RT)
-{
-    /* This converts an arbitrary value representing a reference time
-       into a MILLISECONDS value for use in subsequent system calls */
-
-    return (RT / (UNITS / MILLISECONDS));
-}
-
-/* This class hierarchy will support an IReferenceClock interface so
-   that an audio card (or other externally driven clock) can update the
-   system wide clock that everyone uses.
-
-   The interface will be pretty thin with probably just one update method
-   This interface has not yet been defined.
- */
-
-/* This abstract base class implements the IReferenceClock
- * interface.  Classes that actually provide clock signals (from
- * whatever source) have to be derived from this class.
- *
- * The abstract class provides implementations for:
- *  CUnknown support
- *      locking support (CCritSec)
- *  client advise code (creates a thread)
- *
- * Question: what can we do about quality?  Change the timer
- * resolution to lower the system load?  Up the priority of the
- * timer thread to force more responsive signals?
- *
- * During class construction we create a worker thread that is destroyed during
- * destuction.  This thread executes a series of WaitForSingleObject calls,
- * waking up when a command is given to the thread or the next wake up point
- * is reached.  The wakeup points are determined by clients making Advise
- * calls.
- *
- * Each advise call defines a point in time when they wish to be notified.  A
- * periodic advise is a series of these such events.  We maintain a list of
- * advise links and calculate when the nearest event notification is due for.
- * We then call WaitForSingleObject with a timeout equal to this time.  The
- * handle we wait on is used by the class to signal that something has changed
- * and that we must reschedule the next event.  This typically happens when
- * someone comes in and asks for an advise link while we are waiting for an
- * event to timeout.
- *
- * While we are modifying the list of advise requests we
- * are protected from interference through a critical section.  Clients are NOT
- * advised through callbacks.  One shot clients have an event set, while
- * periodic clients have a semaphore released for each event notification.  A
- * semaphore allows a client to be kept up to date with the number of events
- * actually triggered and be assured that they can't miss multiple events being
- * set.
- *
- * Keeping track of advises is taken care of by the CAMSchedule class.
- */
-
-class CBaseReferenceClock
-: public CUnknown, public IReferenceClock, public CCritSec, public IReferenceClockTimerControl
-{
-protected:
-    virtual ~CBaseReferenceClock();     // Don't let me be created on the stack!
-public:
-    CBaseReferenceClock(__in_opt LPCTSTR pName,
-                        __inout_opt LPUNKNOWN pUnk,
-                        __inout HRESULT *phr,
-                        __inout_opt CAMSchedule * pSched = 0 );
-
-    STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, __deref_out void ** ppv);
-
-    DECLARE_IUNKNOWN
-
-    /* IReferenceClock methods */
-    // Derived classes must implement GetPrivateTime().  All our GetTime
-    // does is call GetPrivateTime and then check so that time does not
-    // go backwards.  A return code of S_FALSE implies that the internal
-    // clock has gone backwards and GetTime time has halted until internal
-    // time has caught up. (Don't know if this will be much use to folk,
-    // but it seems odd not to use the return code for something useful.)
-    STDMETHODIMP GetTime(__out REFERENCE_TIME *pTime);
-    // When this is called, it sets m_rtLastGotTime to the time it returns.
-
-    /* Provide standard mechanisms for scheduling events */
-
-    /* Ask for an async notification that a time has elapsed */
-    STDMETHODIMP AdviseTime(
-        REFERENCE_TIME baseTime,        // base reference time
-        REFERENCE_TIME streamTime,      // stream offset time
-        HEVENT hEvent,                  // advise via this event
-        __out DWORD_PTR *pdwAdviseCookie// where your cookie goes
-    );
-
-    /* Ask for an asynchronous periodic notification that a time has elapsed */
-    STDMETHODIMP AdvisePeriodic(
-        REFERENCE_TIME StartTime,       // starting at this time
-        REFERENCE_TIME PeriodTime,      // time between notifications
-        HSEMAPHORE hSemaphore,          // advise via a semaphore
-        __out DWORD_PTR *pdwAdviseCookie// where your cookie goes
-    );
-
-    /* Cancel a request for notification(s) - if the notification was
-     * a one shot timer then this function doesn't need to be called
-     * as the advise is automatically cancelled, however it does no
-     * harm to explicitly cancel a one-shot advise.  It is REQUIRED that
-     * clients call Unadvise to clear a Periodic advise setting.
-     */
-
-    STDMETHODIMP Unadvise(DWORD_PTR dwAdviseCookie);
-
-    /* Methods for the benefit of derived classes or outer objects */
-
-    // GetPrivateTime() is the REAL clock.  GetTime is just a cover for
-    // it.  Derived classes will probably override this method but not
-    // GetTime() itself.
-    // The important point about GetPrivateTime() is it's allowed to go
-    // backwards.  Our GetTime() will keep returning the LastGotTime
-    // until GetPrivateTime() catches up.
-    virtual REFERENCE_TIME GetPrivateTime();
-
-    /* Provide a method for correcting drift */
-    STDMETHODIMP SetTimeDelta( const REFERENCE_TIME& TimeDelta );
-
-    CAMSchedule * GetSchedule() const { return m_pSchedule; }
-
-    // IReferenceClockTimerControl methods
-    //
-    // Setting a default of 0 disables the default of 1ms
-    STDMETHODIMP SetDefaultTimerResolution(
-        REFERENCE_TIME timerResolution // in 100ns
-    );
-    STDMETHODIMP GetDefaultTimerResolution(
-        __out REFERENCE_TIME* pTimerResolution // in 100ns
-    );
-
-private:
-    REFERENCE_TIME m_rtPrivateTime;     // Current best estimate of time
-    DWORD          m_dwPrevSystemTime;  // Last vaule we got from timeGetTime
-    REFERENCE_TIME m_rtLastGotTime;     // Last time returned by GetTime
-    REFERENCE_TIME m_rtNextAdvise;      // Time of next advise
-    UINT           m_TimerResolution;
-
-#ifdef PERF
-    int m_idGetSystemTime;
-#endif
-
-// Thread stuff
-public:
-    void TriggerThread()    // Wakes thread up.  Need to do this if
-    {                       // time to next advise needs reevaluating.
-        EXECUTE_ASSERT(SetEvent(m_pSchedule->GetEvent()));
-    }
-
-
-private:
-    BOOL           m_bAbort;            // Flag used for thread shutdown
-    HANDLE         m_hThread;           // Thread handle
-
-    HRESULT AdviseThread();             // Method in which the advise thread runs
-    static DWORD __stdcall AdviseThreadFunction(__in LPVOID); // Function used to get there
-
-protected:
-    CAMSchedule * m_pSchedule;
-
-    void Restart (IN REFERENCE_TIME rtMinTime = 0I64) ;
-};
-
-#endif
-

3rdparty/baseclasses/reftime.h

@@ -1,116 +0,0 @@
-//------------------------------------------------------------------------------
-// File: RefTime.h
-//
-// Desc: DirectShow base classes - defines CRefTime, a class that manages
-//       reference times.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation. All rights reserved.
-//------------------------------------------------------------------------------
-
-
-//
-// CRefTime
-//
-// Manage reference times.
-// Shares same data layout as REFERENCE_TIME, but adds some (nonvirtual)
-// functions providing simple comparison, conversion and arithmetic.
-//
-// A reference time (at the moment) is a unit of seconds represented in
-// 100ns units as is used in the Win32 FILETIME structure. BUT the time
-// a REFERENCE_TIME represents is NOT the time elapsed since 1/1/1601 it
-// will either be stream time or reference time depending upon context
-//
-// This class provides simple arithmetic operations on reference times
-//
-// keep non-virtual otherwise the data layout will not be the same as
-// REFERENCE_TIME
-
-
-// -----
-// note that you are safe to cast a CRefTime* to a REFERENCE_TIME*, but
-// you will need to do so explicitly
-// -----
-
-
-#ifndef __REFTIME__
-#define __REFTIME__
-
-
-const LONGLONG MILLISECONDS = (1000);            // 10 ^ 3
-const LONGLONG NANOSECONDS = (1000000000);       // 10 ^ 9
-const LONGLONG UNITS = (NANOSECONDS / 100);      // 10 ^ 7
-
-/*  Unfortunately an inline function here generates a call to __allmul
-    - even for constants!
-*/
-#define MILLISECONDS_TO_100NS_UNITS(lMs) \
-    Int32x32To64((lMs), (UNITS / MILLISECONDS))
-
-class CRefTime
-{
-public:
-
-    // *MUST* be the only data member so that this class is exactly
-    // equivalent to a REFERENCE_TIME.
-    // Also, must be *no virtual functions*
-
-    REFERENCE_TIME m_time;
-
-    inline CRefTime()
-    {
-        // default to 0 time
-        m_time = 0;
-    };
-
-    inline CRefTime(LONG msecs)
-    {
-        m_time = MILLISECONDS_TO_100NS_UNITS(msecs);
-    };
-
-    inline CRefTime(REFERENCE_TIME rt)
-    {
-        m_time = rt;
-    };
-
-    inline operator REFERENCE_TIME() const
-    {
-        return m_time;
-    };
-
-    inline CRefTime& operator=(const CRefTime& rt)
-    {
-        m_time = rt.m_time;
-        return *this;
-    };
-
-    inline CRefTime& operator=(const LONGLONG ll)
-    {
-        m_time = ll;
-        return *this;
-    };
-
-    inline CRefTime& operator+=(const CRefTime& rt)
-    {
-        return (*this = *this + rt);
-    };
-
-    inline CRefTime& operator-=(const CRefTime& rt)
-    {
-        return (*this = *this - rt);
-    };
-
-    inline LONG Millisecs(void)
-    {
-        return (LONG)(m_time / (UNITS / MILLISECONDS));
-    };
-
-    inline LONGLONG GetUnits(void)
-    {
-        return m_time;
-    };
-};
-
-const LONGLONG TimeZero = 0;
-
-#endif /* __REFTIME__ */
-

3rdparty/baseclasses/renbase.h

@@ -1,478 +0,0 @@
-//------------------------------------------------------------------------------
-// File: RenBase.h
-//
-// Desc: DirectShow base classes - defines a generic ActiveX base renderer
-//       class.
-//
-// Copyright (c) 1992-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-#ifndef __RENBASE__
-#define __RENBASE__
-
-// Forward class declarations
-
-class CBaseRenderer;
-class CBaseVideoRenderer;
-class CRendererInputPin;
-
-// This is our input pin class that channels calls to the renderer
-
-class CRendererInputPin : public CBaseInputPin
-{
-protected:
-
-    CBaseRenderer *m_pRenderer;
-
-public:
-
-    CRendererInputPin(__inout CBaseRenderer *pRenderer,
-                      __inout HRESULT *phr,
-                      __in_opt LPCWSTR Name);
-
-    // Overriden from the base pin classes
-
-    HRESULT BreakConnect();
-    HRESULT CompleteConnect(IPin *pReceivePin);
-    HRESULT SetMediaType(const CMediaType *pmt);
-    HRESULT CheckMediaType(const CMediaType *pmt);
-    HRESULT Active();
-    HRESULT Inactive();
-
-    // Add rendering behaviour to interface functions
-
-    STDMETHODIMP QueryId(__deref_out LPWSTR *Id);
-    STDMETHODIMP EndOfStream();
-    STDMETHODIMP BeginFlush();
-    STDMETHODIMP EndFlush();
-    STDMETHODIMP Receive(IMediaSample *pMediaSample);
-
-    // Helper
-    IMemAllocator inline *Allocator() const
-    {
-        return m_pAllocator;
-    }
-};
-
-// Main renderer class that handles synchronisation and state changes
-
-class CBaseRenderer : public CBaseFilter
-{
-protected:
-
-    friend class CRendererInputPin;
-
-    friend void CALLBACK EndOfStreamTimer(UINT uID,      // Timer identifier
-                                          UINT uMsg,     // Not currently used
-                                          DWORD_PTR dwUser,  // User information
-                                          DWORD_PTR dw1,     // Windows reserved
-                                          DWORD_PTR dw2);    // Is also reserved
-
-    CRendererPosPassThru *m_pPosition;  // Media seeking pass by object
-    CAMEvent m_RenderEvent;             // Used to signal timer events
-    CAMEvent m_ThreadSignal;            // Signalled to release worker thread
-    CAMEvent m_evComplete;              // Signalled when state complete
-    BOOL m_bAbort;                      // Stop us from rendering more data
-    BOOL m_bStreaming;                  // Are we currently streaming
-    DWORD_PTR m_dwAdvise;                   // Timer advise cookie
-    IMediaSample *m_pMediaSample;       // Current image media sample
-    BOOL m_bEOS;                        // Any more samples in the stream
-    BOOL m_bEOSDelivered;               // Have we delivered an EC_COMPLETE
-    CRendererInputPin *m_pInputPin;     // Our renderer input pin object
-    CCritSec m_InterfaceLock;           // Critical section for interfaces
-    CCritSec m_RendererLock;            // Controls access to internals
-    IQualityControl * m_pQSink;         // QualityControl sink
-    BOOL m_bRepaintStatus;              // Can we signal an EC_REPAINT
-    //  Avoid some deadlocks by tracking filter during stop
-    volatile BOOL  m_bInReceive;        // Inside Receive between PrepareReceive
-                                        // And actually processing the sample
-    REFERENCE_TIME m_SignalTime;        // Time when we signal EC_COMPLETE
-    UINT m_EndOfStreamTimer;            // Used to signal end of stream
-    CCritSec m_ObjectCreationLock;      // This lock protects the creation and
-                                        // of m_pPosition and m_pInputPin.  It
-                                        // ensures that two threads cannot create
-                                        // either object simultaneously.
-
-public:
-
-    CBaseRenderer(REFCLSID RenderClass, // CLSID for this renderer
-                  __in_opt LPCTSTR pName,         // Debug ONLY description
-                  __inout_opt LPUNKNOWN pUnk,       // Aggregated owner object
-                  __inout HRESULT *phr);        // General OLE return code
-
-    ~CBaseRenderer();
-
-    // Overriden to say what interfaces we support and where
-
-    virtual HRESULT GetMediaPositionInterface(REFIID riid, __deref_out void **ppv);
-    STDMETHODIMP NonDelegatingQueryInterface(REFIID, __deref_out void **);
-
-    virtual HRESULT SourceThreadCanWait(BOOL bCanWait);
-
-#ifdef DEBUG
-    // Debug only dump of the renderer state
-    void DisplayRendererState();
-#endif
-    virtual HRESULT WaitForRenderTime();
-    virtual HRESULT CompleteStateChange(FILTER_STATE OldState);
-
-    // Return internal information about this filter
-
-    BOOL IsEndOfStream() { return m_bEOS; };
-    BOOL IsEndOfStreamDelivered() { return m_bEOSDelivered; };
-    BOOL IsStreaming() { return m_bStreaming; };
-    void SetAbortSignal(BOOL bAbort) { m_bAbort = bAbort; };
-    virtual void OnReceiveFirstSample(IMediaSample *pMediaSample) { };
-    CAMEvent *GetRenderEvent() { return &m_RenderEvent; };
-
-    // Permit access to the transition state
-
-    void Ready() { m_evComplete.Set(); };
-    void NotReady() { m_evComplete.Reset(); };
-    BOOL CheckReady() { return m_evComplete.Check(); };
-
-    virtual int GetPinCount();
-    virtual CBasePin *GetPin(int n);
-    FILTER_STATE GetRealState();
-    void SendRepaint();
-    void SendNotifyWindow(IPin *pPin,HWND hwnd);
-    BOOL OnDisplayChange();
-    void SetRepaintStatus(BOOL bRepaint);
-
-    // Override the filter and pin interface functions
-
-    STDMETHODIMP Stop();
-    STDMETHODIMP Pause();
-    STDMETHODIMP Run(REFERENCE_TIME StartTime);
-    STDMETHODIMP GetState(DWORD dwMSecs, __out FILTER_STATE *State);
-    STDMETHODIMP FindPin(LPCWSTR Id, __deref_out IPin **ppPin);
-
-    // These are available for a quality management implementation
-
-    virtual void OnRenderStart(IMediaSample *pMediaSample);
-    virtual void OnRenderEnd(IMediaSample *pMediaSample);
-    virtual HRESULT OnStartStreaming() { return NOERROR; };
-    virtual HRESULT OnStopStreaming() { return NOERROR; };
-    virtual void OnWaitStart() { };
-    virtual void OnWaitEnd() { };
-    virtual void PrepareRender() { };
-
-#ifdef PERF
-    REFERENCE_TIME m_trRenderStart; // Just before we started drawing
-                                    // Set in OnRenderStart, Used in OnRenderEnd
-    int m_idBaseStamp;              // MSR_id for frame time stamp
-    int m_idBaseRenderTime;         // MSR_id for true wait time
-    int m_idBaseAccuracy;           // MSR_id for time frame is late (int)
-#endif
-
-    // Quality management implementation for scheduling rendering
-
-    virtual BOOL ScheduleSample(IMediaSample *pMediaSample);
-    virtual HRESULT GetSampleTimes(IMediaSample *pMediaSample,
-                                   __out REFERENCE_TIME *pStartTime,
-                                   __out REFERENCE_TIME *pEndTime);
-
-    virtual HRESULT ShouldDrawSampleNow(IMediaSample *pMediaSample,
-                                        __out REFERENCE_TIME *ptrStart,
-                                        __out REFERENCE_TIME *ptrEnd);
-
-    // Lots of end of stream complexities
-
-    void TimerCallback();
-    void ResetEndOfStreamTimer();
-    HRESULT NotifyEndOfStream();
-    virtual HRESULT SendEndOfStream();
-    virtual HRESULT ResetEndOfStream();
-    virtual HRESULT EndOfStream();
-
-    // Rendering is based around the clock
-
-    void SignalTimerFired();
-    virtual HRESULT CancelNotification();
-    virtual HRESULT ClearPendingSample();
-
-    // Called when the filter changes state
-
-    virtual HRESULT Active();
-    virtual HRESULT Inactive();
-    virtual HRESULT StartStreaming();
-    virtual HRESULT StopStreaming();
-    virtual HRESULT BeginFlush();
-    virtual HRESULT EndFlush();
-
-    // Deal with connections and type changes
-
-    virtual HRESULT BreakConnect();
-    virtual HRESULT SetMediaType(const CMediaType *pmt);
-    virtual HRESULT CompleteConnect(IPin *pReceivePin);
-
-    // These look after the handling of data samples
-
-    virtual HRESULT PrepareReceive(IMediaSample *pMediaSample);
-    virtual HRESULT Receive(IMediaSample *pMediaSample);
-    virtual BOOL HaveCurrentSample();
-    virtual IMediaSample *GetCurrentSample();
-    virtual HRESULT Render(IMediaSample *pMediaSample);
-
-    // Derived classes MUST override these
-    virtual HRESULT DoRenderSample(IMediaSample *pMediaSample) PURE;
-    virtual HRESULT CheckMediaType(const CMediaType *) PURE;
-
-    // Helper
-    void WaitForReceiveToComplete();
-};
-
-
-// CBaseVideoRenderer is a renderer class (see its ancestor class) and
-// it handles scheduling of media samples so that they are drawn at the
-// correct time by the reference clock.  It implements a degradation
-// strategy.  Possible degradation modes are:
-//    Drop frames here (only useful if the drawing takes significant time)
-//    Signal supplier (upstream) to drop some frame(s) - i.e. one-off skip.
-//    Signal supplier to change the frame rate - i.e. ongoing skipping.
-//    Or any combination of the above.
-// In order to determine what's useful to try we need to know what's going
-// on.  This is done by timing various operations (including the supplier).
-// This timing is done by using timeGetTime as it is accurate enough and
-// usually cheaper than calling the reference clock.  It also tells the
-// truth if there is an audio break and the reference clock stops.
-// We provide a number of public entry points (named OnXxxStart, OnXxxEnd)
-// which the rest of the renderer calls at significant moments.  These do
-// the timing.
-
-// the number of frames that the sliding averages are averaged over.
-// the rule is (1024*NewObservation + (AVGPERIOD-1) * PreviousAverage)/AVGPERIOD
-#define AVGPERIOD 4
-#define DO_MOVING_AVG(avg,obs) (avg = (1024*obs + (AVGPERIOD-1)*avg)/AVGPERIOD)
-// Spot the bug in this macro - I can't. but it doesn't work!
-
-class CBaseVideoRenderer : public CBaseRenderer,    // Base renderer class
-                           public IQualProp,        // Property page guff
-                           public IQualityControl   // Allow throttling
-{
-protected:
-
-    // Hungarian:
-    //     tFoo is the time Foo in mSec (beware m_tStart from filter.h)
-    //     trBar is the time Bar by the reference clock
-
-    //******************************************************************
-    // State variables to control synchronisation
-    //******************************************************************
-
-    // Control of sending Quality messages.  We need to know whether
-    // we are in trouble (e.g. frames being dropped) and where the time
-    // is being spent.
-
-    // When we drop a frame we play the next one early.
-    // The frame after that is likely to wait before drawing and counting this
-    // wait as spare time is unfair, so we count it as a zero wait.
-    // We therefore need to know whether we are playing frames early or not.
-
-    int m_nNormal;                  // The number of consecutive frames
-                                    // drawn at their normal time (not early)
-                                    // -1 means we just dropped a frame.
-
-#ifdef PERF
-    BOOL m_bDrawLateFrames;         // Don't drop any frames (debug and I'm
-                                    // not keen on people using it!)
-#endif
-
-    BOOL m_bSupplierHandlingQuality;// The response to Quality messages says
-                                    // our supplier is handling things.
-                                    // We will allow things to go extra late
-                                    // before dropping frames.  We will play
-                                    // very early after he has dropped one.
-
-    // Control of scheduling, frame dropping etc.
-    // We need to know where the time is being spent so as to tell whether
-    // we should be taking action here, signalling supplier or what.
-    // The variables are initialised to a mode of NOT dropping frames.
-    // They will tell the truth after a few frames.
-    // We typically record a start time for an event, later we get the time
-    // again and subtract to get the elapsed time, and we average this over
-    // a few frames.  The average is used to tell what mode we are in.
-
-    // Although these are reference times (64 bit) they are all DIFFERENCES
-    // between times which are small.  An int will go up to 214 secs before
-    // overflow.  Avoiding 64 bit multiplications and divisions seems
-    // worth while.
-
-
-
-    // Audio-video throttling.  If the user has turned up audio quality
-    // very high (in principle it could be any other stream, not just audio)
-    // then we can receive cries for help via the graph manager.  In this case
-    // we put in a wait for some time after rendering each frame.
-    int m_trThrottle;
-
-    // The time taken to render (i.e. BitBlt) frames controls which component
-    // needs to degrade.  If the blt is expensive, the renderer degrades.
-    // If the blt is cheap it's done anyway and the supplier degrades.
-    int m_trRenderAvg;              // Time frames are taking to blt
-    int m_trRenderLast;             // Time for last frame blt
-    int m_tRenderStart;             // Just before we started drawing (mSec)
-                                    // derived from timeGetTime.
-
-    // When frames are dropped we will play the next frame as early as we can.
-    // If it was a false alarm and the machine is fast we slide gently back to
-    // normal timing.  To do this, we record the offset showing just how early
-    // we really are.  This will normally be negative meaning early or zero.
-    int m_trEarliness;
-
-    // Target provides slow long-term feedback to try to reduce the
-    // average sync offset to zero.  Whenever a frame is actually rendered
-    // early we add a msec or two, whenever late we take off a few.
-    // We add or take off 1/32 of the error time.
-    // Eventually we should be hovering around zero.  For a really bad case
-    // where we were (say) 300mSec off, it might take 100 odd frames to
-    // settle down.  The rate of change of this is intended to be slower
-    // than any other mechanism in Quartz, thereby avoiding hunting.
-    int m_trTarget;
-
-    // The proportion of time spent waiting for the right moment to blt
-    // controls whether we bother to drop a frame or whether we reckon that
-    // we're doing well enough that we can stand a one-frame glitch.
-    int m_trWaitAvg;                // Average of last few wait times
-                                    // (actually we just average how early
-                                    // we were).  Negative here means LATE.
-
-    // The average inter-frame time.
-    // This is used to calculate the proportion of the time used by the
-    // three operations (supplying us, waiting, rendering)
-    int m_trFrameAvg;               // Average inter-frame time
-    int m_trDuration;               // duration of last frame.
-
-#ifdef PERF
-    // Performance logging identifiers
-    int m_idTimeStamp;              // MSR_id for frame time stamp
-    int m_idEarliness;              // MSR_id for earliness fudge
-    int m_idTarget;                 // MSR_id for Target fudge
-    int m_idWaitReal;               // MSR_id for true wait time
-    int m_idWait;                   // MSR_id for wait time recorded
-    int m_idFrameAccuracy;          // MSR_id for time frame is late (int)
-    int m_idRenderAvg;              // MSR_id for Render time recorded (int)
-    int m_idSchLateTime;            // MSR_id for lateness at scheduler
-    int m_idQualityRate;            // MSR_id for Quality rate requested
-    int m_idQualityTime;            // MSR_id for Quality time requested
-    int m_idDecision;               // MSR_id for decision code
-    int m_idDuration;               // MSR_id for duration of a frame
-    int m_idThrottle;               // MSR_id for audio-video throttling
-    //int m_idDebug;                  // MSR_id for trace style debugging
-    //int m_idSendQuality;          // MSR_id for timing the notifications per se
-#endif // PERF
-    REFERENCE_TIME m_trRememberStampForPerf;  // original time stamp of frame
-                                              // with no earliness fudges etc.
-#ifdef PERF
-    REFERENCE_TIME m_trRememberFrameForPerf;  // time when previous frame rendered
-
-    // debug...
-    int m_idFrameAvg;
-    int m_idWaitAvg;
-#endif
-
-    // PROPERTY PAGE
-    // This has edit fields that show the user what's happening
-    // These member variables hold these counts.
-
-    int m_cFramesDropped;           // cumulative frames dropped IN THE RENDERER
-    int m_cFramesDrawn;             // Frames since streaming started seen BY THE
-                                    // RENDERER (some may be dropped upstream)
-
-    // Next two support average sync offset and standard deviation of sync offset.
-    LONGLONG m_iTotAcc;                  // Sum of accuracies in mSec
-    LONGLONG m_iSumSqAcc;           // Sum of squares of (accuracies in mSec)
-
-    // Next two allow jitter calculation.  Jitter is std deviation of frame time.
-    REFERENCE_TIME m_trLastDraw;    // Time of prev frame (for inter-frame times)
-    LONGLONG m_iSumSqFrameTime;     // Sum of squares of (inter-frame time in mSec)
-    LONGLONG m_iSumFrameTime;            // Sum of inter-frame times in mSec
-
-    // To get performance statistics on frame rate, jitter etc, we need
-    // to record the lateness and inter-frame time.  What we actually need are the
-    // data above (sum, sum of squares and number of entries for each) but the data
-    // is generated just ahead of time and only later do we discover whether the
-    // frame was actually drawn or not.  So we have to hang on to the data
-    int m_trLate;                   // hold onto frame lateness
-    int m_trFrame;                  // hold onto inter-frame time
-
-    int m_tStreamingStart;          // if streaming then time streaming started
-                                    // else time of last streaming session
-                                    // used for property page statistics
-#ifdef PERF
-    LONGLONG m_llTimeOffset;        // timeGetTime()*10000+m_llTimeOffset==ref time
-#endif
-
-public:
-
-
-    CBaseVideoRenderer(REFCLSID RenderClass, // CLSID for this renderer
-                       __in_opt LPCTSTR pName,         // Debug ONLY description
-                       __inout_opt LPUNKNOWN pUnk,       // Aggregated owner object
-                       __inout HRESULT *phr);        // General OLE return code
-
-    ~CBaseVideoRenderer();
-
-    // IQualityControl methods - Notify allows audio-video throttling
-
-    STDMETHODIMP SetSink( IQualityControl * piqc);
-    STDMETHODIMP Notify( IBaseFilter * pSelf, Quality q);
-
-    // These provide a full video quality management implementation
-
-    void OnRenderStart(IMediaSample *pMediaSample);
-    void OnRenderEnd(IMediaSample *pMediaSample);
-    void OnWaitStart();
-    void OnWaitEnd();
-    HRESULT OnStartStreaming();
-    HRESULT OnStopStreaming();
-    void ThrottleWait();
-
-    // Handle the statistics gathering for our quality management
-
-    void PreparePerformanceData(int trLate, int trFrame);
-    virtual void RecordFrameLateness(int trLate, int trFrame);
-    virtual void OnDirectRender(IMediaSample *pMediaSample);
-    virtual HRESULT ResetStreamingTimes();
-    BOOL ScheduleSample(IMediaSample *pMediaSample);
-    HRESULT ShouldDrawSampleNow(IMediaSample *pMediaSample,
-                                __inout REFERENCE_TIME *ptrStart,
-                                __inout REFERENCE_TIME *ptrEnd);
-
-    virtual HRESULT SendQuality(REFERENCE_TIME trLate, REFERENCE_TIME trRealStream);
-    STDMETHODIMP JoinFilterGraph(__inout_opt IFilterGraph * pGraph, __in_opt LPCWSTR pName);
-
-    //
-    //  Do estimates for standard deviations for per-frame
-    //  statistics
-    //
-    //  *piResult = (llSumSq - iTot * iTot / m_cFramesDrawn - 1) /
-    //                            (m_cFramesDrawn - 2)
-    //  or 0 if m_cFramesDrawn <= 3
-    //
-    HRESULT GetStdDev(
-        int nSamples,
-        __out int *piResult,
-        LONGLONG llSumSq,
-        LONGLONG iTot
-    );
-public:
-
-    // IQualProp property page support
-
-    STDMETHODIMP get_FramesDroppedInRenderer(__out int *cFramesDropped);
-    STDMETHODIMP get_FramesDrawn(__out int *pcFramesDrawn);
-    STDMETHODIMP get_AvgFrameRate(__out int *piAvgFrameRate);
-    STDMETHODIMP get_Jitter(__out int *piJitter);
-    STDMETHODIMP get_AvgSyncOffset(__out int *piAvg);
-    STDMETHODIMP get_DevSyncOffset(__out int *piDev);
-
-    // Implement an IUnknown interface and expose IQualProp
-
-    DECLARE_IUNKNOWN
-    STDMETHODIMP NonDelegatingQueryInterface(REFIID riid,__deref_out VOID **ppv);
-};
-
-#endif // __RENBASE__
-

3rdparty/baseclasses/schedule.cpp

@@ -1,284 +0,0 @@
-//------------------------------------------------------------------------------
-// File: Schedule.cpp
-//
-// Desc: DirectShow base classes.
-//
-// Copyright (c) 1996-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-#include <streams.h>
-
-// DbgLog values (all on LOG_TIMING):
-//
-// 2 for schedulting, firing and shunting of events
-// 3 for wait delays and wake-up times of event thread
-// 4 for details of whats on the list when the thread awakes
-
-/* Construct & destructors */
-
-CAMSchedule::CAMSchedule( HANDLE ev )
-: CBaseObject(TEXT("CAMSchedule"))
-, head(&z, 0), z(0, MAX_TIME)
-, m_dwNextCookie(0), m_dwAdviseCount(0)
-, m_pAdviseCache(0), m_dwCacheCount(0)
-, m_ev( ev )
-{
-    head.m_dwAdviseCookie = z.m_dwAdviseCookie = 0;
-}
-
-CAMSchedule::~CAMSchedule()
-{
-    m_Serialize.Lock();
-
-    // Delete cache
-    CAdvisePacket * p = m_pAdviseCache;
-    while (p)
-    {
-        CAdvisePacket *const p_next = p->m_next;
-        delete p;
-        p = p_next;
-    }
-
-    ASSERT( m_dwAdviseCount == 0 );
-    // Better to be safe than sorry
-    if ( m_dwAdviseCount > 0 )
-    {
-        DumpLinkedList();
-        while ( !head.m_next->IsZ() )
-        {
-            head.DeleteNext();
-            --m_dwAdviseCount;
-        }
-    }
-
-    // If, in the debug version, we assert twice, it means, not only
-    // did we have left over advises, but we have also let m_dwAdviseCount
-    // get out of sync. with the number of advises actually on the list.
-    ASSERT( m_dwAdviseCount == 0 );
-
-    m_Serialize.Unlock();
-}
-
-/* Public methods */
-
-DWORD CAMSchedule::GetAdviseCount()
-{
-    // No need to lock, m_dwAdviseCount is 32bits & declared volatile
-    return m_dwAdviseCount;
-}
-
-REFERENCE_TIME CAMSchedule::GetNextAdviseTime()
-{
-    CAutoLock lck(&m_Serialize); // Need to stop the linked list from changing
-    return head.m_next->m_rtEventTime;
-}
-
-DWORD_PTR CAMSchedule::AddAdvisePacket
-( const REFERENCE_TIME & time1
-, const REFERENCE_TIME & time2
-, HANDLE h, BOOL periodic
-)
-{
-    // Since we use MAX_TIME as a sentry, we can't afford to
-    // schedule a notification at MAX_TIME
-    ASSERT( time1 < MAX_TIME );
-    DWORD_PTR Result;
-    CAdvisePacket * p;
-
-    m_Serialize.Lock();
-
-    if (m_pAdviseCache)
-    {
-        p = m_pAdviseCache;
-        m_pAdviseCache = p->m_next;
-        --m_dwCacheCount;
-    }
-    else
-    {
-        p = new CAdvisePacket();
-    }
-    if (p)
-    {
-        p->m_rtEventTime = time1; p->m_rtPeriod = time2;
-        p->m_hNotify = h; p->m_bPeriodic = periodic;
-        Result = AddAdvisePacket( p );
-    }
-    else Result = 0;
-
-    m_Serialize.Unlock();
-
-    return Result;
-}
-
-HRESULT CAMSchedule::Unadvise(DWORD_PTR dwAdviseCookie)
-{
-    HRESULT hr = S_FALSE;
-    CAdvisePacket * p_prev = &head;
-    CAdvisePacket * p_n;
-    m_Serialize.Lock();
-    while ( p_n = p_prev->Next() ) // The Next() method returns NULL when it hits z
-    {
-        if ( p_n->m_dwAdviseCookie == dwAdviseCookie )
-        {
-            Delete( p_prev->RemoveNext() );
-            --m_dwAdviseCount;
-            hr = S_OK;
-	    // Having found one cookie that matches, there should be no more
-            #ifdef DEBUG
-	       while (p_n = p_prev->Next())
-               {
-                   ASSERT(p_n->m_dwAdviseCookie != dwAdviseCookie);
-                   p_prev = p_n;
-               }
-            #endif
-            break;
-        }
-        p_prev = p_n;
-    };
-    m_Serialize.Unlock();
-    return hr;
-}
-
-REFERENCE_TIME CAMSchedule::Advise( const REFERENCE_TIME & rtTime )
-{
-    REFERENCE_TIME  rtNextTime;
-    CAdvisePacket * pAdvise;
-
-    DbgLog((LOG_TIMING, 2,
-        TEXT("CAMSchedule::Advise( %lu ms )"), ULONG(rtTime / (UNITS / MILLISECONDS))));
-
-    CAutoLock lck(&m_Serialize);
-
-    #ifdef DEBUG
-        if (DbgCheckModuleLevel(LOG_TIMING, 4)) DumpLinkedList();
-    #endif
-
-    //  Note - DON'T cache the difference, it might overflow
-    while ( rtTime >= (rtNextTime = (pAdvise=head.m_next)->m_rtEventTime) &&
-            !pAdvise->IsZ() )
-    {
-        ASSERT(pAdvise->m_dwAdviseCookie); // If this is zero, its the head or the tail!!
-
-        ASSERT(pAdvise->m_hNotify != INVALID_HANDLE_VALUE);
-
-        if (pAdvise->m_bPeriodic == TRUE)
-        {
-            ReleaseSemaphore(pAdvise->m_hNotify,1,NULL);
-            pAdvise->m_rtEventTime += pAdvise->m_rtPeriod;
-            ShuntHead();
-        }
-        else
-        {
-            ASSERT( pAdvise->m_bPeriodic == FALSE );
-            EXECUTE_ASSERT(SetEvent(pAdvise->m_hNotify));
-            --m_dwAdviseCount;
-            Delete( head.RemoveNext() );
-        }
-
-    }
-
-    DbgLog((LOG_TIMING, 3,
-            TEXT("CAMSchedule::Advise() Next time stamp: %lu ms, for advise %lu."),
-            DWORD(rtNextTime / (UNITS / MILLISECONDS)), pAdvise->m_dwAdviseCookie ));
-
-    return rtNextTime;
-}
-
-/* Private methods */
-
-DWORD_PTR CAMSchedule::AddAdvisePacket( __inout CAdvisePacket * pPacket )
-{
-    ASSERT(pPacket->m_rtEventTime >= 0 && pPacket->m_rtEventTime < MAX_TIME);
-    ASSERT(CritCheckIn(&m_Serialize));
-
-    CAdvisePacket * p_prev = &head;
-    CAdvisePacket * p_n;
-
-    const DWORD_PTR Result = pPacket->m_dwAdviseCookie = ++m_dwNextCookie;
-    // This relies on the fact that z is a sentry with a maximal m_rtEventTime
-    for(;;p_prev = p_n)
-    {
-        p_n = p_prev->m_next;
-        if ( p_n->m_rtEventTime >= pPacket->m_rtEventTime ) break;
-    }
-    p_prev->InsertAfter( pPacket );
-    ++m_dwAdviseCount;
-
-    DbgLog((LOG_TIMING, 2, TEXT("Added advise %lu, for thread 0x%02X, scheduled at %lu"),
-    	pPacket->m_dwAdviseCookie, GetCurrentThreadId(), (pPacket->m_rtEventTime / (UNITS / MILLISECONDS)) ));
-
-    // If packet added at the head, then clock needs to re-evaluate wait time.
-    if ( p_prev == &head ) SetEvent( m_ev );
-
-    return Result;
-}
-
-void CAMSchedule::Delete( __inout CAdvisePacket * pPacket )
-{
-    if ( m_dwCacheCount >= dwCacheMax ) delete pPacket;
-    else
-    {
-        m_Serialize.Lock();
-        pPacket->m_next = m_pAdviseCache;
-        m_pAdviseCache = pPacket;
-        ++m_dwCacheCount;
-        m_Serialize.Unlock();
-    }
-}
-
-
-// Takes the head of the list & repositions it
-void CAMSchedule::ShuntHead()
-{
-    CAdvisePacket * p_prev = &head;
-    CAdvisePacket * p_n;
-
-    m_Serialize.Lock();
-    CAdvisePacket *const pPacket = head.m_next;
-
-    // This will catch both an empty list,
-    // and if somehow a MAX_TIME time gets into the list
-    // (which would also break this method).
-    ASSERT( pPacket->m_rtEventTime < MAX_TIME );
-
-    // This relies on the fact that z is a sentry with a maximal m_rtEventTime
-    for(;;p_prev = p_n)
-    {
-        p_n = p_prev->m_next;
-        if ( p_n->m_rtEventTime > pPacket->m_rtEventTime ) break;
-    }
-    // If p_prev == pPacket then we're already in the right place
-    if (p_prev != pPacket)
-    {
-        head.m_next = pPacket->m_next;
-        (p_prev->m_next = pPacket)->m_next = p_n;
-    }
-    #ifdef DEBUG
-        DbgLog((LOG_TIMING, 2, TEXT("Periodic advise %lu, shunted to %lu"),
-    	    pPacket->m_dwAdviseCookie, (pPacket->m_rtEventTime / (UNITS / MILLISECONDS)) ));
-    #endif
-    m_Serialize.Unlock();
-}
-
-
-#ifdef DEBUG
-void CAMSchedule::DumpLinkedList()
-{
-    m_Serialize.Lock();
-    int i=0;
-    DbgLog((LOG_TIMING, 1, TEXT("CAMSchedule::DumpLinkedList() this = 0x%p"), this));
-    for ( CAdvisePacket * p = &head
-        ; p
-        ; p = p->m_next         , i++
-        )
-    {
-        DbgLog((LOG_TIMING, 1, TEXT("Advise List # %lu, Cookie %d,  RefTime %lu"),
-            i,
-	    p->m_dwAdviseCookie,
-	    p->m_rtEventTime / (UNITS / MILLISECONDS)
-            ));
-    }
-    m_Serialize.Unlock();
-}
-#endif

3rdparty/baseclasses/schedule.h

@@ -1,128 +0,0 @@
-//------------------------------------------------------------------------------
-// File: Schedule.h
-//
-// Desc: DirectShow base classes.
-//
-// Copyright (c) 1996-2001 Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------------------------
-
-
-#ifndef __CAMSchedule__
-#define __CAMSchedule__
-
-class CAMSchedule : private CBaseObject
-{
-public:
-    virtual ~CAMSchedule();
-    // ev is the event we should fire if the advise time needs re-evaluating
-    CAMSchedule( HANDLE ev );
-
-    DWORD GetAdviseCount();
-    REFERENCE_TIME GetNextAdviseTime();
-
-    // We need a method for derived classes to add advise packets, we return the cookie
-    DWORD_PTR AddAdvisePacket( const REFERENCE_TIME & time1, const REFERENCE_TIME & time2, HANDLE h, BOOL periodic );
-    // And a way to cancel
-    HRESULT Unadvise(DWORD_PTR dwAdviseCookie);
-
-    // Tell us the time please, and we'll dispatch the expired events.  We return the time of the next event.
-    // NB: The time returned will be "useless" if you start adding extra Advises.  But that's the problem of
-    // whoever is using this helper class (typically a clock).
-    REFERENCE_TIME Advise( const REFERENCE_TIME & rtTime );
-
-    // Get the event handle which will be set if advise time requires re-evaluation.
-    HANDLE GetEvent() const { return m_ev; }
-
-private:
-    // We define the nodes that will be used in our singly linked list
-    // of advise packets.  The list is ordered by time, with the
-    // elements that will expire first at the front.
-    class CAdvisePacket
-    {
-    public:
-        CAdvisePacket()
-        {}
-
-        CAdvisePacket * m_next;
-        DWORD_PTR       m_dwAdviseCookie;
-        REFERENCE_TIME  m_rtEventTime;      // Time at which event should be set
-        REFERENCE_TIME  m_rtPeriod;         // Periodic time
-        HANDLE          m_hNotify;          // Handle to event or semephore
-        BOOL            m_bPeriodic;        // TRUE => Periodic event
-
-        CAdvisePacket( __inout_opt CAdvisePacket * next, LONGLONG time ) : m_next(next), m_rtEventTime(time)
-        {}
-
-        void InsertAfter( __inout CAdvisePacket * p )
-        {
-            p->m_next = m_next;
-            m_next    = p;
-        }
-
-        int IsZ() const // That is, is it the node that represents the end of the list
-        { return m_next == 0; }
-
-        CAdvisePacket * RemoveNext()
-        {
-            CAdvisePacket *const next = m_next;
-            CAdvisePacket *const new_next = next->m_next;
-            m_next = new_next;
-            return next;
-        }
-
-        void DeleteNext()
-        {
-            delete RemoveNext();
-        }
-
-        CAdvisePacket * Next() const
-        {
-            CAdvisePacket * result = m_next;
-            if (result->IsZ()) result = 0;
-            return result;
-        }
-
-        DWORD_PTR Cookie() const
-        { return m_dwAdviseCookie; }
-    };
-
-    // Structure is:
-    // head -> elmt1 -> elmt2 -> z -> null
-    // So an empty list is:       head -> z -> null
-    // Having head & z as links makes insertaion,
-    // deletion and shunting much easier.
-    CAdvisePacket   head, z;            // z is both a tail and a sentry
-
-    volatile DWORD_PTR  m_dwNextCookie;     // Strictly increasing
-    volatile DWORD  m_dwAdviseCount;    // Number of elements on list
-
-    CCritSec        m_Serialize;
-
-    // AddAdvisePacket: adds the packet, returns the cookie (0 if failed)
-    DWORD_PTR AddAdvisePacket( __inout CAdvisePacket * pPacket );
-    // Event that we should set if the packed added above will be the next to fire.
-    const HANDLE m_ev;
-
-    // A Shunt is where we have changed the first element in the
-    // list and want it re-evaluating (i.e. repositioned) in
-    // the list.
-    void ShuntHead();
-
-    // Rather than delete advise packets, we cache them for future use
-    CAdvisePacket * m_pAdviseCache;
-    DWORD           m_dwCacheCount;
-    enum { dwCacheMax = 5 };             // Don't bother caching more than five
-
-    void Delete( __inout CAdvisePacket * pLink );// This "Delete" will cache the Link
-
-// Attributes and methods for debugging
-public:
-#ifdef DEBUG
-    void DumpLinkedList();
-#else
-    void DumpLinkedList() {}
-#endif
-
-};
-
-#endif // __CAMSchedule__