[feat] github actions support linux aarch64 platform

.github/workflows/build.yaml

@@ -0,0 +1,343 @@
+name: Build and Release CrossDesk
+
+on:
+  push:
+    branches:
+      - "**"
+    tags:
+      - "*"
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+env:
+  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+jobs:
+  # Linux x86_64
+  build-linux-x86_64:
+    name: Build on Ubuntu 22.04 x86_64
+    runs-on: ubuntu-22.04
+    container:
+      image: crossdesk/ubuntu22.04:latest
+      options: --user root
+    steps:
+      - name: Extract version number
+        id: version
+        run: |
+          VERSION="${GITHUB_REF##*/}"
+          VERSION_NUM="${VERSION#v}"
+          echo "VERSION_NUM=${VERSION_NUM}" >> $GITHUB_ENV
+
+      - name: Set legal Debian version
+        shell: bash
+        id: set_deb_version
+        run: |
+          if [[ ! "${VERSION_NUM}" =~ ^[0-9] ]]; then
+            LEGAL_VERSION="0.0.0-${VERSION_NUM}"
+          else
+            LEGAL_VERSION="${VERSION_NUM}"
+          fi
+          echo "LEGAL_VERSION=${LEGAL_VERSION}" >> $GITHUB_ENV
+
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Build CrossDesk
+        env:
+          CUDA_PATH: /usr/local/cuda
+          XMAKE_GLOBALDIR: /data
+        run: |
+          ls -la $XMAKE_GLOBALDIR
+          xmake b -vy --root crossdesk
+
+      - name: Decode and save certificate
+        shell: bash
+        run: |
+          mkdir -p certs
+          echo "${{ secrets.CROSSDESK_CERT_BASE64 }}" | base64 --decode > certs/crossdesk.cn_root.crt
+
+      - name: Package
+        run: |
+          chmod +x ./scripts/linux/pkg_x86_64.sh
+          ./scripts/linux/pkg_x86_64.sh ${LEGAL_VERSION}
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: crossdesk-linux-x86_64-${{ env.LEGAL_VERSION }}
+          path: ${{ github.workspace }}/crossdesk-linux-x86_64-${{ env.LEGAL_VERSION }}.deb
+
+  # Linux arm64
+  build-linux-arm64:
+    name: Build on Ubuntu 22.04 arm64
+    runs-on: ubuntu-22.04-arm
+    strategy:
+      matrix:
+        include:
+          - arch: arm64
+            image: crossdesk/ubuntu20.04-arm64v8:latest
+            package_script: ./scripts/linux/pkg_arm64.sh
+    container:
+      image: ${{ matrix.image }}
+      options: --user root
+    steps:
+      - name: Extract version number
+        id: version
+        run: |
+          VERSION="${GITHUB_REF##*/}"
+          VERSION_NUM="${VERSION#v}"
+          echo "VERSION_NUM=${VERSION_NUM}" >> $GITHUB_ENV
+
+      - name: Set legal Debian version
+        shell: bash
+        id: set_deb_version
+        run: |
+          if [[ ! "${VERSION_NUM}" =~ ^[0-9] ]]; then
+            LEGAL_VERSION="0.0.0-${VERSION_NUM}"
+          else
+            LEGAL_VERSION="${VERSION_NUM}"
+          fi
+          echo "LEGAL_VERSION=${LEGAL_VERSION}" >> $GITHUB_ENV
+
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Build CrossDesk
+        env:
+          CUDA_PATH: /usr/local/cuda
+          XMAKE_GLOBALDIR: /data
+        run: |
+          xmake b -vy --root crossdesk
+
+      - name: Decode and save certificate
+        shell: bash
+        run: |
+          mkdir -p certs
+          echo "${{ secrets.CROSSDESK_CERT_BASE64 }}" | base64 --decode > certs/crossdesk.cn_root.crt
+
+      - name: Package
+        run: |
+          chmod +x ${{ matrix.package_script }}
+          ${{ matrix.package_script }} ${LEGAL_VERSION}
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: crossdesk-linux-${{ matrix.arch }}-${{ env.LEGAL_VERSION }}
+          path: ${{ github.workspace }}/crossdesk-linux-${{ matrix.arch }}-${{ env.LEGAL_VERSION }}.deb
+
+  # macOS
+  build-macos:
+    name: Build on macOS
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      matrix:
+        include:
+          - arch: x86_64
+            runner: macos-13
+            cache-key: intel
+            out-dir: ./build/macosx/x86_64/release/crossdesk
+            package_script: ./scripts/macosx/pkg_x86_64.sh
+          - arch: arm64
+            runner: macos-14
+            cache-key: arm
+            out-dir: ./build/macosx/arm64/release/crossdesk
+            package_script: ./scripts/macosx/pkg_arm64.sh
+
+    steps:
+      - name: Extract version number
+        id: version
+        run: |
+          VERSION="${GITHUB_REF##*/}"
+          VERSION_NUM="${VERSION#v}"
+          echo "VERSION_NUM=${VERSION_NUM}" >> $GITHUB_ENV
+          echo "VERSION_NUM=${VERSION_NUM}"
+
+      - name: Cache xmake dependencies
+        uses: actions/cache@v4
+        with:
+          path: ~/.xmake/packages
+          key: ${{ runner.os }}-xmake-deps-${{ matrix.cache-key }}-${{ hashFiles('**/xmake.lua') }}
+          restore-keys: |
+            ${{ runner.os }}-xmake-deps-${{ matrix.cache-key }}-
+
+      - name: Install xmake
+        run: brew install xmake
+
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Initialize submodules
+        run: git submodule update --init --recursive
+
+      - name: Build CrossDesk
+        run: xmake b -vy crossdesk
+
+      - name: Decode and save certificate
+        shell: bash
+        run: |
+          mkdir -p certs
+          echo "${{ secrets.CROSSDESK_CERT_BASE64 }}" | base64 --decode > certs/crossdesk.cn_root.crt
+
+      - name: Package CrossDesk app
+        run: |
+          chmod +x ${{ matrix.package_script }}
+          ${{ matrix.package_script }} ${VERSION_NUM}
+
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: crossdesk-macos-${{ matrix.arch }}-${{ env.VERSION_NUM }}
+          path: crossdesk-macos-${{ matrix.arch }}-${{ env.VERSION_NUM }}.pkg
+
+      - name: Move files to release dir
+        run: |
+          mkdir -p release
+          cp crossdesk-macos-${{ matrix.arch }}-${{ env.VERSION_NUM }}.pkg release/
+
+  # Windows
+  build-windows:
+    name: Build on Windows
+    runs-on: windows-2022
+    env:
+      XMAKE_GLOBALDIR: D:\xmake_global
+    steps:
+      - name: Extract version number
+        shell: pwsh
+        run: |
+          $ref = $env:GITHUB_REF
+          $version = $ref -replace '^refs/(tags|heads)/', ''
+          $version = $version -replace '^v', ''
+          $version = $version -replace '/', '-'
+          echo "VERSION_NUM=$version" >> $env:GITHUB_ENV
+
+      - name: Cache xmake dependencies
+        uses: actions/cache@v4
+        with:
+          path: D:\xmake_global\.xmake\packages
+          key: ${{ runner.os }}-xmake-deps-intel-${{ hashFiles('**/xmake.lua') }}
+          restore-keys: |
+            ${{ runner.os }}-xmake-deps-intel-
+
+      - name: Install xmake
+        run: |
+          Invoke-Expression (Invoke-Webrequest 'https://raw.githubusercontent.com/tboox/xmake/master/scripts/get.ps1' -UseBasicParsing).Content
+          echo "C:\Users\runneradmin\xmake" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          xmake create cuda
+          Set-Location cuda
+          xmake g --theme=plain
+          $cudaPath = ""
+          $packagesPath = "D:\xmake_global\.xmake\packages"
+
+          if (Test-Path $packagesPath) {
+              Write-Host "Packages directory exists: $packagesPath"
+              try {
+                  $info = xmake require --info "cuda 12.6.3" 2>$null
+                  if ($null -ne $info -and $info -ne "") {
+                      $cudaPath = (($info | Select-String installdir).ToString() -replace '.*installdir:\s*','').Trim()
+                  }
+              } catch {}
+          } else {
+              Write-Host "Packages directory not found: $packagesPath"
+              Write-Host "Installing CUDA package..."
+              xmake require -vy "cuda 12.6.3"
+              $info = xmake require --info "cuda 12.6.3"
+              $cudaPath = (($info | Select-String installdir).ToString() -replace '.*installdir:\s*','').Trim()
+          }
+
+          echo "CUDA_PATH=$cudaPath" >> $env:GITHUB_ENV
+          Write-Host "Resolved CUDA_PATH = $cudaPath"
+          Pop-Location
+
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Initialize submodules
+        run: git submodule update --init --recursive
+
+      - name: Build CrossDesk
+        run: xmake b -vy crossdesk
+
+      - name: Decode and save certificate
+        shell: powershell
+        run: |
+          New-Item -ItemType Directory -Force -Path certs
+          [System.IO.File]::WriteAllBytes('certs\crossdesk.cn_root.crt', [Convert]::FromBase64String('${{ secrets.CROSSDESK_CERT_BASE64 }}'))
+
+      - name: Package
+        shell: pwsh
+        run: |
+          cd "${{ github.workspace }}\scripts\windows"
+          makensis /DVERSION=$env:VERSION_NUM nsis_script.nsi
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: crossdesk-win-x86_64-${{ env.VERSION_NUM }}
+          path: ${{ github.workspace }}/scripts/windows/crossdesk-win-x86_64-${{ env.VERSION_NUM }}.exe
+
+  release:
+    name: Publish Release
+    if: startsWith(github.ref, 'refs/tags/v')
+    needs: [build-linux-x86_64, build-linux-arm64, build-macos, build-windows]
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts
+
+      - name: Extract version number
+        id: version
+        run: |
+          VERSION="${GITHUB_REF##*/}"
+          VERSION_NUM="${VERSION#v}"
+          echo "VERSION_NUM=${VERSION_NUM}" >> $GITHUB_OUTPUT
+
+      - name: Rename artifacts
+        run: |
+          mkdir -p release
+          cp artifacts/crossdesk-macos-x86_64-${{ steps.version.outputs.VERSION_NUM }}/* release/crossdesk-macos-x86_64-${{ steps.version.outputs.VERSION_NUM }}.pkg
+          cp artifacts/crossdesk-macos-arm64-${{ steps.version.outputs.VERSION_NUM }}/* release/crossdesk-macos-arm64-${{ steps.version.outputs.VERSION_NUM }}.pkg
+          cp artifacts/crossdesk-linux-x86_64-${{ steps.version.outputs.VERSION_NUM }}/* release/crossdesk-linux-x86_64-${{ steps.version.outputs.VERSION_NUM }}.deb
+          cp artifacts/crossdesk-linux-arm64-${{ steps.version.outputs.VERSION_NUM }}/* release/crossdesk-linux-arm64-${{ steps.version.outputs.VERSION_NUM }}.deb
+          cp artifacts/crossdesk-win-x86_64-${{ steps.version.outputs.VERSION_NUM }}/* release/crossdesk-win-x86_64-${{ steps.version.outputs.VERSION_NUM }}.exe
+
+      - name: Upload to Versioned GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: v${{ steps.version.outputs.VERSION_NUM }}
+          name: Release v${{ steps.version.outputs.VERSION_NUM }}
+          draft: false
+          prerelease: false
+          files: release/*
+          generate_release_notes: false
+          body: |
+            Binary release only. Source code is not included.
+
+      - name: Create or update 'latest' tag
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git tag -f latest
+          git push origin latest --force
+
+      - name: Upload to GitHub Release (latest)
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: latest
+          name: Latest Release
+          draft: false
+          prerelease: false
+          files: release/*
+          generate_release_notes: false

.github/workflows/update-pages.yaml

@@ -0,0 +1,48 @@
+name: Update GitHub Pages Downloads
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  update-pages:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout CrossDesk repo
+        uses: actions/checkout@v4
+
+      - name: Set version number
+        id: version
+        run: |
+          VERSION_NUM="${GITHUB_REF##*/}"
+          VERSION_NUM="${VERSION_NUM#v}"
+          echo "VERSION_NUM=${VERSION_NUM}" >> $GITHUB_ENV
+          echo "VERSION_NUM=${VERSION_NUM}" >> $GITHUB_OUTPUT
+
+      - name: Checkout Pages repo
+        uses: actions/checkout@v4
+        with:
+          repository: kunkundi/kunkundi.github.io
+          token: ${{ secrets.GH_PAGES_PAT }}
+          path: pages
+
+      - name: Update download links
+        run: |
+          cd pages
+          sed -E -i "s/crossdesk-win-x86_64-[0-9]+\.[0-9]+\.[0-9]+\.exe/crossdesk-win-x86_64-${VERSION_NUM}.exe/g" index.html
+          sed -E -i "s/crossdesk-macos-x86_64-[0-9]+\.[0-9]+\.[0-9]+\.pkg/crossdesk-macos-x86_64-${VERSION_NUM}.pkg/g" index.html
+          sed -E -i "s/crossdesk-macos-arm64-[0-9]+\.[0-9]+\.[0-9]+\.pkg/crossdesk-macos-arm64-${VERSION_NUM}.pkg/g" index.html
+          sed -E -i "s/crossdesk-linux-x86_64-[0-9]+\.[0-9]+\.[0-9]+\.deb/crossdesk-linux-x86_64-${VERSION_NUM}.deb/g" index.html
+          sed -E -i "s/crossdesk-linux-arm64-[0-9]+\.[0-9]+\.[0-9]+\.deb/crossdesk-linux-arm64-${VERSION_NUM}.deb/g" index.html
+
+      - name: Commit & Push changes
+        run: |
+          cd pages
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add index.html
+          git commit -m "Update download links to v${VERSION_NUM}" || echo "No changes to commit"
+          git push origin main
+        env:
+          VERSION_NUM: ${{ env.VERSION_NUM }}

.gitmodules

@@ -1,3 +1,3 @@
-[submodule "thirdparty/projectx"]
-	path = thirdparty/projectx
-	url = https://github.com/dijunkun/projectx.git
+[submodule "thirdparty/minirtc"]
+	path = thirdparty/minirtc
+	url = https://github.com/kunkundi/minirtc.git

Info.plist

@@ -1,39 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <!-- 应用的Bundle identifier，通常使用反向域名标记 -->
-    <key>CFBundleIdentifier</key>
-    <string>com.yourcompany.yourappname</string>
-
-    <!-- 应用的显示名称 -->
-    <key>CFBundleName</key>
-    <string>Your App Name</string>
-
-    <!-- 应用的版本号 -->
-    <key>CFBundleShortVersionString</key>
-    <string>1.0.0</string>
-
-    <!-- 应用的构建版本号 -->
-    <key>CFBundleVersion</key>
-    <string>1</string>
-
-    <!-- 请求麦克风访问权限 -->
-    <key>NSMicrophoneUsageDescription</key>
-    <string>App requires access to the microphone for audio recording.</string>
-
-    <!-- 请求相机访问权限 -->
-    <key>NSCameraUsageDescription</key>
-    <string>App requires access to the camera for video recording.</string>
-
-    <!-- 请求使用连续相机设备 -->
-    <key>NSCameraUseContinuityCameraDeviceType</key>
-    <string>Your usage description here</string>
-
-    <!-- High DPI -->>
-    <key>NSHighResolutionCapable</key>
-    <true/>
-
-    <!-- 其他权限和配置可以在这里添加 -->
-</dict>
-</plist>

README.md

@@ -1,4 +1,4 @@
-# Continuous Desk
+# CrossDesk
 
 #### More than remote desktop
 
@@ -9,9 +9,9 @@
 
 # Intro
 
-Continuous Desk is a lightweight cross-platform remote desktop. It allows multiple users to remotely control the same computer at the same time. In addition to desktop image transmission, it also supports end-to-end voice transmission, providing collaboration capabilities on the basis of remote desktop.
+CrossDesk is a lightweight cross-platform remote desktop. It allows multiple users to remotely control the same computer at the same time. In addition to desktop image transmission, it also supports end-to-end voice transmission, providing collaboration capabilities on the basis of remote desktop.
 
-Continuous Desk is an experimental application of [Projectx](https://github.com/dijunkun/projectx) real-time communications library. Projectx is a lightweight cross-platform real-time communications library. It has basic capabilities such as network traversal ([RFC5245](https://datatracker.ietf.org/doc/html/rfc5245)), video software/hardware encoding/decoding (H264), audio encoding/decoding ([Opus](https://github.com/xiph/opus)), signaling interaction, and network congestion control ([TCP over UDP](https://libnice.freedesktop.org/)).
+CrossDesk is an experimental application of [Projectx](https://github.com/dijunkun/projectx) real-time communications library. Projectx is a lightweight cross-platform real-time communications library. It has basic capabilities such as network traversal ([RFC5245](https://datatracker.ietf.org/doc/html/rfc5245)), video software/hardware encoding/decoding (H264), audio encoding/decoding ([Opus](https://github.com/xiph/opus)), signaling interaction, and network congestion control ([TCP over UDP](https://libnice.freedesktop.org/)).
 
 ## Usage
 

config/config.ini

@@ -1,19 +0,0 @@
-[signal server]
-ip = 150.158.81.30
-port = 9099
-
-[stun server]
-ip = 150.158.81.30
-port = 3478
-
-[turn server]
-ip = 150.158.81.30
-port = 3478
-username = dijunkun
-password = dijunkunpw
-
-[hardware acceleration]
-turn_on = false
-
-[av1 encoding]
-turn_on = true

scripts/linux/pkg_arm64.sh

@@ -0,0 +1,111 @@
+#!/bin/bash
+set -e
+
+APP_NAME="CrossDesk"
+APP_VERSION="$1"
+ARCHITECTURE="arm64"  # 改为 arm64
+MAINTAINER="Junkun Di <junkun.di@hotmail.com>"
+DESCRIPTION="A simple cross-platform remote desktop client."
+
+DEB_DIR="$APP_NAME-$APP_VERSION"
+DEBIAN_DIR="$DEB_DIR/DEBIAN"
+BIN_DIR="$DEB_DIR/usr/local/bin"
+CERT_SRC_DIR="$DEB_DIR/opt/$APP_NAME/certs"
+ICON_DIR="$DEB_DIR/usr/share/icons/hicolor/256x256/apps"
+DESKTOP_DIR="$DEB_DIR/usr/share/applications"
+
+rm -rf "$DEB_DIR"
+
+mkdir -p "$DEBIAN_DIR" "$BIN_DIR" "$CERT_SRC_DIR" "$ICON_DIR" "$DESKTOP_DIR"
+
+cp build/linux/arm64/release/crossdesk "$BIN_DIR"
+cp certs/crossdesk.cn_root.crt "$CERT_SRC_DIR/crossdesk.cn_root.crt"
+cp icons/crossdesk.png "$ICON_DIR/crossdesk.png"
+
+chmod +x "$BIN_DIR/crossdesk"
+
+cat > "$DEBIAN_DIR/control" << EOF
+Package: $APP_NAME
+Version: $APP_VERSION
+Architecture: $ARCHITECTURE
+Maintainer: $MAINTAINER
+Description: $DESCRIPTION
+Depends: libc6 (>= 2.29), libstdc++6 (>= 9), libx11-6, libxcb1,
+ libxcb-randr0, libxcb-xtest0, libxcb-xinerama0, libxcb-shape0,
+ libxcb-xkb1, libxcb-xfixes0, libxv1, libxtst6, libasound2,
+ libsndio7.0, libxcb-shm0, libpulse0
+Priority: optional
+Section: utils
+EOF
+
+cat > "$DESKTOP_DIR/$APP_NAME.desktop" << EOF
+[Desktop Entry]
+Version=$APP_VERSION
+Name=$APP_NAME
+Comment=$DESCRIPTION
+Exec=/usr/local/bin/crossdesk
+Icon=crossdesk
+Terminal=false
+Type=Application
+Categories=Utility;
+EOF
+
+cat > "$DEBIAN_DIR/postrm" << EOF
+#!/bin/bash
+# post-removal script for $APP_NAME
+
+set -e
+
+if [ "\$1" = "remove" ] || [ "\$1" = "purge" ]; then
+    rm -f /usr/local/bin/crossdesk
+    rm -f /usr/share/icons/hicolor/256x256/apps/crossdesk.png
+    rm -f /usr/share/applications/$APP_NAME.desktop
+    rm -rf /opt/$APP_NAME
+fi
+
+exit 0
+EOF
+
+chmod +x "$DEBIAN_DIR/postrm"
+
+cat > "$DEBIAN_DIR/postinst" << 'EOF'
+#!/bin/bash
+set -e
+
+CERT_SRC="/opt/CrossDesk/certs"
+CERT_FILE="crossdesk.cn_root.crt"
+
+for user_home in /home/*; do
+    [ -d "$user_home" ] || continue
+    username=$(basename "$user_home")
+    config_dir="$user_home/.config/CrossDesk/certs"
+    target="$config_dir/$CERT_FILE"
+
+    if [ ! -f "$target" ]; then
+        mkdir -p "$config_dir"
+        cp "$CERT_SRC/$CERT_FILE" "$target"
+        chown -R "$username:$username" "$user_home/.config/CrossDesk"
+        echo "✔ Installed cert for $username at $target"
+    fi
+done
+
+if [ -d "/root" ]; then
+    config_dir="/root/.config/CrossDesk/certs"
+    mkdir -p "$config_dir"
+    cp "$CERT_SRC/$CERT_FILE" "$config_dir/$CERT_FILE"
+    chown -R root:root /root/.config/CrossDesk
+fi
+
+exit 0
+EOF
+
+chmod +x "$DEBIAN_DIR/postinst"
+
+dpkg-deb --build "$DEB_DIR"
+
+OUTPUT_FILE="crossdesk-linux-arm64-$APP_VERSION.deb"
+mv "$DEB_DIR.deb" "$OUTPUT_FILE"
+
+rm -rf "$DEB_DIR"
+
+echo "✅ Deb package for $APP_NAME (ARM64) created successfully."

scripts/linux/pkg_x86_64.sh

@@ -0,0 +1,111 @@
+#!/bin/bash
+set -e
+
+APP_NAME="CrossDesk"
+APP_VERSION="$1"
+ARCHITECTURE="amd64"
+MAINTAINER="Junkun Di <junkun.di@hotmail.com>"
+DESCRIPTION="A simple cross-platform remote desktop client."
+
+DEB_DIR="$APP_NAME-$APP_VERSION"
+DEBIAN_DIR="$DEB_DIR/DEBIAN"
+BIN_DIR="$DEB_DIR/usr/local/bin"
+CERT_SRC_DIR="$DEB_DIR/opt/$APP_NAME/certs"  # 用于中转安装时分发
+ICON_DIR="$DEB_DIR/usr/share/icons/hicolor/256x256/apps"
+DESKTOP_DIR="$DEB_DIR/usr/share/applications"
+
+rm -rf "$DEB_DIR"
+
+mkdir -p "$DEBIAN_DIR" "$BIN_DIR" "$CERT_SRC_DIR" "$ICON_DIR" "$DESKTOP_DIR"
+
+cp build/linux/x86_64/release/crossdesk "$BIN_DIR"
+cp certs/crossdesk.cn_root.crt "$CERT_SRC_DIR/crossdesk.cn_root.crt"
+cp icons/crossdesk.png "$ICON_DIR/crossdesk.png"
+
+chmod +x "$BIN_DIR/crossdesk"
+
+cat > "$DEBIAN_DIR/control" << EOF
+Package: $APP_NAME
+Version: $APP_VERSION
+Architecture: $ARCHITECTURE
+Maintainer: $MAINTAINER
+Description: $DESCRIPTION
+Depends: libc6 (>= 2.29), libstdc++6 (>= 9), libx11-6, libxcb1,
+ libxcb-randr0, libxcb-xtest0, libxcb-xinerama0, libxcb-shape0,
+ libxcb-xkb1, libxcb-xfixes0, libxv1, libxtst6, libasound2,
+ libsndio7.0, libxcb-shm0, libpulse0, nvidia-cuda-toolkit
+Priority: optional
+Section: utils
+EOF
+
+cat > "$DESKTOP_DIR/$APP_NAME.desktop" << EOF
+[Desktop Entry]
+Version=$APP_VERSION
+Name=$APP_NAME
+Comment=$DESCRIPTION
+Exec=/usr/local/bin/crossdesk
+Icon=crossdesk
+Terminal=false
+Type=Application
+Categories=Utility;
+EOF
+
+cat > "$DEBIAN_DIR/postrm" << EOF
+#!/bin/bash
+# post-removal script for $APP_NAME
+
+set -e
+
+if [ "\$1" = "remove" ] || [ "\$1" = "purge" ]; then
+    rm -f /usr/local/bin/crossdesk
+    rm -f /usr/share/icons/hicolor/256x256/apps/crossdesk.png
+    rm -f /usr/share/applications/$APP_NAME.desktop
+    rm -rf /opt/$APP_NAME
+fi
+
+exit 0
+EOF
+
+chmod +x "$DEBIAN_DIR/postrm"
+
+cat > "$DEBIAN_DIR/postinst" << 'EOF'
+#!/bin/bash
+set -e
+
+CERT_SRC="/opt/CrossDesk/certs"
+CERT_FILE="crossdesk.cn_root.crt"
+
+for user_home in /home/*; do
+    [ -d "$user_home" ] || continue
+    username=$(basename "$user_home")
+    config_dir="$user_home/.config/CrossDesk/certs"
+    target="$config_dir/$CERT_FILE"
+
+    if [ ! -f "$target" ]; then
+        mkdir -p "$config_dir"
+        cp "$CERT_SRC/$CERT_FILE" "$target"
+        chown -R "$username:$username" "$user_home/.config/CrossDesk"
+        echo "✔ Installed cert for $username at $target"
+    fi
+done
+
+if [ -d "/root" ]; then
+    config_dir="/root/.config/CrossDesk/certs"
+    mkdir -p "$config_dir"
+    cp "$CERT_SRC/$CERT_FILE" "$config_dir/$CERT_FILE"
+    chown -R root:root /root/.config/CrossDesk
+fi
+
+exit 0
+EOF
+
+chmod +x "$DEBIAN_DIR/postinst"
+
+dpkg-deb --build "$DEB_DIR"
+
+OUTPUT_FILE="crossdesk-linux-x86_64-$APP_VERSION.deb"
+mv "$DEB_DIR.deb" "$OUTPUT_FILE"
+
+rm -rf "$DEB_DIR"
+
+echo "✅ Deb package for $APP_NAME created successfully."

scripts/macosx/pkg_arm64.sh

@@ -0,0 +1,152 @@
+#!/bin/bash
+set -e  # 遇错退出
+
+# === 配置变量 ===
+APP_NAME="crossdesk"
+APP_NAME_UPPER="CrossDesk"  # 这个变量用来指定大写的应用名
+EXECUTABLE_PATH="./build/macosx/arm64/release/crossdesk"             # 可执行文件路径
+APP_VERSION="$1"
+PLATFORM="macos"
+ARCH="arm64"
+IDENTIFIER="cn.crossdesk.app"
+ICON_PATH="./icons/crossdesk.icns"         # .icns 图标路径
+MACOS_MIN_VERSION="10.12"
+
+CERTS_SOURCE="./certs"                     # 你的证书文件目录，里面放所有需要安装的文件
+CERT_NAME="crossdesk.cn_root.crt"
+
+APP_BUNDLE="${APP_NAME_UPPER}.app"          # 使用大写的应用名称
+CONTENTS_DIR="${APP_BUNDLE}/Contents"
+MACOS_DIR="${CONTENTS_DIR}/MacOS"
+RESOURCES_DIR="${CONTENTS_DIR}/Resources"
+
+PKG_NAME="${APP_NAME}-${PLATFORM}-${ARCH}-${APP_VERSION}.pkg"  # 保持安装包名称小写
+DMG_NAME="${APP_NAME}-${PLATFORM}-${ARCH}-${APP_VERSION}.dmg"
+VOL_NAME="Install ${APP_NAME_UPPER}"
+
+# === 清理旧文件 ===
+echo "🧹 清理旧文件..."
+rm -rf "${APP_BUNDLE}" "${PKG_NAME}" "${DMG_NAME}" build_pkg_temp CrossDesk_dmg_temp
+
+mkdir -p build_pkg_temp
+
+# === 创建 .app 结构 ===
+echo "📦 创建 ${APP_BUNDLE}..."
+mkdir -p "${MACOS_DIR}" "${RESOURCES_DIR}"
+
+echo "🚚 拷贝可执行文件..."
+cp "${EXECUTABLE_PATH}" "${MACOS_DIR}/${APP_NAME_UPPER}"  # 拷贝时使用大写的应用名称
+chmod +x "${MACOS_DIR}/${APP_NAME_UPPER}"
+
+# === 图标 ===
+if [ -f "${ICON_PATH}" ]; then
+    cp "${ICON_PATH}" "${RESOURCES_DIR}/crossedesk.icns"
+    ICON_KEY="<key>CFBundleIconFile</key><string>crossedesk.icns</string>"
+    echo "🎨 图标添加完成"
+else
+    ICON_KEY=""
+    echo "⚠️ 未找到图标文件，跳过图标设置"
+fi
+
+# === 生成 Info.plist ===
+echo "📝 生成 Info.plist..."
+cat > "${CONTENTS_DIR}/Info.plist" <<EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleName</key>
+    <string>${APP_NAME_UPPER}</string>  <!-- 使用大写名称 -->
+    <key>CFBundleDisplayName</key>
+    <string>${APP_NAME_UPPER}</string>  <!-- 使用大写名称 -->
+    <key>CFBundleIdentifier</key>
+    <string>${IDENTIFIER}</string>
+    <key>CFBundleVersion</key>
+    <string>${APP_VERSION}</string>
+    <key>CFBundleShortVersionString</key>
+    <string>${APP_VERSION}</string>
+    <key>CFBundleExecutable</key>
+    <string>${APP_NAME_UPPER}</string>  <!-- 使用大写名称 -->
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+    ${ICON_KEY}
+    <key>LSMinimumSystemVersion</key>
+    <string>${MACOS_MIN_VERSION}</string>
+    <key>NSHighResolutionCapable</key>
+    <true/>
+    <key>NSCameraUsageDescription</key>
+    <string>应用需要访问摄像头</string>
+    <key>NSMicrophoneUsageDescription</key>
+    <string>应用需要访问麦克风</string>
+    <key>NSAppleEventsUsageDescription</key>
+    <string>应用需要发送 Apple 事件</string>
+    <key>NSScreenCaptureUsageDescription</key>
+    <string>应用需要录屏权限以捕获屏幕内容</string>
+</dict>
+</plist>
+EOF
+
+echo "✅ .app 创建完成"
+
+# === 构建应用组件包 ===
+echo "📦 构建应用组件包..."
+pkgbuild \
+  --identifier "${IDENTIFIER}" \
+  --version "${APP_VERSION}" \
+  --install-location "/Applications" \
+  --component "${APP_BUNDLE}" \
+  build_pkg_temp/${APP_NAME}-component.pkg
+
+# === 构建 certs 组件包 ===
+# 先创建脚本目录和脚本文件
+mkdir -p scripts
+
+cat > scripts/postinstall <<'EOF'
+#!/bin/bash
+USER_HOME=$( /usr/bin/stat -f "%Su" /dev/console )
+HOME_DIR=$( /usr/bin/dscl . -read /Users/$USER_HOME NFSHomeDirectory | awk '{print $2}' )
+
+DEST="$HOME_DIR/Library/Application Support/CrossDesk/certs"
+
+mkdir -p "$DEST"
+cp -R "/Library/Application Support/CrossDesk/certs/"* "$DEST/"
+
+exit 0
+EOF
+
+chmod +x scripts/postinstall
+
+# 构建 certs 组件包，增加 --scripts 参数指定 postinstall
+pkgbuild \
+  --root "${CERTS_SOURCE}" \
+  --identifier "${IDENTIFIER}.certs" \
+  --version "${APP_VERSION}" \
+  --install-location "/Library/Application Support/CrossDesk/certs" \
+  --scripts scripts \
+  build_pkg_temp/${APP_NAME}-certs.pkg
+
+# === 组合产品包 ===
+echo "🏗️ 组合最终安装包..."
+productbuild \
+  --package build_pkg_temp/${APP_NAME}-component.pkg \
+  --package build_pkg_temp/${APP_NAME}-certs.pkg \
+  "${PKG_NAME}"
+
+echo "✅ 生成安装包完成：${PKG_NAME}"
+
+# === 可选：打包成 DMG ===
+# echo "📦 可选打包成 DMG..."
+# mkdir -p CrossDesk_dmg_temp
+# cp "${PKG_NAME}" CrossDesk_dmg_temp/
+# ln -s /Applications CrossDesk_dmg_temp/Applications
+
+# hdiutil create -volname "${VOL_NAME}" \
+#   -srcfolder CrossDesk_dmg_temp \
+#   -ov -format UDZO "${DMG_NAME}"
+
+rm -rf build_pkg_temp scripts ${APP_BUNDLE}
+
+echo "🎉 所有打包完成："
+echo "   ✔️ 应用：${APP_BUNDLE}"
+echo "   ✔️ 安装包：${PKG_NAME}"
+# echo "   ✔️ 镜像包（可选）：${DMG_NAME}"

scripts/macosx/pkg_x86_64.sh

@@ -0,0 +1,152 @@
+#!/bin/bash
+set -e  # 遇错退出
+
+# === 配置变量 ===
+APP_NAME="crossdesk"
+APP_NAME_UPPER="CrossDesk"  # 这个变量用来指定大写的应用名
+EXECUTABLE_PATH="build/macosx/x86_64/release/crossdesk"             # 可执行文件路径
+APP_VERSION="$1"
+PLATFORM="macos"
+ARCH="x86_64"
+IDENTIFIER="cn.crossdesk.app"
+ICON_PATH="icons/crossdesk.icns"         # .icns 图标路径
+MACOS_MIN_VERSION="10.12"
+
+CERTS_SOURCE="certs"                     # 你的证书文件目录，里面放所有需要安装的文件
+CERT_NAME="crossdesk.cn_root.crt"
+
+APP_BUNDLE="${APP_NAME_UPPER}.app"          # 使用大写的应用名称
+CONTENTS_DIR="${APP_BUNDLE}/Contents"
+MACOS_DIR="${CONTENTS_DIR}/MacOS"
+RESOURCES_DIR="${CONTENTS_DIR}/Resources"
+
+PKG_NAME="${APP_NAME}-${PLATFORM}-${ARCH}-${APP_VERSION}.pkg"  # 保持安装包名称小写
+DMG_NAME="${APP_NAME}-${PLATFORM}-${ARCH}-${APP_VERSION}.dmg"
+VOL_NAME="Install ${APP_NAME_UPPER}"
+
+# === 清理旧文件 ===
+echo "🧹 清理旧文件..."
+rm -rf "${APP_BUNDLE}" "${PKG_NAME}" "${DMG_NAME}" build_pkg_temp CrossDesk_dmg_temp
+
+mkdir -p build_pkg_temp
+
+# === 创建 .app 结构 ===
+echo "📦 创建 ${APP_BUNDLE}..."
+mkdir -p "${MACOS_DIR}" "${RESOURCES_DIR}"
+
+echo "🚚 拷贝可执行文件..."
+cp "${EXECUTABLE_PATH}" "${MACOS_DIR}/${APP_NAME_UPPER}"  # 拷贝时使用大写的应用名称
+chmod +x "${MACOS_DIR}/${APP_NAME_UPPER}"
+
+# === 图标 ===
+if [ -f "${ICON_PATH}" ]; then
+    cp "${ICON_PATH}" "${RESOURCES_DIR}/crossedesk.icns"
+    ICON_KEY="<key>CFBundleIconFile</key><string>crossedesk.icns</string>"
+    echo "🎨 图标添加完成"
+else
+    ICON_KEY=""
+    echo "⚠️ 未找到图标文件，跳过图标设置"
+fi
+
+# === 生成 Info.plist ===
+echo "📝 生成 Info.plist..."
+cat > "${CONTENTS_DIR}/Info.plist" <<EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleName</key>
+    <string>${APP_NAME_UPPER}</string>  <!-- 使用大写名称 -->
+    <key>CFBundleDisplayName</key>
+    <string>${APP_NAME_UPPER}</string>  <!-- 使用大写名称 -->
+    <key>CFBundleIdentifier</key>
+    <string>${IDENTIFIER}</string>
+    <key>CFBundleVersion</key>
+    <string>${APP_VERSION}</string>
+    <key>CFBundleShortVersionString</key>
+    <string>${APP_VERSION}</string>
+    <key>CFBundleExecutable</key>
+    <string>${APP_NAME_UPPER}</string>  <!-- 使用大写名称 -->
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+    ${ICON_KEY}
+    <key>LSMinimumSystemVersion</key>
+    <string>${MACOS_MIN_VERSION}</string>
+    <key>NSHighResolutionCapable</key>
+    <true/>
+    <key>NSCameraUsageDescription</key>
+    <string>应用需要访问摄像头</string>
+    <key>NSMicrophoneUsageDescription</key>
+    <string>应用需要访问麦克风</string>
+    <key>NSAppleEventsUsageDescription</key>
+    <string>应用需要发送 Apple 事件</string>
+    <key>NSScreenCaptureUsageDescription</key>
+    <string>应用需要录屏权限以捕获屏幕内容</string>
+</dict>
+</plist>
+EOF
+
+echo "✅ .app 创建完成"
+
+# === 构建应用组件包 ===
+echo "📦 构建应用组件包..."
+pkgbuild \
+  --identifier "${IDENTIFIER}" \
+  --version "${APP_VERSION}" \
+  --install-location "/Applications" \
+  --component "${APP_BUNDLE}" \
+  build_pkg_temp/${APP_NAME}-component.pkg
+
+# === 构建 certs 组件包 ===
+# 先创建脚本目录和脚本文件
+mkdir -p scripts
+
+cat > scripts/postinstall <<'EOF'
+#!/bin/bash
+USER_HOME=$( /usr/bin/stat -f "%Su" /dev/console )
+HOME_DIR=$( /usr/bin/dscl . -read /Users/$USER_HOME NFSHomeDirectory | awk '{print $2}' )
+
+DEST="$HOME_DIR/Library/Application Support/CrossDesk/certs"
+
+mkdir -p "$DEST"
+cp -R "/Library/Application Support/CrossDesk/certs/"* "$DEST/"
+
+exit 0
+EOF
+
+chmod +x scripts/postinstall
+
+# 构建 certs 组件包，增加 --scripts 参数指定 postinstall
+pkgbuild \
+  --root "${CERTS_SOURCE}" \
+  --identifier "${IDENTIFIER}.certs" \
+  --version "${APP_VERSION}" \
+  --install-location "/Library/Application Support/CrossDesk/certs" \
+  --scripts scripts \
+  build_pkg_temp/${APP_NAME}-certs.pkg
+
+# === 组合产品包 ===
+echo "🏗️ 组合最终安装包..."
+productbuild \
+  --package build_pkg_temp/${APP_NAME}-component.pkg \
+  --package build_pkg_temp/${APP_NAME}-certs.pkg \
+  "${PKG_NAME}"
+
+echo "✅ 生成安装包完成：${PKG_NAME}"
+
+# === 可选：打包成 DMG ===
+# echo "📦 可选打包成 DMG..."
+# mkdir -p CrossDesk_dmg_temp
+# cp "${PKG_NAME}" CrossDesk_dmg_temp/
+# ln -s /Applications CrossDesk_dmg_temp/Applications
+
+# hdiutil create -volname "${VOL_NAME}" \
+#   -srcfolder CrossDesk_dmg_temp \
+#   -ov -format UDZO "${DMG_NAME}"
+
+rm -rf build_pkg_temp scripts ${APP_BUNDLE}
+
+echo "🎉 所有打包完成："
+echo "   ✔️ 应用：${APP_BUNDLE}"
+echo "   ✔️ 安装包：${PKG_NAME}"
+# echo "   ✔️ 镜像包（可选）：${DMG_NAME}"

scripts/windows/nsis_script.nsi

@@ -0,0 +1,102 @@
+; <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>·<EFBFBD><C2B7>
+!addincludedir "${__FILEDIR__}"
+
+; <20><>װ<EFBFBD><D7B0><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC><EFBFBD>峣<EFBFBD><E5B3A3>
+!define PRODUCT_NAME "CrossDesk"
+!define PRODUCT_VERSION "${VERSION}"
+!define PRODUCT_PUBLISHER "CrossDesk"
+!define PRODUCT_WEB_SITE "https://www.crossdesk.cn/"
+!define APP_NAME "CrossDesk"
+!define UNINSTALL_REG_KEY "CrossDesk"
+
+; <20><><EFBFBD>ð<EFBFBD>װ<EFBFBD><D7B0>ͼ<EFBFBD><CDBC>·<EFBFBD><C2B7>
+!define MUI_ICON "${__FILEDIR__}\..\..\icons\crossdesk.ico"
+
+; <20><><EFBFBD><EFBFBD>֤<EFBFBD><D6A4>·<EFBFBD><C2B7>
+!define CERT_FILE "${__FILEDIR__}\..\..\certs\crossdesk.cn_root.crt"
+
+; ѹ<><D1B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+SetCompressor /FINAL lzma
+
+; <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ԱȨ<D4B1>ޣ<EFBFBD>д<EFBFBD><D0B4>HKLM<4C><4D>Ҫ<EFBFBD><D2AA>
+RequestExecutionLevel admin
+
+; ------ MUI <20>ִ<EFBFBD><D6B4><EFBFBD><EFBFBD>涨<EFBFBD><E6B6A8> ------
+!include "MUI.nsh"
+!define MUI_ABORTWARNING
+!insertmacro MUI_PAGE_WELCOME
+!insertmacro MUI_PAGE_DIRECTORY
+!insertmacro MUI_PAGE_INSTFILES
+!insertmacro MUI_PAGE_FINISH
+!insertmacro MUI_LANGUAGE "SimpChinese"
+!insertmacro MUI_RESERVEFILE_INSTALLOPTIONS
+; ------ MUI <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ------
+
+Name "${PRODUCT_NAME} ${PRODUCT_VERSION}"
+OutFile "crossdesk-win-x86_64-${PRODUCT_VERSION}.exe"
+InstallDir "$PROGRAMFILES\CrossDesk"
+ShowInstDetails show
+
+Section "MainSection"
+    SetOutPath "$INSTDIR"
+    SetOverwrite ifnewer
+
+    ; <20><><EFBFBD>ó<EFBFBD><C3B3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>·<EFBFBD><C2B7>
+    File /oname=crossdesk.exe "..\..\build\windows\x64\release\crossdesk.exe"
+	
+	; ? <20><><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>װĿ¼
+    File "${MUI_ICON}"
+
+    ; д<><D0B4>ж<EFBFBD><D0B6><EFBFBD><EFBFBD>Ϣ
+    WriteUninstaller "$INSTDIR\uninstall.exe"
+
+    WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${UNINSTALL_REG_KEY}" "DisplayName" "${PRODUCT_NAME}"
+    WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${UNINSTALL_REG_KEY}" "UninstallString" "$INSTDIR\uninstall.exe"
+    WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${UNINSTALL_REG_KEY}" "DisplayVersion" "${PRODUCT_VERSION}"
+    WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${UNINSTALL_REG_KEY}" "Publisher" "${PRODUCT_PUBLISHER}"
+    WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${UNINSTALL_REG_KEY}" "URLInfoAbout" "${PRODUCT_WEB_SITE}"
+	WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${UNINSTALL_REG_KEY}" "DisplayIcon" "$INSTDIR\crossdesk.ico"
+    WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${UNINSTALL_REG_KEY}" "NoModify" 1
+    WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${UNINSTALL_REG_KEY}" "NoRepair" 1
+SectionEnd
+
+Section "Cert"
+    SetOutPath "$APPDATA\CrossDesk\certs"
+    File /r "${CERT_FILE}"
+SectionEnd
+
+Section -AdditionalIcons
+    ; <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݷ<EFBFBD>ʽ
+    CreateShortCut "$DESKTOP\${PRODUCT_NAME}.lnk" "$INSTDIR\crossdesk.exe" "" "$INSTDIR\crossdesk.ico"
+
+    ; <20><>ʼ<EFBFBD>˵<EFBFBD><CBB5><EFBFBD><EFBFBD>ݷ<EFBFBD>ʽ
+    CreateShortCut "$SMPROGRAMS\${PRODUCT_NAME}.lnk" "$INSTDIR\crossdesk.exe" "" "$INSTDIR\crossdesk.ico"
+
+    ; <20><>ҳ<EFBFBD><D2B3><EFBFBD>ݷ<EFBFBD>ʽ<EFBFBD><CABD><EFBFBD><EFBFBD><EFBFBD>棩
+    WriteIniStr "$DESKTOP\${PRODUCT_NAME}.url" "InternetShortcut" "URL" "${PRODUCT_WEB_SITE}"
+SectionEnd
+
+Section "Uninstall"
+    ; ɾ<><C9BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD>س<EFBFBD><D8B3><EFBFBD>
+    Delete "$INSTDIR\crossdesk.exe"
+    Delete "$INSTDIR\uninstall.exe"
+
+    ; <20>ݹ<EFBFBD>ɾ<EFBFBD><C9BE><EFBFBD><EFBFBD>װĿ¼
+    RMDir /r "$INSTDIR"
+
+    ; ɾ<><C9BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϳ<EFBFBD>ʼ<EFBFBD>˵<EFBFBD><CBB5><EFBFBD><EFBFBD>ݷ<EFBFBD>ʽ
+    Delete "$DESKTOP\${PRODUCT_NAME}.lnk"
+    Delete "$DESKTOP\${PRODUCT_NAME}.url"
+    Delete "$SMPROGRAMS\${PRODUCT_NAME}.lnk"
+
+    ; ɾ<><C9BE>ע<EFBFBD><D7A2><EFBFBD><EFBFBD>ж<EFBFBD><D0B6><EFBFBD><EFBFBD>
+    DeleteRegKey HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${UNINSTALL_REG_KEY}"
+
+    ; <20>ݹ<EFBFBD>ɾ<EFBFBD><C9BE><EFBFBD>û<EFBFBD> AppData <20>е<EFBFBD> CrossDesk <20>ļ<EFBFBD><C4BC><EFBFBD>
+    RMDir /r "$APPDATA\CrossDesk"
+    RMDir /r "$LOCALAPPDATA\CrossDesk"
+SectionEnd
+
+
+Section -Post
+SectionEnd

src/common/display_info.h

@@ -0,0 +1,44 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2025-05-15
+ * Copyright (c) 2025 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _DISPLAY_INFO_H_
+#define _DISPLAY_INFO_H_
+
+#include <string>
+
+class DisplayInfo {
+ public:
+  DisplayInfo(std::string name, int left, int top, int right, int bottom)
+      : name(name), left(left), top(top), right(right), bottom(bottom) {
+    width = right - left;
+    height = bottom - top;
+  }
+  DisplayInfo(void* handle, std::string name, bool is_primary, int left,
+              int top, int right, int bottom)
+      : handle(handle),
+        name(name),
+        is_primary(is_primary),
+        left(left),
+        top(top),
+        right(right),
+        bottom(bottom) {
+    width = right - left;
+    height = bottom - top;
+  }
+  ~DisplayInfo() {}
+
+  void* handle = nullptr;
+  std::string name = "";
+  bool is_primary = false;
+  int left = 0;
+  int top = 0;
+  int right = 0;
+  int bottom = 0;
+  int width = 0;
+  int height = 0;
+};
+
+#endif

src/device_controller/device_controller.h

@@ -9,17 +9,31 @@
 
 #include <stdio.h>
 
+#include "display_info.h"
+
 typedef enum {
   mouse = 0,
   keyboard,
   audio_capture,
-  host_infomation
+  host_infomation,
+  display_id,
 } ControlType;
-typedef enum { move = 0, left_down, left_up, right_down, right_up } MouseFlag;
+typedef enum {
+  move = 0,
+  left_down,
+  left_up,
+  right_down,
+  right_up,
+  middle_down,
+  middle_up,
+  wheel_vertical,
+  wheel_horizontal
+} MouseFlag;
 typedef enum { key_down = 0, key_up } KeyFlag;
 typedef struct {
-  size_t x;
-  size_t y;
+  float x;
+  float y;
+  int s;
   MouseFlag flag;
 } Mouse;
 
@@ -31,6 +45,12 @@ typedef struct {
 typedef struct {
   char host_name[64];
   size_t host_name_size;
+  char** display_list;
+  size_t display_num;
+  int* left;
+  int* top;
+  int* right;
+  int* bottom;
 } HostInfo;
 
 typedef struct {
@@ -40,6 +60,7 @@ typedef struct {
     Key k;
     HostInfo i;
     bool a;
+    int d;
   };
 } RemoteAction;
 
@@ -53,7 +74,7 @@ class DeviceController {
  public:
   // virtual int Init(int screen_width, int screen_height);
   // virtual int Destroy();
-  // virtual int SendCommand(RemoteAction remote_action);
+  // virtual int SendMouseCommand(RemoteAction remote_action);
 
   // virtual int Hook();
   // virtual int Unhook();

src/device_controller/keyboard/linux/keyboard_capturer.cpp

@@ -1,15 +1,69 @@
 #include "keyboard_capturer.h"
 
-KeyboardCapturer::KeyboardCapturer() {}
+#include "keyboard_converter.h"
+#include "rd_log.h"
 
-KeyboardCapturer::~KeyboardCapturer() {}
+static OnKeyAction g_on_key_action = nullptr;
+static void* g_user_ptr = nullptr;
 
-int KeyboardCapturer::Hook(OnKeyAction on_key_action, void *user_ptr) {
+static int KeyboardEventHandler(Display* display, XEvent* event) {
+  if (event->xkey.type == KeyPress || event->xkey.type == KeyRelease) {
+    KeySym keySym = XKeycodeToKeysym(display, event->xkey.keycode, 0);
+    int key_code = XKeysymToKeycode(display, keySym);
+    bool is_key_down = (event->xkey.type == KeyPress);
+
+    if (g_on_key_action) {
+      g_on_key_action(key_code, is_key_down, g_user_ptr);
+    }
+  }
   return 0;
 }
 
-int KeyboardCapturer::Unhook() { return 0; }
+KeyboardCapturer::KeyboardCapturer() : display_(nullptr), running_(true) {
+  display_ = XOpenDisplay(nullptr);
+  if (!display_) {
+    LOG_ERROR("Failed to open X display.");
+  }
+}
+
+KeyboardCapturer::~KeyboardCapturer() {
+  if (display_) {
+    XCloseDisplay(display_);
+  }
+}
+
+int KeyboardCapturer::Hook(OnKeyAction on_key_action, void* user_ptr) {
+  g_on_key_action = on_key_action;
+  g_user_ptr = user_ptr;
+
+  XSelectInput(display_, DefaultRootWindow(display_),
+               KeyPressMask | KeyReleaseMask);
+
+  while (running_) {
+    XEvent event;
+    XNextEvent(display_, &event);
+    KeyboardEventHandler(display_, &event);
+  }
+
+  return 0;
+}
+
+int KeyboardCapturer::Unhook() {
+  running_ = false;
+  return 0;
+}
 
 int KeyboardCapturer::SendKeyboardCommand(int key_code, bool is_down) {
+  if (!display_) {
+    LOG_ERROR("Display not initialized.");
+    return -1;
+  }
+
+  if (vkCodeToX11KeySym.find(key_code) != vkCodeToX11KeySym.end()) {
+    int x11_key_code = vkCodeToX11KeySym[key_code];
+    KeyCode keycode = XKeysymToKeycode(display_, x11_key_code);
+    XTestFakeKeyEvent(display_, keycode, is_down, CurrentTime);
+    XFlush(display_);
+  }
   return 0;
-}
+}

src/device_controller/keyboard/linux/keyboard_capturer.h

@@ -7,6 +7,10 @@
 #ifndef _KEYBOARD_CAPTURER_H_
 #define _KEYBOARD_CAPTURER_H_
 
+#include <X11/Xlib.h>
+#include <X11/extensions/XTest.h>
+#include <X11/keysym.h>
+
 #include "device_controller.h"
 
 class KeyboardCapturer : public DeviceController {
@@ -20,6 +24,9 @@ class KeyboardCapturer : public DeviceController {
   virtual int SendKeyboardCommand(int key_code, bool is_down);
 
  private:
+  Display *display_;
+  Window root_;
+  bool running_;
 };
 
 #endif

src/device_controller/keyboard/windows/keyboard_capturer.cpp

@@ -30,7 +30,7 @@ int KeyboardCapturer::Hook(OnKeyAction on_key_action, void* user_ptr) {
 
   keyboard_hook_ = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardProc, NULL, 0);
   if (!keyboard_hook_) {
-    LOG_ERROR("Failed to install keyboard hook!")
+    LOG_ERROR("Failed to install keyboard hook");
     return -1;
   }
   return 0;

src/device_controller/keyboard_converter.h

@@ -245,4 +245,60 @@ std::map<int, int> CGKeyCodeToVkCode = {
     {0x36, 0x5C},  // Right Command
 };
 
+// Windows vkCode to X11 KeySym
+std::map<int, int> vkCodeToX11KeySym = {
+    {0x41, 0x0041}, {0x42, 0x0042}, {0x43, 0x0043}, {0x44, 0x0044},
+    {0x45, 0x0045}, {0x46, 0x0046}, {0x47, 0x0047}, {0x48, 0x0048},
+    {0x49, 0x0049}, {0x4A, 0x004A}, {0x4B, 0x004B}, {0x4C, 0x004C},
+    {0x4D, 0x004D}, {0x4E, 0x004E}, {0x4F, 0x004F}, {0x50, 0x0050},
+    {0x51, 0x0051}, {0x52, 0x0052}, {0x53, 0x0053}, {0x54, 0x0054},
+    {0x55, 0x0055}, {0x56, 0x0056}, {0x57, 0x0057}, {0x58, 0x0058},
+    {0x59, 0x0059}, {0x5A, 0x005A}, {0x30, 0x0030}, {0x31, 0x0031},
+    {0x32, 0x0032}, {0x33, 0x0033}, {0x34, 0x0034}, {0x35, 0x0035},
+    {0x36, 0x0036}, {0x37, 0x0037}, {0x38, 0x0038}, {0x39, 0x0039},
+    {0x1B, 0xFF1B}, {0x0D, 0xFF0D}, {0x20, 0x0020}, {0x08, 0xFF08},
+    {0x09, 0xFF09}, {0x25, 0xFF51}, {0x27, 0xFF53}, {0x26, 0xFF52},
+    {0x28, 0xFF54}, {0x70, 0xFFBE}, {0x71, 0xFFBF}, {0x72, 0xFFC0},
+    {0x73, 0xFFC1}, {0x74, 0xFFC2}, {0x75, 0xFFC3}, {0x76, 0xFFC4},
+    {0x77, 0xFFC5}, {0x78, 0xFFC6}, {0x79, 0xFFC7}, {0x7A, 0xFFC8},
+    {0x7B, 0xFFC9},
+};
+
+// X11 KeySym to Windows vkCode
+std::map<int, int> x11KeySymToVkCode = []() {
+  std::map<int, int> result;
+  for (const auto& pair : vkCodeToX11KeySym) {
+    result[pair.second] = pair.first;
+  }
+  return result;
+}();
+
+// macOS CGKeyCode to X11 KeySym
+std::map<int, int> cgKeyCodeToX11KeySym = {
+    {0x00, 0x0041}, {0x0B, 0x0042}, {0x08, 0x0043}, {0x02, 0x0044},
+    {0x0E, 0x0045}, {0x03, 0x0046}, {0x05, 0x0047}, {0x04, 0x0048},
+    {0x22, 0x0049}, {0x26, 0x004A}, {0x28, 0x004B}, {0x25, 0x004C},
+    {0x2E, 0x004D}, {0x2D, 0x004E}, {0x1F, 0x004F}, {0x23, 0x0050},
+    {0x0C, 0x0051}, {0x0F, 0x0052}, {0x01, 0x0053}, {0x11, 0x0054},
+    {0x20, 0x0055}, {0x09, 0x0056}, {0x0D, 0x0057}, {0x07, 0x0058},
+    {0x10, 0x0059}, {0x06, 0x005A}, {0x12, 0x0031}, {0x13, 0x0032},
+    {0x14, 0x0033}, {0x15, 0x0034}, {0x17, 0x0035}, {0x16, 0x0036},
+    {0x1A, 0x0037}, {0x1C, 0x0038}, {0x19, 0x0039}, {0x1D, 0x0030},
+    {0x35, 0xFF1B}, {0x24, 0xFF0D}, {0x31, 0x0020}, {0x33, 0xFF08},
+    {0x30, 0xFF09}, {0x7B, 0xFF51}, {0x7C, 0xFF53}, {0x7E, 0xFF52},
+    {0x7D, 0xFF54}, {0x7A, 0xFFBE}, {0x78, 0xFFBF}, {0x63, 0xFFC0},
+    {0x76, 0xFFC1}, {0x60, 0xFFC2}, {0x61, 0xFFC3}, {0x62, 0xFFC4},
+    {0x64, 0xFFC5}, {0x65, 0xFFC6}, {0x6D, 0xFFC7}, {0x67, 0xFFC8},
+    {0x6F, 0xFFC9},
+};
+
+// X11 KeySym to macOS CGKeyCode
+std::map<int, int> x11KeySymToCgKeyCode = []() {
+  std::map<int, int> result;
+  for (const auto& pair : cgKeyCodeToX11KeySym) {
+    result[pair.second] = pair.first;
+  }
+  return result;
+}();
+
 #endif

src/device_controller/mouse/linux/mouse_controller.cpp

@@ -1,127 +1,124 @@
 #include "mouse_controller.h"
 
-#include "log.h"
+#include <X11/extensions/XTest.h>
+
+#include "rd_log.h"
 
 MouseController::MouseController() {}
 
-MouseController::~MouseController() {
-  if (uinput_fd_) {
-    ioctl(uinput_fd_, UI_DEV_DESTROY);
-    close(uinput_fd_);
-  }
-}
+MouseController::~MouseController() { Destroy(); }
 
-int MouseController::Init(int screen_width, int screen_height) {
-  screen_width_ = screen_width;
-  screen_height_ = screen_height;
-
-  uinput_fd_ = open("/dev/uinput", O_WRONLY | O_NONBLOCK);
-  if (uinput_fd_ < 0) {
-    LOG_ERROR("Cannot open device: /dev/uinput");
+int MouseController::Init(std::vector<DisplayInfo> display_info_list) {
+  display_info_list_ = display_info_list;
+  display_ = XOpenDisplay(NULL);
+  if (!display_) {
+    LOG_ERROR("Cannot connect to X server");
     return -1;
   }
 
-  ioctl(uinput_fd_, UI_SET_EVBIT, EV_KEY);
-  ioctl(uinput_fd_, UI_SET_KEYBIT, BTN_RIGHT);
-  ioctl(uinput_fd_, UI_SET_KEYBIT, BTN_LEFT);
-  ioctl(uinput_fd_, UI_SET_EVBIT, EV_ABS);
-  ioctl(uinput_fd_, UI_SET_ABSBIT, ABS_X);
-  ioctl(uinput_fd_, UI_SET_ABSBIT, ABS_Y);
-  ioctl(uinput_fd_, UI_SET_EVBIT, EV_REL);
+  root_ = DefaultRootWindow(display_);
 
-  struct uinput_user_dev uidev;
-  memset(&uidev, 0, sizeof(uidev));
-  snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "VirtualMouse");
-  uidev.id.bustype = BUS_USB;
-  uidev.id.version = 1;
-  uidev.id.vendor = 0x1;
-  uidev.id.product = 0x1;
-  uidev.absmin[ABS_X] = 0;
-  uidev.absmax[ABS_X] = screen_width_;
-  uidev.absmin[ABS_Y] = 0;
-  uidev.absmax[ABS_Y] = screen_height_;
-
-  int res_uidev = write(uinput_fd_, &uidev, sizeof(uidev));
-  ioctl(uinput_fd_, UI_DEV_CREATE);
-  return 0;
-}
-
-int MouseController::Destroy() { return 0; }
-
-int MouseController::SendCommand(RemoteAction remote_action) {
-  int mouse_pos_x = remote_action.m.x;
-  int mouse_pos_y = remote_action.m.y;
-
-  if (remote_action.type == ControlType::mouse) {
-    struct input_event event;
-    memset(&event, 0, sizeof(event));
-    gettimeofday(&event.time, NULL);
-
-    if (remote_action.m.flag == MouseFlag::left_down) {
-      SimulateKeyDown(uinput_fd_, BTN_LEFT);
-    } else if (remote_action.m.flag == MouseFlag::left_up) {
-      SimulateKeyUp(uinput_fd_, BTN_LEFT);
-    } else if (remote_action.m.flag == MouseFlag::right_down) {
-      SimulateKeyDown(uinput_fd_, BTN_RIGHT);
-    } else if (remote_action.m.flag == MouseFlag::right_up) {
-      SimulateKeyUp(uinput_fd_, BTN_RIGHT);
-    } else {
-      SetMousePosition(uinput_fd_, mouse_pos_x, mouse_pos_y);
-    }
+  int event_base, error_base, major_version, minor_version;
+  if (!XTestQueryExtension(display_, &event_base, &error_base, &major_version,
+                           &minor_version)) {
+    LOG_ERROR("XTest extension not available");
+    XCloseDisplay(display_);
+    return -2;
   }
 
   return 0;
 }
 
-void MouseController::SimulateKeyDown(int fd, int kval) {
-  int res_ev = 0;
-  struct input_event event;
-  memset(&event, 0, sizeof(event));
-  gettimeofday(&event.time, 0);
-
-  event.type = EV_KEY;
-  event.value = 1;
-  event.code = kval;
-  res_ev = write(fd, &event, sizeof(event));
-
-  event.type = EV_SYN;
-  event.value = 0;
-  event.code = SYN_REPORT;
-  res_ev = write(fd, &event, sizeof(event));
+int MouseController::Destroy() {
+  if (display_) {
+    XCloseDisplay(display_);
+    display_ = nullptr;
+  }
+  return 0;
 }
 
-void MouseController::SimulateKeyUp(int fd, int kval) {
-  int res_ev = 0;
-  struct input_event event;
-  memset(&event, 0, sizeof(event));
-  gettimeofday(&event.time, 0);
+int MouseController::SendMouseCommand(RemoteAction remote_action,
+                                      int display_index) {
+  switch (remote_action.type) {
+    case mouse:
+      switch (remote_action.m.flag) {
+        case MouseFlag::move:
+          SetMousePosition(
+              static_cast<int>(remote_action.m.x *
+                                   display_info_list_[display_index].width +
+                               display_info_list_[display_index].left),
+              static_cast<int>(remote_action.m.y *
+                                   display_info_list_[display_index].height +
+                               display_info_list_[display_index].top));
+          break;
+        case MouseFlag::left_down:
+          XTestFakeButtonEvent(display_, 1, True, CurrentTime);
+          XFlush(display_);
+          break;
+        case MouseFlag::left_up:
+          XTestFakeButtonEvent(display_, 1, False, CurrentTime);
+          XFlush(display_);
+          break;
+        case MouseFlag::right_down:
+          XTestFakeButtonEvent(display_, 3, True, CurrentTime);
+          XFlush(display_);
+          break;
+        case MouseFlag::right_up:
+          XTestFakeButtonEvent(display_, 3, False, CurrentTime);
+          XFlush(display_);
+          break;
+        case MouseFlag::middle_down:
+          XTestFakeButtonEvent(display_, 2, True, CurrentTime);
+          XFlush(display_);
+          break;
+        case MouseFlag::middle_up:
+          XTestFakeButtonEvent(display_, 2, False, CurrentTime);
+          XFlush(display_);
+          break;
+        case MouseFlag::wheel_vertical: {
+          if (remote_action.m.s > 0) {
+            SimulateMouseWheel(4, remote_action.m.s);
+          } else if (remote_action.m.s < 0) {
+            SimulateMouseWheel(5, -remote_action.m.s);
+          }
+          break;
+        }
+        case MouseFlag::wheel_horizontal: {
+          if (remote_action.m.s > 0) {
+            SimulateMouseWheel(6, remote_action.m.s);
+          } else if (remote_action.m.s < 0) {
+            SimulateMouseWheel(7, -remote_action.m.s);
+          }
+          break;
+        }
+      }
+      break;
+    default:
+      break;
+  }
 
-  event.type = EV_KEY;
-  event.value = 0;
-  event.code = kval;
-  res_ev = write(fd, &event, sizeof(event));
-
-  event.type = EV_SYN;
-  event.value = 0;
-  event.code = SYN_REPORT;
-  res_ev = write(fd, &event, sizeof(event));
+  return 0;
 }
 
-void MouseController::SetMousePosition(int fd, int x, int y) {
-  struct input_event ev[2], ev_sync;
-  memset(ev, 0, sizeof(ev));
-  memset(&ev_sync, 0, sizeof(ev_sync));
+void MouseController::SetMousePosition(int x, int y) {
+  XWarpPointer(display_, None, root_, 0, 0, 0, 0, x, y);
+  XFlush(display_);
+}
 
-  ev[0].type = EV_ABS;
-  ev[0].code = ABS_X;
-  ev[0].value = x;
-  ev[1].type = EV_ABS;
-  ev[1].code = ABS_Y;
-  ev[1].value = y;
-  int res_w = write(fd, ev, sizeof(ev));
+void MouseController::SimulateKeyDown(int kval) {
+  XTestFakeKeyEvent(display_, kval, True, CurrentTime);
+  XFlush(display_);
+}
 
-  ev_sync.type = EV_SYN;
-  ev_sync.value = 0;
-  ev_sync.code = 0;
-  int res_ev_sync = write(fd, &ev_sync, sizeof(ev_sync));
+void MouseController::SimulateKeyUp(int kval) {
+  XTestFakeKeyEvent(display_, kval, False, CurrentTime);
+  XFlush(display_);
+}
+
+void MouseController::SimulateMouseWheel(int direction_button, int count) {
+  for (int i = 0; i < count; ++i) {
+    XTestFakeButtonEvent(display_, direction_button, True, CurrentTime);
+    XTestFakeButtonEvent(display_, direction_button, False, CurrentTime);
+  }
+  XFlush(display_);
 }

src/device_controller/mouse/linux/mouse_controller.h

@@ -1,19 +1,18 @@
 /*
  * @Author: DI JUNKUN
- * @Date: 2023-12-14
- * Copyright (c) 2023 by DI JUNKUN, All Rights Reserved.
+ * @Date: 2025-05-07
+ * Copyright (c) 2025 by DI JUNKUN, All Rights Reserved.
  */
 
 #ifndef _MOUSE_CONTROLLER_H_
 #define _MOUSE_CONTROLLER_H_
 
-#include <fcntl.h>
-#include <linux/uinput.h>
-#include <net/if.h>
-#include <sys/ioctl.h>
-#include <sys/socket.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
 #include <unistd.h>
 
+#include <vector>
+
 #include "device_controller.h"
 
 class MouseController : public DeviceController {
@@ -22,18 +21,19 @@ class MouseController : public DeviceController {
   virtual ~MouseController();
 
  public:
-  virtual int Init(int screen_width, int screen_height);
+  virtual int Init(std::vector<DisplayInfo> display_info_list);
   virtual int Destroy();
-  virtual int SendCommand(RemoteAction remote_action);
+  virtual int SendMouseCommand(RemoteAction remote_action, int display_index);
 
  private:
-  void SimulateKeyDown(int fd, int kval);
-  void SimulateKeyUp(int fd, int kval);
-  void SetMousePosition(int fd, int x, int y);
+  void SimulateKeyDown(int kval);
+  void SimulateKeyUp(int kval);
+  void SetMousePosition(int x, int y);
+  void SimulateMouseWheel(int direction_button, int count);
 
- private:
-  int uinput_fd_;
-  struct uinput_user_dev uinput_dev_;
+  Display* display_ = nullptr;
+  Window root_ = 0;
+  std::vector<DisplayInfo> display_info_list_;
   int screen_width_ = 0;
   int screen_height_ = 0;
 };

src/device_controller/mouse/mac/mouse_controller.cpp

@@ -8,46 +8,93 @@ MouseController::MouseController() {}
 
 MouseController::~MouseController() {}
 
-int MouseController::Init(int screen_width, int screen_height) {
-  screen_width_ = screen_width;
-  screen_height_ = screen_height;
-
-  pixel_width_ =
-      CGDisplayModeGetPixelWidth(CGDisplayCopyDisplayMode(CGMainDisplayID()));
-  pixel_height_ =
-      CGDisplayModeGetPixelHeight(CGDisplayCopyDisplayMode(CGMainDisplayID()));
+int MouseController::Init(std::vector<DisplayInfo> display_info_list) {
+  display_info_list_ = display_info_list;
 
   return 0;
 }
 
 int MouseController::Destroy() { return 0; }
 
-int MouseController::SendCommand(RemoteAction remote_action) {
-  int mouse_pos_x = remote_action.m.x * screen_width_ / pixel_width_;
-  int mouse_pos_y = remote_action.m.y * screen_height_ / pixel_height_;
+int MouseController::SendMouseCommand(RemoteAction remote_action,
+                                      int display_index) {
+  int mouse_pos_x =
+      remote_action.m.x * display_info_list_[display_index].width +
+      display_info_list_[display_index].left;
+  int mouse_pos_y =
+      remote_action.m.y * display_info_list_[display_index].height +
+      display_info_list_[display_index].top;
 
   if (remote_action.type == ControlType::mouse) {
-    CGEventRef mouse_event;
+    CGEventRef mouse_event = nullptr;
     CGEventType mouse_type;
+    CGMouseButton mouse_button;
+    CGPoint mouse_point = CGPointMake(mouse_pos_x, mouse_pos_y);
 
-    if (remote_action.m.flag == MouseFlag::left_down) {
-      mouse_type = kCGEventLeftMouseDown;
-    } else if (remote_action.m.flag == MouseFlag::left_up) {
-      mouse_type = kCGEventLeftMouseUp;
-    } else if (remote_action.m.flag == MouseFlag::right_down) {
-      mouse_type = kCGEventRightMouseDown;
-    } else if (remote_action.m.flag == MouseFlag::right_up) {
-      mouse_type = kCGEventRightMouseUp;
-    } else {
-      mouse_type = kCGEventMouseMoved;
+    switch (remote_action.m.flag) {
+      case MouseFlag::left_down:
+        mouse_type = kCGEventLeftMouseDown;
+        left_dragging_ = true;
+        mouse_event = CGEventCreateMouseEvent(NULL, mouse_type, mouse_point,
+                                              kCGMouseButtonLeft);
+        break;
+      case MouseFlag::left_up:
+        mouse_type = kCGEventLeftMouseUp;
+        left_dragging_ = false;
+        mouse_event = CGEventCreateMouseEvent(NULL, mouse_type, mouse_point,
+                                              kCGMouseButtonLeft);
+        break;
+      case MouseFlag::right_down:
+        mouse_type = kCGEventRightMouseDown;
+        right_dragging_ = true;
+        mouse_event = CGEventCreateMouseEvent(NULL, mouse_type, mouse_point,
+                                              kCGMouseButtonRight);
+        break;
+      case MouseFlag::right_up:
+        mouse_type = kCGEventRightMouseUp;
+        right_dragging_ = false;
+        mouse_event = CGEventCreateMouseEvent(NULL, mouse_type, mouse_point,
+                                              kCGMouseButtonRight);
+        break;
+      case MouseFlag::middle_down:
+        mouse_type = kCGEventOtherMouseDown;
+        mouse_event = CGEventCreateMouseEvent(NULL, mouse_type, mouse_point,
+                                              kCGMouseButtonCenter);
+        break;
+      case MouseFlag::middle_up:
+        mouse_type = kCGEventOtherMouseUp;
+        mouse_event = CGEventCreateMouseEvent(NULL, mouse_type, mouse_point,
+                                              kCGMouseButtonCenter);
+        break;
+      case MouseFlag::wheel_vertical:
+        mouse_event = CGEventCreateScrollWheelEvent(
+            NULL, kCGScrollEventUnitLine, 2, remote_action.m.s, 0);
+        break;
+      case MouseFlag::wheel_horizontal:
+        mouse_event = CGEventCreateScrollWheelEvent(
+            NULL, kCGScrollEventUnitLine, 2, 0, remote_action.m.s);
+        break;
+      default:
+        if (left_dragging_) {
+          mouse_type = kCGEventLeftMouseDragged;
+          mouse_button = kCGMouseButtonLeft;
+        } else if (right_dragging_) {
+          mouse_type = kCGEventRightMouseDragged;
+          mouse_button = kCGMouseButtonRight;
+        } else {
+          mouse_type = kCGEventMouseMoved;
+          mouse_button = kCGMouseButtonLeft;
+        }
+
+        mouse_event = CGEventCreateMouseEvent(NULL, mouse_type, mouse_point,
+                                              mouse_button);
+        break;
     }
 
-    mouse_event = CGEventCreateMouseEvent(NULL, mouse_type,
-                                          CGPointMake(mouse_pos_x, mouse_pos_y),
-                                          kCGMouseButtonLeft);
-
-    CGEventPost(kCGHIDEventTap, mouse_event);
-    CFRelease(mouse_event);
+    if (mouse_event) {
+      CGEventPost(kCGHIDEventTap, mouse_event);
+      CFRelease(mouse_event);
+    }
   }
 
   return 0;

src/device_controller/mouse/mac/mouse_controller.h

@@ -7,6 +7,8 @@
 #ifndef _MOUSE_CONTROLLER_H_
 #define _MOUSE_CONTROLLER_H_
 
+#include <vector>
+
 #include "device_controller.h"
 
 class MouseController : public DeviceController {
@@ -15,16 +17,14 @@ class MouseController : public DeviceController {
   virtual ~MouseController();
 
  public:
-  virtual int Init(int screen_width, int screen_height);
+  virtual int Init(std::vector<DisplayInfo> display_info_list);
   virtual int Destroy();
-  virtual int SendCommand(RemoteAction remote_action);
+  virtual int SendMouseCommand(RemoteAction remote_action, int display_index);
 
  private:
-  int screen_width_ = 0;
-  int screen_height_ = 0;
-
-  int pixel_width_ = 0;
-  int pixel_height_ = 0;
+  std::vector<DisplayInfo> display_info_list_;
+  bool left_dragging_ = false;
+  bool right_dragging_ = false;
 };
 
 #endif

src/device_controller/mouse/windows/mouse_controller.cpp

@@ -6,34 +6,59 @@ MouseController::MouseController() {}
 
 MouseController::~MouseController() {}
 
-int MouseController::Init(int screen_width, int screen_height) {
-  screen_width_ = screen_width;
-  screen_height_ = screen_height;
+int MouseController::Init(std::vector<DisplayInfo> display_info_list) {
+  display_info_list_ = display_info_list;
 
   return 0;
 }
 
 int MouseController::Destroy() { return 0; }
 
-int MouseController::SendCommand(RemoteAction remote_action) {
+int MouseController::SendMouseCommand(RemoteAction remote_action,
+                                      int display_index) {
   INPUT ip;
 
   if (remote_action.type == ControlType::mouse) {
     ip.type = INPUT_MOUSE;
-    ip.mi.dx = (LONG)remote_action.m.x;
-    ip.mi.dy = (LONG)remote_action.m.y;
-    if (remote_action.m.flag == MouseFlag::left_down) {
-      ip.mi.dwFlags = MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_ABSOLUTE;
-    } else if (remote_action.m.flag == MouseFlag::left_up) {
-      ip.mi.dwFlags = MOUSEEVENTF_LEFTUP | MOUSEEVENTF_ABSOLUTE;
-    } else if (remote_action.m.flag == MouseFlag::right_down) {
-      ip.mi.dwFlags = MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_ABSOLUTE;
-    } else if (remote_action.m.flag == MouseFlag::right_up) {
-      ip.mi.dwFlags = MOUSEEVENTF_RIGHTUP | MOUSEEVENTF_ABSOLUTE;
-    } else {
-      ip.mi.dwFlags = MOUSEEVENTF_MOVE;
+    ip.mi.dx =
+        (LONG)(remote_action.m.x * display_info_list_[display_index].width) +
+        display_info_list_[display_index].left;
+    ip.mi.dy =
+        (LONG)(remote_action.m.y * display_info_list_[display_index].height) +
+        display_info_list_[display_index].top;
+
+    switch (remote_action.m.flag) {
+      case MouseFlag::left_down:
+        ip.mi.dwFlags = MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_ABSOLUTE;
+        break;
+      case MouseFlag::left_up:
+        ip.mi.dwFlags = MOUSEEVENTF_LEFTUP | MOUSEEVENTF_ABSOLUTE;
+        break;
+      case MouseFlag::right_down:
+        ip.mi.dwFlags = MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_ABSOLUTE;
+        break;
+      case MouseFlag::right_up:
+        ip.mi.dwFlags = MOUSEEVENTF_RIGHTUP | MOUSEEVENTF_ABSOLUTE;
+        break;
+      case MouseFlag::middle_down:
+        ip.mi.dwFlags = MOUSEEVENTF_MIDDLEDOWN | MOUSEEVENTF_ABSOLUTE;
+        break;
+      case MouseFlag::middle_up:
+        ip.mi.dwFlags = MOUSEEVENTF_MIDDLEUP | MOUSEEVENTF_ABSOLUTE;
+        break;
+      case MouseFlag::wheel_vertical:
+        ip.mi.dwFlags = MOUSEEVENTF_WHEEL;
+        ip.mi.mouseData = remote_action.m.s * 120;
+        break;
+      case MouseFlag::wheel_horizontal:
+        ip.mi.dwFlags = MOUSEEVENTF_HWHEEL;
+        ip.mi.mouseData = remote_action.m.s * 120;
+        break;
+      default:
+        ip.mi.dwFlags = MOUSEEVENTF_MOVE;
+        break;
     }
-    ip.mi.mouseData = 0;
+
     ip.mi.time = 0;
 
     SetCursorPos(ip.mi.dx, ip.mi.dy);

src/device_controller/mouse/windows/mouse_controller.h

@@ -7,6 +7,8 @@
 #ifndef _MOUSE_CONTROLLER_H_
 #define _MOUSE_CONTROLLER_H_
 
+#include <vector>
+
 #include "device_controller.h"
 
 class MouseController : public DeviceController {
@@ -15,13 +17,12 @@ class MouseController : public DeviceController {
   virtual ~MouseController();
 
  public:
-  virtual int Init(int screen_width, int screen_height);
+  virtual int Init(std::vector<DisplayInfo> display_info_list);
   virtual int Destroy();
-  virtual int SendCommand(RemoteAction remote_action);
+  virtual int SendMouseCommand(RemoteAction remote_action, int display_index);
 
  private:
-  int screen_width_ = 0;
-  int screen_height_ = 0;
+  std::vector<DisplayInfo> display_info_list_;
 };
 
 #endif

src/gui/main.cpp

@@ -1,5 +1,5 @@
 #ifdef _WIN32
-#ifdef REMOTE_DESK_DEBUG
+#ifdef DESK_PORT_DEBUG
 #pragma comment(linker, "/subsystem:\"console\"")
 #else
 #pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")
@@ -10,9 +10,7 @@
 #include "render.h"
 
 int main([[maybe_unused]] int argc, [[maybe_unused]] char *argv[]) {
-  LOG_INFO("Remote desk");
   Render render;
-
   render.Run();
 
   return 0;

src/localization/localization.h

@@ -10,94 +10,133 @@
 #include <vector>
 namespace localization {
 
-static std::vector<std::string> local_desktop = {u8"本桌面", "Local Desktop"};
-static std::vector<std::string> local_id = {u8"本机ID", "Local ID"};
+static std::vector<std::string> local_desktop = {
+    reinterpret_cast<const char*>(u8"本桌面"), "Local Desktop"};
+static std::vector<std::string> local_id = {
+    reinterpret_cast<const char*>(u8"本机ID"), "Local ID"};
 static std::vector<std::string> local_id_copied_to_clipboard = {
-    u8"已复制到剪贴板", "Copied to clipboard"};
-static std::vector<std::string> password = {u8"密码", "Password"};
-static std::vector<std::string> max_password_len = {u8"最大6个字符",
-                                                    "Max 6 chars"};
+    reinterpret_cast<const char*>(u8"已复制到剪贴板"), "Copied to clipboard"};
+static std::vector<std::string> password = {
+    reinterpret_cast<const char*>(u8"密码"), "Password"};
+static std::vector<std::string> max_password_len = {
+    reinterpret_cast<const char*>(u8"最大6个字符"), "Max 6 chars"};
 
-static std::vector<std::string> remote_desktop = {u8"控制远程桌面",
-                                                  "Control Remote Desktop"};
-static std::vector<std::string> remote_id = {u8"对端ID", "Remote ID"};
-static std::vector<std::string> connect = {u8"连接", "Connect"};
-static std::vector<std::string> recent_connections = {u8"近期连接",
-                                                      "Recent Connections"};
-static std::vector<std::string> disconnect = {u8"断开连接", "Disconnect"};
-static std::vector<std::string> fullscreen = {u8"全屏", " Fullscreen"};
+static std::vector<std::string> remote_desktop = {
+    reinterpret_cast<const char*>(u8"控制远程桌面"), "Control Remote Desktop"};
+static std::vector<std::string> remote_id = {
+    reinterpret_cast<const char*>(u8"对端ID"), "Remote ID"};
+static std::vector<std::string> connect = {
+    reinterpret_cast<const char*>(u8"连接"), "Connect"};
+static std::vector<std::string> recent_connections = {
+    reinterpret_cast<const char*>(u8"近期连接"), "Recent Connections"};
+static std::vector<std::string> disconnect = {
+    reinterpret_cast<const char*>(u8"断开连接"), "Disconnect"};
+static std::vector<std::string> fullscreen = {
+    reinterpret_cast<const char*>(u8"全屏"), " Fullscreen"};
 static std::vector<std::string> show_net_traffic_stats = {
-    u8"显示流量统计", "Show Net Traffic Stats"};
+    reinterpret_cast<const char*>(u8"显示流量统计"), "Show Net Traffic Stats"};
 static std::vector<std::string> hide_net_traffic_stats = {
-    u8"隐藏流量统计", "Hide Net Traffic Stats"};
-static std::vector<std::string> video = {u8"视频", "Video"};
-static std::vector<std::string> audio = {u8"音频", "Audio"};
-static std::vector<std::string> data = {u8"数据", "Data"};
-static std::vector<std::string> total = {u8"总计", "Total"};
-static std::vector<std::string> in = {u8"输入", "In"};
-static std::vector<std::string> out = {u8"输出", "Out"};
-static std::vector<std::string> loss_rate = {u8"丢包率", "Loss Rate"};
-static std::vector<std::string> exit_fullscreen = {u8"退出全屏",
-                                                   "Exit fullscreen"};
-static std::vector<std::string> control_mouse = {u8"控制", "Control"};
-static std::vector<std::string> release_mouse = {u8"释放", "Release"};
-static std::vector<std::string> audio_capture = {u8"声音", "Audio"};
-static std::vector<std::string> mute = {u8" 静音", " Mute"};
-static std::vector<std::string> settings = {u8"设置", "Settings"};
-static std::vector<std::string> language = {u8"语言:", "Language:"};
-static std::vector<std::string> language_zh = {u8"中文", "Chinese"};
-static std::vector<std::string> language_en = {u8"英文", "English"};
-static std::vector<std::string> video_quality = {u8"视频质量:",
-                                                 "Video Quality:"};
-static std::vector<std::string> video_quality_high = {u8"高", "High"};
-static std::vector<std::string> video_quality_medium = {u8"中", "Medium"};
-static std::vector<std::string> video_quality_low = {u8"低", "Low"};
-static std::vector<std::string> video_encode_format = {u8"视频编码格式:",
-                                                       "Video Encode Format:"};
-static std::vector<std::string> av1 = {u8"AV1", "AV1"};
-static std::vector<std::string> h264 = {u8"H.264", "H.264"};
+    reinterpret_cast<const char*>(u8"隐藏流量统计"), "Hide Net Traffic Stats"};
+static std::vector<std::string> video = {
+    reinterpret_cast<const char*>(u8"视频"), "Video"};
+static std::vector<std::string> audio = {
+    reinterpret_cast<const char*>(u8"音频"), "Audio"};
+static std::vector<std::string> data = {reinterpret_cast<const char*>(u8"数据"),
+                                        "Data"};
+static std::vector<std::string> total = {
+    reinterpret_cast<const char*>(u8"总计"), "Total"};
+static std::vector<std::string> in = {reinterpret_cast<const char*>(u8"输入"),
+                                      "In"};
+static std::vector<std::string> out = {reinterpret_cast<const char*>(u8"输出"),
+                                       "Out"};
+static std::vector<std::string> loss_rate = {
+    reinterpret_cast<const char*>(u8"丢包率"), "Loss Rate"};
+static std::vector<std::string> exit_fullscreen = {
+    reinterpret_cast<const char*>(u8"退出全屏"), "Exit fullscreen"};
+static std::vector<std::string> control_mouse = {
+    reinterpret_cast<const char*>(u8"控制"), "Control"};
+static std::vector<std::string> release_mouse = {
+    reinterpret_cast<const char*>(u8"释放"), "Release"};
+static std::vector<std::string> audio_capture = {
+    reinterpret_cast<const char*>(u8"声音"), "Audio"};
+static std::vector<std::string> mute = {
+    reinterpret_cast<const char*>(u8" 静音"), " Mute"};
+static std::vector<std::string> settings = {
+    reinterpret_cast<const char*>(u8"设置"), "Settings"};
+static std::vector<std::string> language = {
+    reinterpret_cast<const char*>(u8"语言:"), "Language:"};
+static std::vector<std::string> language_zh = {
+    reinterpret_cast<const char*>(u8"中文"), "Chinese"};
+static std::vector<std::string> language_en = {
+    reinterpret_cast<const char*>(u8"英文"), "English"};
+static std::vector<std::string> video_quality = {
+    reinterpret_cast<const char*>(u8"视频质量:"), "Video Quality:"};
+static std::vector<std::string> video_quality_high = {
+    reinterpret_cast<const char*>(u8"高"), "High"};
+static std::vector<std::string> video_quality_medium = {
+    reinterpret_cast<const char*>(u8"中"), "Medium"};
+static std::vector<std::string> video_quality_low = {
+    reinterpret_cast<const char*>(u8"低"), "Low"};
+static std::vector<std::string> video_encode_format = {
+    reinterpret_cast<const char*>(u8"视频编码格式:"), "Video Encode Format:"};
+static std::vector<std::string> av1 = {reinterpret_cast<const char*>(u8"AV1"),
+                                       "AV1"};
+static std::vector<std::string> h264 = {
+    reinterpret_cast<const char*>(u8"H.264"), "H.264"};
 static std::vector<std::string> enable_hardware_video_codec = {
-    u8"启用硬件编解码器:", "Enable Hardware Video Codec:"};
-static std::vector<std::string> enable_turn = {u8"启用中继服务:",
-                                               "Enable TURN Service:"};
+    reinterpret_cast<const char*>(u8"启用硬件编解码器:"),
+    "Enable Hardware Video Codec:"};
+static std::vector<std::string> enable_turn = {
+    reinterpret_cast<const char*>(u8"启用中继服务:"), "Enable TURN Service:"};
 
-static std::vector<std::string> ok = {u8"确认", "OK"};
-static std::vector<std::string> cancel = {u8"取消", "Cancel"};
+static std::vector<std::string> ok = {reinterpret_cast<const char*>(u8"确认"),
+                                      "OK"};
+static std::vector<std::string> cancel = {
+    reinterpret_cast<const char*>(u8"取消"), "Cancel"};
 
 static std::vector<std::string> new_password = {
-    u8"请输入六位密码:", "Please input a six-char password:"};
+    reinterpret_cast<const char*>(u8"请输入六位密码:"),
+    "Please input a six-char password:"};
 
-static std::vector<std::string> input_password = {u8"请输入密码:",
-                                                  "Please input password:"};
-static std::vector<std::string> validate_password = {u8"验证密码中...",
-                                                     "Validate password ..."};
+static std::vector<std::string> input_password = {
+    reinterpret_cast<const char*>(u8"请输入密码:"), "Please input password:"};
+static std::vector<std::string> validate_password = {
+    reinterpret_cast<const char*>(u8"验证密码中..."), "Validate password ..."};
 static std::vector<std::string> reinput_password = {
-    u8"请重新输入密码", "Please input password again"};
+    reinterpret_cast<const char*>(u8"请重新输入密码"),
+    "Please input password again"};
 
-static std::vector<std::string> remember_password = {u8"记住密码",
-                                                     "Remember password"};
+static std::vector<std::string> remember_password = {
+    reinterpret_cast<const char*>(u8"记住密码"), "Remember password"};
 
-static std::vector<std::string> signal_connected = {u8"已连接服务器",
-                                                    "Connected"};
-static std::vector<std::string> signal_disconnected = {u8"未连接服务器",
-                                                       "Disconnected"};
+static std::vector<std::string> signal_connected = {
+    reinterpret_cast<const char*>(u8"已连接服务器"), "Connected"};
+static std::vector<std::string> signal_disconnected = {
+    reinterpret_cast<const char*>(u8"未连接服务器"), "Disconnected"};
 
-static std::vector<std::string> p2p_connected = {u8"对等连接已建立",
-                                                 "P2P Connected"};
-static std::vector<std::string> p2p_disconnected = {u8"对等连接已断开",
-                                                    "P2P Disconnected"};
-static std::vector<std::string> p2p_connecting = {u8"正在建立对等连接...",
-                                                  "P2P Connecting ..."};
-static std::vector<std::string> p2p_failed = {u8"对等连接失败", "P2P Failed"};
-static std::vector<std::string> p2p_closed = {u8"对等连接已关闭", "P2P closed"};
+static std::vector<std::string> p2p_connected = {
+    reinterpret_cast<const char*>(u8"对等连接已建立"), "P2P Connected"};
+static std::vector<std::string> p2p_disconnected = {
+    reinterpret_cast<const char*>(u8"对等连接已断开"), "P2P Disconnected"};
+static std::vector<std::string> p2p_connecting = {
+    reinterpret_cast<const char*>(u8"正在建立对等连接..."),
+    "P2P Connecting ..."};
+static std::vector<std::string> p2p_failed = {
+    reinterpret_cast<const char*>(u8"对等连接失败"), "P2P Failed"};
+static std::vector<std::string> p2p_closed = {
+    reinterpret_cast<const char*>(u8"对等连接已关闭"), "P2P closed"};
 
-static std::vector<std::string> no_such_id = {u8"无此ID", "No such ID"};
+static std::vector<std::string> no_such_id = {
+    reinterpret_cast<const char*>(u8"无此ID"), "No such ID"};
 
-static std::vector<std::string> about = {u8"关于", "About"};
-static std::vector<std::string> version = {u8"版本", "Version"};
+static std::vector<std::string> about = {
+    reinterpret_cast<const char*>(u8"关于"), "About"};
+static std::vector<std::string> version = {
+    reinterpret_cast<const char*>(u8"版本"), "Version"};
 
 static std::vector<std::string> confirm_delete_connection = {
-    u8"确认删除此连接", "Confirm to delete this connection"};
+    reinterpret_cast<const char*>(u8"确认删除此连接"),
+    "Confirm to delete this connection"};
 }  // namespace localization
 
 #endif

src/log/rd_log.cpp

@@ -1,37 +1,62 @@
 #include "rd_log.h"
 
-std::shared_ptr<spdlog::logger> get_logger() {
-  if (auto logger = spdlog::get(LOGGER_NAME)) {
-    return logger;
+#include <atomic>
+#include <filesystem>
+
+namespace {
+
+std::string g_log_dir = "logs";
+std::once_flag g_logger_once_flag;
+std::shared_ptr<spdlog::logger> g_logger;
+std::atomic<bool> g_logger_created{false};
+
+}  // namespace
+
+void InitLogger(const std::string& log_dir) {
+  if (g_logger_created.load()) {
+    LOG_WARN(
+        "InitLogger called after logger initialized. Ignoring log_dir: {}, "
+        "using previous log_dir: {}",
+        log_dir, g_log_dir);
+    return;
   }
 
-  auto now = std::chrono::system_clock::now() + std::chrono::hours(8);
-  auto now_time = std::chrono::system_clock::to_time_t(now);
+  g_log_dir = log_dir;
+}
 
-  std::tm tm_info;
+std::shared_ptr<spdlog::logger> get_logger() {
+  std::call_once(g_logger_once_flag, []() {
+    g_logger_created.store(true);
 
+    std::error_code ec;
+    std::filesystem::create_directories(g_log_dir, ec);
+
+    auto now = std::chrono::system_clock::now() + std::chrono::hours(8);
+    auto now_time = std::chrono::system_clock::to_time_t(now);
+
+    std::tm tm_info;
 #ifdef _WIN32
-  gmtime_s(&tm_info, &now_time);
+    gmtime_s(&tm_info, &now_time);
 #else
-  gmtime_r(&now_time, &tm_info);
+    gmtime_r(&now_time, &tm_info);
 #endif
 
-  std::stringstream ss;
-  std::string filename;
-  ss << LOGGER_NAME;
-  ss << std::put_time(&tm_info, "-%Y%m%d-%H%M%S.log");
-  ss >> filename;
+    std::stringstream ss;
+    ss << LOGGER_NAME;
+    ss << std::put_time(&tm_info, "-%Y%m%d-%H%M%S.log");
 
-  std::string path = "logs/" + filename;
-  std::vector<spdlog::sink_ptr> sinks;
-  sinks.push_back(std::make_shared<spdlog::sinks::stdout_color_sink_mt>());
-  sinks.push_back(std::make_shared<spdlog::sinks::rotating_file_sink_mt>(
-      path, 1048576 * 5, 3));
+    std::string filename = g_log_dir + "/" + ss.str();
 
-  auto combined_logger =
-      std::make_shared<spdlog::logger>(LOGGER_NAME, begin(sinks), end(sinks));
-  combined_logger->flush_on(spdlog::level::info);
-  spdlog::register_logger(combined_logger);
+    std::vector<spdlog::sink_ptr> sinks;
+    sinks.push_back(std::make_shared<spdlog::sinks::stdout_color_sink_mt>());
+    sinks.push_back(std::make_shared<spdlog::sinks::rotating_file_sink_mt>(
+        filename, 5 * 1024 * 1024, 3));
 
-  return combined_logger;
+    g_logger = std::make_shared<spdlog::logger>(LOGGER_NAME, sinks.begin(),
+                                                sinks.end());
+    g_logger->flush_on(spdlog::level::info);
+    spdlog::register_logger(g_logger);
+  });
+
+  return g_logger;
 }

src/log/rd_log.h

@@ -1,7 +1,7 @@
 /*
  * @Author: DI JUNKUN
- * @Date: 2024-11-26
- * Copyright (c) 2024 by DI JUNKUN, All Rights Reserved.
+ * @Date: 2025-07-21
+ * Copyright (c) 2025 by DI JUNKUN, All Rights Reserved.
  */
 
 #ifndef _RD_LOG_H_
@@ -10,8 +10,11 @@
 #include <chrono>
 #include <iomanip>
 #include <iostream>
+#include <memory>
+#include <mutex>
 #include <sstream>
 #include <string>
+#include <vector>
 
 #include "spdlog/common.h"
 #include "spdlog/logger.h"
@@ -20,20 +23,17 @@
 #include "spdlog/sinks/stdout_color_sinks.h"
 #include "spdlog/spdlog.h"
 
-using namespace std::chrono;
-
 #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
 
-constexpr auto LOGGER_NAME = "rd";
+constexpr auto LOGGER_NAME = "crossdesk";
+
+void InitLogger(const std::string& log_dir);
 
 std::shared_ptr<spdlog::logger> get_logger();
 
-#define LOG_INFO(...) SPDLOG_LOGGER_INFO(get_logger(), __VA_ARGS__);
-
-#define LOG_WARN(...) SPDLOG_LOGGER_WARN(get_logger(), __VA_ARGS__);
-
-#define LOG_ERROR(...) SPDLOG_LOGGER_ERROR(get_logger(), __VA_ARGS__);
-
-#define LOG_FATAL(...) SPDLOG_LOGGER_CRITICAL(get_logger(), __VA_ARGS__);
+#define LOG_INFO(...) SPDLOG_LOGGER_INFO(get_logger(), __VA_ARGS__)
+#define LOG_WARN(...) SPDLOG_LOGGER_WARN(get_logger(), __VA_ARGS__)
+#define LOG_ERROR(...) SPDLOG_LOGGER_ERROR(get_logger(), __VA_ARGS__)
+#define LOG_FATAL(...) SPDLOG_LOGGER_CRITICAL(get_logger(), __VA_ARGS__)
 
 #endif

src/path_manager/path_manager.cpp

@@ -0,0 +1,91 @@
+#include "path_manager.h"
+
+#include <cstdlib>
+
+PathManager::PathManager(const std::string& app_name) : app_name_(app_name) {}
+
+std::filesystem::path PathManager::GetConfigPath() {
+#ifdef _WIN32
+  return GetKnownFolder(FOLDERID_RoamingAppData) / app_name_;
+#elif __APPLE__
+  return GetEnvOrDefault("XDG_CONFIG_HOME", GetHome() + "/.config") / app_name_;
+#else
+  return GetEnvOrDefault("XDG_CONFIG_HOME", GetHome() + "/.config") / app_name_;
+#endif
+}
+
+std::filesystem::path PathManager::GetCachePath() {
+#ifdef _WIN32
+  return GetKnownFolder(FOLDERID_LocalAppData) / app_name_ / "cache";
+#elif __APPLE__
+  return GetEnvOrDefault("XDG_CACHE_HOME", GetHome() + "/.cache") / app_name_;
+#else
+  return GetEnvOrDefault("XDG_CACHE_HOME", GetHome() + "/.cache") / app_name_;
+#endif
+}
+
+std::filesystem::path PathManager::GetLogPath() {
+#ifdef _WIN32
+  return GetKnownFolder(FOLDERID_LocalAppData) / app_name_ / "logs";
+#elif __APPLE__
+  return GetHome() + "/Library/Logs/" + app_name_;
+#else
+  return GetCachePath() / app_name_ / "logs";
+#endif
+}
+
+std::filesystem::path PathManager::GetCertPath() {
+#ifdef _WIN32
+  // %APPDATA%\AppName\Certs
+  return GetKnownFolder(FOLDERID_RoamingAppData) / app_name_ / "certs";
+#elif __APPLE__
+  // $HOME/Library/Application Support/AppName/certs
+  return GetHome() + "/Library/Application Support/" + app_name_ + "/certs";
+#else
+  // $XDG_CONFIG_HOME/AppName/certs
+  return GetEnvOrDefault("XDG_CONFIG_HOME", GetHome() + "/.config") /
+         app_name_ / "certs";
+#endif
+}
+
+bool PathManager::CreateDirectories(const std::filesystem::path& p) {
+  std::error_code ec;
+  bool created = std::filesystem::create_directories(p, ec);
+  if (ec) {
+    return false;
+  }
+  return created || std::filesystem::exists(p);
+}
+
+#ifdef _WIN32
+std::filesystem::path PathManager::GetKnownFolder(REFKNOWNFOLDERID id) {
+  PWSTR path = NULL;
+  if (SUCCEEDED(SHGetKnownFolderPath(id, 0, NULL, &path))) {
+    std::wstring wpath(path);
+    CoTaskMemFree(path);
+    return std::filesystem::path(wpath);
+  }
+  return {};
+}
+#endif
+
+std::string PathManager::GetHome() {
+  if (const char* home = getenv("HOME")) {
+    return std::string(home);
+  }
+#ifdef _WIN32
+  char path[MAX_PATH];
+  if (SUCCEEDED(SHGetFolderPathA(NULL, CSIDL_PROFILE, NULL, 0, path)))
+    return std::string(path);
+#endif
+  return {};
+}
+
+std::filesystem::path PathManager::GetEnvOrDefault(const char* env_var,
+                                                   const std::string& def) {
+  if (const char* val = getenv(env_var)) {
+    return std::filesystem::path(val);
+  }
+
+  return std::filesystem::path(def);
+}

src/path_manager/path_manager.h

@@ -0,0 +1,44 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2025-07-16
+ * Copyright (c) 2025 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _PATH_MANAGER_H_
+#define _PATH_MANAGER_H_
+
+#include <filesystem>
+#include <string>
+#ifdef _WIN32
+#include <shlobj.h>
+#include <windows.h>
+#endif
+
+class PathManager {
+ public:
+  explicit PathManager(const std::string& app_name);
+
+  std::filesystem::path GetConfigPath();
+
+  std::filesystem::path GetCachePath();
+
+  std::filesystem::path GetLogPath();
+
+  std::filesystem::path GetCertPath();
+
+  bool CreateDirectories(const std::filesystem::path& p);
+
+ private:
+#ifdef _WIN32
+  std::filesystem::path GetKnownFolder(REFKNOWNFOLDERID id);
+#endif
+
+  std::string GetHome();
+  std::filesystem::path GetEnvOrDefault(const char* env_var,
+                                        const std::string& def);
+
+ private:
+  std::string app_name_;
+};
+
+#endif

src/screen_capturer/linux/screen_capturer_x11.cpp

@@ -1,152 +1,174 @@
 #include "screen_capturer_x11.h"
 
-#include <iostream>
+#include <chrono>
+#include <thread>
 
-#include "log.h"
-
-#define NV12_BUFFER_SIZE 1280 * 720 * 3 / 2
-unsigned char nv12_buffer_[NV12_BUFFER_SIZE];
+#include "libyuv.h"
+#include "rd_log.h"
 
 ScreenCapturerX11::ScreenCapturerX11() {}
 
-ScreenCapturerX11::~ScreenCapturerX11() {
-  if (inited_ && capture_thread_.joinable()) {
-    capture_thread_.join();
-    inited_ = false;
-  }
-}
+ScreenCapturerX11::~ScreenCapturerX11() { Destroy(); }
 
-int ScreenCapturerX11::Init(const RECORD_DESKTOP_RECT &rect, const int fps,
-                            cb_desktop_data cb) {
-  if (cb) {
-    _on_data = cb;
+int ScreenCapturerX11::Init(const int fps, cb_desktop_data cb) {
+  display_ = XOpenDisplay(nullptr);
+  if (!display_) {
+    LOG_ERROR("Cannot connect to X server");
+    return -1;
+  }
+
+  root_ = DefaultRootWindow(display_);
+  screen_res_ = XRRGetScreenResources(display_, root_);
+  if (!screen_res_) {
+    LOG_ERROR("Failed to get screen resources");
+    XCloseDisplay(display_);
+    return 1;
+  }
+
+  for (int i = 0; i < screen_res_->noutput; ++i) {
+    RROutput output = screen_res_->outputs[i];
+    XRROutputInfo* output_info =
+        XRRGetOutputInfo(display_, screen_res_, output);
+
+    if (output_info->connection == RR_Connected && output_info->crtc != 0) {
+      XRRCrtcInfo* crtc_info =
+          XRRGetCrtcInfo(display_, screen_res_, output_info->crtc);
+
+      display_info_list_.push_back(
+          DisplayInfo((void*)display_, output_info->name, true, crtc_info->x,
+                      crtc_info->y, crtc_info->width, crtc_info->height));
+
+      XRRFreeCrtcInfo(crtc_info);
+    }
+
+    if (output_info) {
+      XRRFreeOutputInfo(output_info);
+    }
+  }
+
+  XWindowAttributes attr;
+  XGetWindowAttributes(display_, root_, &attr);
+
+  width_ = attr.width;
+  height_ = attr.height;
+
+  if (width_ % 2 != 0 || height_ % 2 != 0) {
+    LOG_ERROR("Width and height must be even numbers");
+    return -2;
   }
 
   fps_ = fps;
+  callback_ = cb;
 
-  av_log_set_level(AV_LOG_QUIET);
-
-  pFormatCtx_ = avformat_alloc_context();
-
-  avdevice_register_all();
-
-  // grabbing frame rate
-  av_dict_set(&options_, "framerate", "30", 0);
-  // show remote cursor
-  av_dict_set(&options_, "capture_cursor", "0", 0);
-  // Make the grabbed area follow the mouse
-  // av_dict_set(&options_, "follow_mouse", "centered", 0);
-  // Video frame size. The default is to capture the full screen
-  // av_dict_set(&options_, "video_size", "1280x720", 0);
-  std::string capture_method = "x11grab";
-  ifmt_ = (AVInputFormat *)av_find_input_format(capture_method.c_str());
-  if (!ifmt_) {
-    LOG_ERROR("Couldn't find_input_format [{}]", capture_method.c_str());
-  }
-
-  // Grab at position 10,20
-  if (avformat_open_input(&pFormatCtx_, ":0.0", ifmt_, &options_) != 0) {
-    printf("Couldn't open input stream.\n");
-    return -1;
-  }
-
-  if (avformat_find_stream_info(pFormatCtx_, NULL) < 0) {
-    printf("Couldn't find stream information.\n");
-    return -1;
-  }
-
-  videoindex_ = -1;
-  for (i_ = 0; i_ < pFormatCtx_->nb_streams; i_++)
-    if (pFormatCtx_->streams[i_]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
-      videoindex_ = i_;
-      break;
-    }
-  if (videoindex_ == -1) {
-    printf("Didn't find a video stream.\n");
-    return -1;
-  }
-
-  pCodecParam_ = pFormatCtx_->streams[videoindex_]->codecpar;
-
-  pCodecCtx_ = avcodec_alloc_context3(NULL);
-  avcodec_parameters_to_context(pCodecCtx_, pCodecParam_);
-
-  pCodec_ = const_cast<AVCodec *>(avcodec_find_decoder(pCodecCtx_->codec_id));
-  if (pCodec_ == NULL) {
-    printf("Codec not found.\n");
-    return -1;
-  }
-  if (avcodec_open2(pCodecCtx_, pCodec_, NULL) < 0) {
-    printf("Could not open codec.\n");
-    return -1;
-  }
-
-  const int screen_w = pFormatCtx_->streams[videoindex_]->codecpar->width;
-  const int screen_h = pFormatCtx_->streams[videoindex_]->codecpar->height;
-
-  pFrame_ = av_frame_alloc();
-  pFrameNv12_ = av_frame_alloc();
-
-  pFrame_->width = screen_w;
-  pFrame_->height = screen_h;
-  pFrameNv12_->width = 1280;
-  pFrameNv12_->height = 720;
-
-  packet_ = (AVPacket *)av_malloc(sizeof(AVPacket));
-
-  img_convert_ctx_ = sws_getContext(
-      pFrame_->width, pFrame_->height, pCodecCtx_->pix_fmt, pFrameNv12_->width,
-      pFrameNv12_->height, AV_PIX_FMT_NV12, SWS_BICUBIC, NULL, NULL, NULL);
-
-  inited_ = true;
+  y_plane_.resize(width_ * height_);
+  uv_plane_.resize((width_ / 2) * (height_ / 2) * 2);
 
   return 0;
 }
 
 int ScreenCapturerX11::Destroy() {
-  running_ = false;
+  Stop();
+
+  y_plane_.clear();
+  uv_plane_.clear();
+
+  if (screen_res_) {
+    XRRFreeScreenResources(screen_res_);
+    screen_res_ = nullptr;
+  }
+
+  if (display_) {
+    XCloseDisplay(display_);
+    display_ = nullptr;
+  }
   return 0;
 }
 
 int ScreenCapturerX11::Start() {
-  capture_thread_ = std::thread([this]() {
+  if (running_) return 0;
+  running_ = true;
+  paused_ = false;
+  thread_ = std::thread([this]() {
     while (running_) {
-      if (av_read_frame(pFormatCtx_, packet_) >= 0) {
-        if (packet_->stream_index == videoindex_) {
-          avcodec_send_packet(pCodecCtx_, packet_);
-          av_packet_unref(packet_);
-          got_picture_ = avcodec_receive_frame(pCodecCtx_, pFrame_);
-
-          if (!got_picture_) {
-            av_image_fill_arrays(pFrameNv12_->data, pFrameNv12_->linesize,
-                                 nv12_buffer_, AV_PIX_FMT_NV12,
-                                 pFrameNv12_->width, pFrameNv12_->height, 1);
-
-            sws_scale(img_convert_ctx_, pFrame_->data, pFrame_->linesize, 0,
-                      pFrame_->height, pFrameNv12_->data,
-                      pFrameNv12_->linesize);
-
-            _on_data((unsigned char *)nv12_buffer_,
-                     pFrameNv12_->width * pFrameNv12_->height * 3 / 2,
-                     pFrameNv12_->width, pFrameNv12_->height);
-          }
-        }
-      }
+      if (!paused_) OnFrame();
     }
   });
-
   return 0;
 }
 
 int ScreenCapturerX11::Stop() {
+  if (!running_) return 0;
   running_ = false;
+  if (thread_.joinable()) thread_.join();
   return 0;
 }
 
-int ScreenCapturerX11::Pause() { return 0; }
+int ScreenCapturerX11::Pause(int monitor_index) {
+  paused_ = true;
+  return 0;
+}
 
-int ScreenCapturerX11::Resume() { return 0; }
+int ScreenCapturerX11::Resume(int monitor_index) {
+  paused_ = false;
+  return 0;
+}
 
-void ScreenCapturerX11::OnFrame() {}
+int ScreenCapturerX11::SwitchTo(int monitor_index) {
+  monitor_index_ = monitor_index;
+  return 0;
+}
 
-void ScreenCapturerX11::CleanUp() {}
+std::vector<DisplayInfo> ScreenCapturerX11::GetDisplayInfoList() {
+  return display_info_list_;
+}
+
+void ScreenCapturerX11::OnFrame() {
+  if (!display_) {
+    LOG_ERROR("Display is not initialized");
+    return;
+  }
+
+  if (monitor_index_ < 0 || monitor_index_ >= display_info_list_.size()) {
+    LOG_ERROR("Invalid monitor index: {}", monitor_index_.load());
+    return;
+  }
+
+  left_ = display_info_list_[monitor_index_].left;
+  top_ = display_info_list_[monitor_index_].top;
+  width_ = display_info_list_[monitor_index_].width;
+  height_ = display_info_list_[monitor_index_].height;
+
+  XImage* image = XGetImage(display_, root_, left_, top_, width_, height_,
+                            AllPlanes, ZPixmap);
+  if (!image) return;
+
+  bool needs_copy = image->bytes_per_line != width_ * 4;
+  std::vector<uint8_t> argb_buf;
+  uint8_t* src_argb = nullptr;
+
+  if (needs_copy) {
+    argb_buf.resize(width_ * height_ * 4);
+    for (int y = 0; y < height_; ++y) {
+      memcpy(&argb_buf[y * width_ * 4], image->data + y * image->bytes_per_line,
+             width_ * 4);
+    }
+    src_argb = argb_buf.data();
+  } else {
+    src_argb = reinterpret_cast<uint8_t*>(image->data);
+  }
+
+  libyuv::ARGBToNV12(src_argb, width_ * 4, y_plane_.data(), width_,
+                     uv_plane_.data(), width_, width_, height_);
+
+  std::vector<uint8_t> nv12;
+  nv12.reserve(y_plane_.size() + uv_plane_.size());
+  nv12.insert(nv12.end(), y_plane_.begin(), y_plane_.end());
+  nv12.insert(nv12.end(), uv_plane_.begin(), uv_plane_.end());
+
+  if (callback_) {
+    callback_(nv12.data(), width_ * height_ * 3 / 2, width_, height_,
+              display_info_list_[monitor_index_].name.c_str());
+  }
+
+  XDestroyImage(image);
+}

src/screen_capturer/linux/screen_capturer_x11.h

@@ -1,23 +1,24 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2025-05-07
+ * Copyright (c) 2025 by DI JUNKUN, All Rights Reserved.
+ */
+
 #ifndef _SCREEN_CAPTURER_X11_H_
 #define _SCREEN_CAPTURER_X11_H_
 
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/extensions/Xrandr.h>
+
 #include <atomic>
+#include <cstring>
 #include <functional>
-#include <string>
+#include <iostream>
 #include <thread>
+#include <vector>
 
 #include "screen_capturer.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include <libavcodec/avcodec.h>
-#include <libavdevice/avdevice.h>
-#include <libavformat/avformat.h>
-#include <libavutil/imgutils.h>
-#include <libswscale/swscale.h>
-#ifdef __cplusplus
-};
-#endif
 
 class ScreenCapturerX11 : public ScreenCapturer {
  public:
@@ -25,60 +26,39 @@ class ScreenCapturerX11 : public ScreenCapturer {
   ~ScreenCapturerX11();
 
  public:
-  virtual int Init(const RECORD_DESKTOP_RECT &rect, const int fps,
-                   cb_desktop_data cb);
+  int Init(const int fps, cb_desktop_data cb) override;
+  int Destroy() override;
+  int Start() override;
+  int Stop() override;
 
-  virtual int Destroy();
+  int Pause(int monitor_index) override;
+  int Resume(int monitor_index) override;
 
-  virtual int Start();
+  int SwitchTo(int monitor_index) override;
 
-  virtual int Stop();
-
-  int Pause();
-  int Resume();
+  std::vector<DisplayInfo> GetDisplayInfoList() override;
 
   void OnFrame();
 
- protected:
-  void CleanUp();
-
  private:
-  std::atomic_bool _running;
-  std::atomic_bool _paused;
-  std::atomic_bool _inited;
+  Display* display_ = nullptr;
+  Window root_ = 0;
+  XRRScreenResources* screen_res_ = nullptr;
+  int left_ = 0;
+  int top_ = 0;
+  int width_ = 0;
+  int height_ = 0;
+  std::thread thread_;
+  std::atomic<bool> running_{false};
+  std::atomic<bool> paused_{false};
+  std::atomic<int> monitor_index_{0};
+  int fps_ = 30;
+  cb_desktop_data callback_;
+  std::vector<DisplayInfo> display_info_list_;
 
-  std::thread _thread;
-
-  std::string _device_name;
-
-  RECORD_DESKTOP_RECT _rect;
-
-  int _fps;
-
-  cb_desktop_data _on_data;
-
- private:
-  int i_ = 0;
-  int videoindex_ = 0;
-  int got_picture_ = 0;
-  int fps_ = 0;
-  bool inited_ = false;
-
-  // ffmpeg
-  AVFormatContext *pFormatCtx_ = nullptr;
-  AVCodecContext *pCodecCtx_ = nullptr;
-  AVCodec *pCodec_ = nullptr;
-  AVCodecParameters *pCodecParam_ = nullptr;
-  AVDictionary *options_ = nullptr;
-  AVInputFormat *ifmt_ = nullptr;
-  AVFrame *pFrame_ = nullptr;
-  AVFrame *pFrameNv12_ = nullptr;
-  AVPacket *packet_ = nullptr;
-  struct SwsContext *img_convert_ctx_ = nullptr;
-
-  // thread
-  std::thread capture_thread_;
-  std::atomic_bool running_;
+  // 缓冲区
+  std::vector<uint8_t> y_plane_;
+  std::vector<uint8_t> uv_plane_;
 };
 
 #endif

src/screen_capturer/linux/x11_session.h

@@ -1,37 +0,0 @@
-#ifndef _X11_SESSION_H_
-#define _X11_SESSION_H_
-
-class X11Session {
- public:
-  struct x11_session_frame {
-    unsigned int width;
-    unsigned int height;
-    unsigned int row_pitch;
-
-    const unsigned char *data;
-  };
-
-  class x11_session_observer {
-   public:
-    virtual ~x11_session_observer() {}
-    virtual void OnFrame(const x11_session_frame &frame) = 0;
-  };
-
- public:
-  virtual void Release() = 0;
-
-  virtual int Initialize() = 0;
-
-  virtual void RegisterObserver(x11_session_observer *observer) = 0;
-
-  virtual int Start() = 0;
-  virtual int Stop() = 0;
-
-  virtual int Pause() = 0;
-  virtual int Resume() = 0;
-
- protected:
-  virtual ~X11Session(){};
-};
-
-#endif

src/screen_capturer/linux/x11_session_impl.cpp

@@ -1,49 +0,0 @@
-#include "x11_session_impl.h"
-
-#include <atomic>
-#include <functional>
-#include <iostream>
-#include <memory>
-
-#define CHECK_INIT                            \
-  if (!is_initialized_) {                     \
-    std::cout << "AE_NEED_INIT" << std::endl; \
-    return 4;                                 \
-  }
-
-X11SessionImpl::X11SessionImpl() {}
-
-X11SessionImpl::~X11SessionImpl() {
-  Stop();
-  CleanUp();
-}
-
-void X11SessionImpl::Release() { delete this; }
-
-int X11SessionImpl::Initialize() { return 0; }
-
-void X11SessionImpl::RegisterObserver(x11_session_observer *observer) {
-  observer_ = observer;
-}
-
-int X11SessionImpl::Start() {
-  if (is_running_) return 0;
-
-  int error = 1;
-
-  CHECK_INIT;
-
-  return error;
-}
-
-int X11SessionImpl::Stop() { return 0; }
-
-int X11SessionImpl::Pause() { return 0; }
-
-int X11SessionImpl::Resume() { return 0; }
-
-void X11SessionImpl::OnFrame() {}
-
-void X11SessionImpl::OnClosed() {}
-
-void X11SessionImpl::CleanUp() {}

src/screen_capturer/linux/x11_session_impl.h

@@ -1,44 +0,0 @@
-#ifndef _WGC_SESSION_IMPL_H_
-#define _WGC_SESSION_IMPL_H_
-
-#include <mutex>
-#include <thread>
-
-#include "x11_session.h"
-
-class X11SessionImpl : public X11Session {
- public:
-  X11SessionImpl();
-  ~X11SessionImpl() override;
-
- public:
-  void Release() override;
-
-  int Initialize() override;
-
-  void RegisterObserver(x11_session_observer *observer) override;
-
-  int Start() override;
-  int Stop() override;
-
-  int Pause() override;
-  int Resume() override;
-
- private:
-  void OnFrame();
-  void OnClosed();
-
-  void CleanUp();
-
-  // void message_func();
-
- private:
-  std::mutex lock_;
-  bool is_initialized_ = false;
-  bool is_running_ = false;
-  bool is_paused_ = false;
-
-  x11_session_observer *observer_ = nullptr;
-};
-
-#endif

src/screen_capturer/macosx/avfoundation/screen_capturer_avf.cpp

@@ -1,212 +0,0 @@
-#include "screen_capturer_avf.h"
-
-#include <ApplicationServices/ApplicationServices.h>
-
-#include <iostream>
-
-#include "rd_log.h"
-
-#define USE_SCALE_FACTOR 0
-
-ScreenCapturerAvf::ScreenCapturerAvf() {}
-
-ScreenCapturerAvf::~ScreenCapturerAvf() {
-  if (inited_ && capture_thread_.joinable()) {
-    capture_thread_.join();
-    inited_ = false;
-  }
-
-  if (nv12_frame_) {
-    delete[] nv12_frame_;
-    nv12_frame_ = nullptr;
-  }
-
-  if (pFormatCtx_) {
-    avformat_close_input(&pFormatCtx_);
-    pFormatCtx_ = nullptr;
-  }
-
-  if (pCodecCtx_) {
-    avcodec_free_context(&pCodecCtx_);
-    pCodecCtx_ = nullptr;
-  }
-
-  if (options_) {
-    av_dict_free(&options_);
-    options_ = nullptr;
-  }
-
-  if (pFrame_) {
-    av_frame_free(&pFrame_);
-    pFrame_ = nullptr;
-  }
-
-  if (packet_) {
-    av_packet_free(&packet_);
-    packet_ = nullptr;
-  }
-
-#if USE_SCALE_FACTOR
-  if (img_convert_ctx_) {
-    sws_freeContext(img_convert_ctx_);
-    img_convert_ctx_ = nullptr;
-  }
-#endif
-}
-
-int ScreenCapturerAvf::Init(const int fps, cb_desktop_data cb) {
-  if (cb) {
-    _on_data = cb;
-  }
-
-  av_log_set_level(AV_LOG_QUIET);
-
-  pFormatCtx_ = avformat_alloc_context();
-
-  avdevice_register_all();
-
-  // grabbing frame rate
-  av_dict_set(&options_, "framerate", "60", 0);
-  av_dict_set(&options_, "pixel_format", "nv12", 0);
-  // show remote cursor
-  av_dict_set(&options_, "capture_cursor", "0", 0);
-  // Make the grabbed area follow the mouse
-  // av_dict_set(&options_, "follow_mouse", "centered", 0);
-  // Video frame size. The default is to capture the full screen
-  // av_dict_set(&options_, "video_size", "1440x900", 0);
-  ifmt_ = (AVInputFormat *)av_find_input_format("avfoundation");
-  if (!ifmt_) {
-    printf("Couldn't find_input_format\n");
-  }
-
-  // Grab at position 10,20
-  if (avformat_open_input(&pFormatCtx_, "Capture screen 0", ifmt_, &options_) !=
-      0) {
-    printf("Couldn't open input stream.\n");
-    return -1;
-  }
-
-  if (avformat_find_stream_info(pFormatCtx_, NULL) < 0) {
-    printf("Couldn't find stream information.\n");
-    return -1;
-  }
-
-  videoindex_ = -1;
-  for (i_ = 0; i_ < pFormatCtx_->nb_streams; i_++)
-    if (pFormatCtx_->streams[i_]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
-      videoindex_ = i_;
-      break;
-    }
-  if (videoindex_ == -1) {
-    printf("Didn't find a video stream.\n");
-    return -1;
-  }
-
-  pCodecParam_ = pFormatCtx_->streams[videoindex_]->codecpar;
-
-  pCodecCtx_ = avcodec_alloc_context3(NULL);
-  avcodec_parameters_to_context(pCodecCtx_, pCodecParam_);
-
-  pCodec_ = const_cast<AVCodec *>(avcodec_find_decoder(pCodecCtx_->codec_id));
-  if (pCodec_ == NULL) {
-    printf("Codec not found.\n");
-    return -1;
-  }
-  if (avcodec_open2(pCodecCtx_, pCodec_, NULL) < 0) {
-    printf("Could not open codec.\n");
-    return -1;
-  }
-
-  const int screen_w = pFormatCtx_->streams[videoindex_]->codecpar->width;
-  const int screen_h = pFormatCtx_->streams[videoindex_]->codecpar->height;
-
-  pFrame_ = av_frame_alloc();
-  pFrame_->width = screen_w;
-  pFrame_->height = screen_h;
-
-#if USE_SCALE_FACTOR
-  pFrame_resized_ = av_frame_alloc();
-  pFrame_resized_->width = CGDisplayPixelsWide(CGMainDisplayID());
-  pFrame_resized_->height = CGDisplayPixelsHigh(CGMainDisplayID());
-
-  img_convert_ctx_ =
-      sws_getContext(pFrame_->width, pFrame_->height, pCodecCtx_->pix_fmt,
-                     pFrame_resized_->width, pFrame_resized_->height,
-                     AV_PIX_FMT_NV12, SWS_BICUBIC, NULL, NULL, NULL);
-#endif
-
-  if (!nv12_frame_) {
-    nv12_frame_ = new unsigned char[screen_w * screen_h * 3 / 2];
-  }
-
-  packet_ = (AVPacket *)av_malloc(sizeof(AVPacket));
-
-  inited_ = true;
-
-  return 0;
-}
-
-int ScreenCapturerAvf::Destroy() {
-  running_ = false;
-  return 0;
-}
-
-int ScreenCapturerAvf::Start() {
-  if (running_) {
-    return 0;
-  }
-
-  running_ = true;
-  capture_thread_ = std::thread([this]() {
-    while (running_) {
-      if (av_read_frame(pFormatCtx_, packet_) >= 0) {
-        if (packet_->stream_index == videoindex_) {
-          avcodec_send_packet(pCodecCtx_, packet_);
-          av_packet_unref(packet_);
-          got_picture_ = avcodec_receive_frame(pCodecCtx_, pFrame_);
-
-          if (!got_picture_) {
-#if USE_SCALE_FACTOR
-            av_image_fill_arrays(pFrame_resized_->data,
-                                 pFrame_resized_->linesize, nv12_frame_,
-                                 AV_PIX_FMT_NV12, pFrame_resized_->width,
-                                 pFrame_resized_->height, 1);
-
-            sws_scale(img_convert_ctx_, pFrame_->data, pFrame_->linesize, 0,
-                      pFrame_->height, pFrame_resized_->data,
-                      pFrame_resized_->linesize);
-
-            _on_data((unsigned char *)nv12_frame_,
-                     pFrame_resized_->width * pFrame_resized_->height * 3 / 2,
-                     pFrame_resized_->width, pFrame_resized_->height);
-#else
-            memcpy(nv12_frame_, pFrame_->data[0],
-                   pFrame_->linesize[0] * pFrame_->height);
-            memcpy(nv12_frame_ + pFrame_->linesize[0] * pFrame_->height,
-                   pFrame_->data[1],
-                   pFrame_->linesize[1] * pFrame_->height / 2);
-            _on_data((unsigned char *)nv12_frame_,
-                     pFrame_->width * pFrame_->height * 3 / 2, pFrame_->width,
-                     pFrame_->height);
-#endif
-          }
-        }
-      }
-    }
-  });
-
-  return 0;
-}
-
-int ScreenCapturerAvf::Stop() {
-  running_ = false;
-  return 0;
-}
-
-int ScreenCapturerAvf::Pause() { return 0; }
-
-int ScreenCapturerAvf::Resume() { return 0; }
-
-void ScreenCapturerAvf::OnFrame() {}
-
-void ScreenCapturerAvf::CleanUp() {}

src/screen_capturer/macosx/avfoundation/screen_capturer_avf.h

@@ -1,87 +0,0 @@
-/*
- * @Author: DI JUNKUN
- * @Date: 2023-12-01
- * Copyright (c) 2023 by DI JUNKUN, All Rights Reserved.
- */
-
-#ifndef _SCREEN_CAPTURER_AVF_H_
-#define _SCREEN_CAPTURER_AVF_H_
-
-#include <atomic>
-#include <functional>
-#include <string>
-#include <thread>
-
-#include "screen_capturer.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include <libavcodec/avcodec.h>
-#include <libavdevice/avdevice.h>
-#include <libavformat/avformat.h>
-#include <libavutil/imgutils.h>
-#include <libswscale/swscale.h>
-#ifdef __cplusplus
-};
-#endif
-
-class ScreenCapturerAvf : public ScreenCapturer {
- public:
-  ScreenCapturerAvf();
-  ~ScreenCapturerAvf();
-
- public:
-  virtual int Init(const int fps, cb_desktop_data cb);
-
-  virtual int Destroy();
-
-  virtual int Start();
-
-  virtual int Stop();
-
-  int Pause();
-  int Resume();
-
-  void OnFrame();
-
- protected:
-  void CleanUp();
-
- private:
-  std::atomic_bool _paused;
-  std::atomic_bool _inited;
-
-  std::thread _thread;
-
-  std::string _device_name;
-
-  int _fps;
-
-  cb_desktop_data _on_data;
-
- private:
-  int i_ = 0;
-  int videoindex_ = 0;
-  int got_picture_ = 0;
-  bool inited_ = false;
-
-  // ffmpeg
-  AVFormatContext *pFormatCtx_ = nullptr;
-  AVCodecContext *pCodecCtx_ = nullptr;
-  AVCodec *pCodec_ = nullptr;
-  AVCodecParameters *pCodecParam_ = nullptr;
-  AVDictionary *options_ = nullptr;
-  AVInputFormat *ifmt_ = nullptr;
-  AVFrame *pFrame_ = nullptr;
-  AVFrame *pFrame_resized_ = nullptr;
-  AVPacket *packet_ = nullptr;
-  struct SwsContext *img_convert_ctx_ = nullptr;
-  unsigned char *nv12_frame_ = nullptr;
-
-  // thread
-  std::thread capture_thread_;
-  std::atomic_bool running_;
-};
-
-#endif

src/screen_capturer/macosx/core_graphics/screen_capturer_cg.cpp

@@ -1,104 +0,0 @@
-#include <IOSurface/IOSurface.h>
-
-#include <utility>
-
-#include "rd_log.h"
-#include "screen_capturer_cgd.h"
-
-ScreenCapturerCg::ScreenCapturerCg() {}
-
-ScreenCapturerCg::~ScreenCapturerCg() {}
-
-int ScreenCapturerCg::Init(const int fps, cb_desktop_data cb) {
-  if (cb) {
-    _on_data = cb;
-  }
-
-  size_t pixel_width = 1280;
-  size_t pixel_height = 720;
-  CGDirectDisplayID display_id = 0;
-
-  CGDisplayStreamFrameAvailableHandler handler =
-      ^(CGDisplayStreamFrameStatus status, uint64_t display_time,
-        IOSurfaceRef frame_surface, CGDisplayStreamUpdateRef updateRef) {
-        if (status == kCGDisplayStreamFrameStatusStopped) return;
-        // Only pay attention to frame updates.
-        if (status != kCGDisplayStreamFrameStatusFrameComplete) return;
-
-        // size_t count = 0;
-        // const CGRect* rects = CGDisplayStreamUpdateGetRects(
-        //     updateRef, kCGDisplayStreamUpdateDirtyRects, &count);
-
-        // 获取帧数据
-        void* frameData = IOSurfaceGetBaseAddressOfPlane(frame_surface, 0);
-        size_t width = IOSurfaceGetWidthOfPlane(frame_surface, 0);
-        size_t height = IOSurfaceGetHeightOfPlane(frame_surface, 0);
-      };
-
-  CFDictionaryRef properties_dictionary = CFDictionaryCreate(
-      kCFAllocatorDefault, (const void*[]){kCGDisplayStreamShowCursor},
-      (const void*[]){kCFBooleanFalse}, 1, &kCFTypeDictionaryKeyCallBacks,
-      &kCFTypeDictionaryValueCallBacks);
-
-  CGDisplayStreamRef display_stream =
-      CGDisplayStreamCreate(display_id, pixel_width, pixel_height, 'BGRA',
-                            properties_dictionary, handler);
-
-  if (display_stream) {
-    CGError error = CGDisplayStreamStart(display_stream);
-    if (error != kCGErrorSuccess) return -1;
-
-    CFRunLoopSourceRef source = CGDisplayStreamGetRunLoopSource(display_stream);
-    CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
-    display_streams_.push_back(display_stream);
-  }
-
-  CFRelease(properties_dictionary);
-
-  return 0;
-}
-
-int ScreenCapturerCg::Destroy() {
-  running_ = false;
-  return 0;
-}
-
-int ScreenCapturerCg::Start() {
-  if (_running) {
-    return 0;
-  }
-
-  running_ = true;
-  capture_thread_ = std::thread([this]() {
-    while (running_) {
-      CFRunLoopRun();
-    }
-  });
-
-  return 0;
-}
-
-int ScreenCapturerCg::Stop() {
-  running_ = false;
-  return 0;
-}
-
-int ScreenCapturerCg::Pause() { return 0; }
-
-int ScreenCapturerCg::Resume() { return 0; }
-
-void ScreenCapturerCg::OnFrame() {}
-
-void ScreenCapturerCg::CleanUp() {}
-
-//
-
-void ScreenCapturerCg::UnregisterRefreshAndMoveHandlers() {
-  for (CGDisplayStreamRef stream : display_streams_) {
-    CFRunLoopSourceRef source = CGDisplayStreamGetRunLoopSource(stream);
-    CFRunLoopRemoveSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
-    CGDisplayStreamStop(stream);
-    CFRelease(stream);
-  }
-  display_streams_.clear();
-}

src/screen_capturer/macosx/core_graphics/screen_capturer_cg.h

@@ -1,56 +0,0 @@
-
-/*
- * @Author: DI JUNKUN
- * @Date: 2024-10-16
- * Copyright (c) 2024 by DI JUNKUN, All Rights Reserved.
- */
-
-#ifndef _SCREEN_CAPTURER_CGD_H_
-#define _SCREEN_CAPTURER_CGD_H_
-
-#include <CoreGraphics/CoreGraphics.h>
-
-#include <atomic>
-#include <functional>
-#include <memory>
-#include <string>
-#include <thread>
-#include <vector>
-
-#include "screen_capturer.h"
-
-class ScreenCapturerCg : public ScreenCapturer {
- public:
-  ScreenCapturerCg();
-  ~ScreenCapturerCg();
-
- public:
-  virtual int Init(const int fps, cb_desktop_data cb);
-
-  virtual int Destroy();
-
-  virtual int Start();
-
-  virtual int Stop();
-
-  int Pause();
-
-  int Resume();
-
-  void OnFrame();
-
- protected:
-  void CleanUp();
-
- private:
-  int _fps;
-  cb_desktop_data _on_data;
-
-  // thread
-  std::thread capture_thread_;
-  std::atomic_bool running_;
-
- private:
-};
-
-#endif

src/screen_capturer/macosx/screen_capturer_kit/screen_capturer_sck.cpp

@@ -1,51 +0,0 @@
-#include "screen_capturer_sck.h"
-
-#include "rd_log.h"
-
-ScreenCapturerSck::ScreenCapturerSck() {}
-ScreenCapturerSck::~ScreenCapturerSck() {
-  // if (inited_ && capture_thread_.joinable()) {
-  //   capture_thread_.join();
-  //   inited_ = false;
-  // }
-}
-
-int ScreenCapturerSck::Init(const int fps, cb_desktop_data cb) {
-  if (cb) {
-    on_data_ = cb;
-  } else {
-    LOG_ERROR("cb is null");
-    return -1;
-  }
-
-  screen_capturer_sck_impl_ = CreateScreenCapturerSck();
-  screen_capturer_sck_impl_->Init(fps, on_data_);
-
-  return 0;
-}
-
-int ScreenCapturerSck::Destroy() { return 0; }
-
-int ScreenCapturerSck::Start() {
-  // if (running_) {
-  //   return 0;
-  // }
-
-  // running_ = true;
-  // capture_thread_ = std::thread([this]() {
-  //   while (running_) {
-  //   }
-  // });
-
-  return 0;
-}
-
-int ScreenCapturerSck::Stop() { return 0; }
-
-int ScreenCapturerSck::Pause() { return 0; }
-
-int ScreenCapturerSck::Resume() { return 0; }
-
-void ScreenCapturerSck::OnFrame() {}
-
-void ScreenCapturerSck::CleanUp() {}

src/screen_capturer/macosx/screen_capturer_kit/screen_capturer_sck_impl.mm

@@ -1,256 +0,0 @@
-/*
- *  Copyright (c) 2024 The WebRTC project authors. All Rights Reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#include "screen_capturer_sck.h"
-
-#include "rd_log.h"
-#include <CoreGraphics/CoreGraphics.h>
-#include <IOSurface/IOSurface.h>
-#include <ScreenCaptureKit/ScreenCaptureKit.h>
-#include <atomic>
-#include <mutex>
-
-class ScreenCapturerSckImpl;
-
-// The ScreenCaptureKit API was available in macOS 12.3, but full-screen capture
-// was reported to be broken before macOS 13 - see http://crbug.com/40234870.
-// Also, the `SCContentFilter` fields `contentRect` and `pointPixelScale` were
-// introduced in macOS 14.
-API_AVAILABLE(macos(14.0))
-@interface SckHelper : NSObject <SCStreamDelegate, SCStreamOutput>
-
-- (instancetype)initWithCapturer:(ScreenCapturerSckImpl *)capturer;
-
-- (void)onShareableContentCreated:(SCShareableContent *)content;
-
-// Called just before the capturer is destroyed. This avoids a dangling pointer,
-// and prevents any new calls into a deleted capturer. If any method-call on the
-// capturer is currently running on a different thread, this blocks until it
-// completes.
-- (void)releaseCapturer;
-@end
-
-class API_AVAILABLE(macos(14.0)) ScreenCapturerSckImpl : public ScreenCapturer {
-public:
-  explicit ScreenCapturerSckImpl();
-
-  ScreenCapturerSckImpl(const ScreenCapturerSckImpl &) = delete;
-  ScreenCapturerSckImpl &operator=(const ScreenCapturerSckImpl &) = delete;
-  ~ScreenCapturerSckImpl();
-
-public:
-  int Init(const int fps, cb_desktop_data cb);
-  void OnReceiveContent(SCShareableContent *content);
-  void OnNewIOSurface(IOSurfaceRef io_surface, CFDictionaryRef attachment);
-
-  virtual int Destroy() { return 0; }
-
-  virtual int Start() { return 0; }
-
-  virtual int Stop() { return 0; }
-
-private:
-  SckHelper *__strong helper_;
-  SCStream *__strong stream_;
-
-  cb_desktop_data _on_data;
-  unsigned char *nv12_frame_ = nullptr;
-  bool permanent_error_ = false;
-  CGDirectDisplayID current_display_ = -1;
-  std::mutex mtx_;
-};
-
-@implementation SckHelper {
-  // This lock is to prevent the capturer being destroyed while an instance
-  // method is still running on another thread.
-  std::mutex helper_mtx_;
-  ScreenCapturerSckImpl *_capturer;
-}
-
-- (instancetype)initWithCapturer:(ScreenCapturerSckImpl *)capturer {
-  self = [super init];
-  if (self) {
-    _capturer = capturer;
-  }
-  return self;
-}
-
-- (void)onShareableContentCreated:(SCShareableContent *)content {
-  std::lock_guard<std::mutex> lock(helper_mtx_);
-  if (_capturer) {
-    _capturer->OnReceiveContent(content);
-  } else {
-    LOG_ERROR("Invalid capturer");
-  }
-}
-
-- (void)stream:(SCStream *)stream
-    didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
-                   ofType:(SCStreamOutputType)type {
-  CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
-  if (!pixelBuffer) {
-    return;
-  }
-
-  IOSurfaceRef ioSurface = CVPixelBufferGetIOSurface(pixelBuffer);
-  if (!ioSurface) {
-    return;
-  }
-
-  CFArrayRef attachmentsArray = CMSampleBufferGetSampleAttachmentsArray(
-      sampleBuffer, /*createIfNecessary=*/false);
-  if (!attachmentsArray || CFArrayGetCount(attachmentsArray) <= 0) {
-    LOG_ERROR("Discarding frame with no attachments");
-    return;
-  }
-
-  CFDictionaryRef attachment =
-      static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(attachmentsArray, 0));
-
-  std::lock_guard<std::mutex> lock(helper_mtx_);
-  if (_capturer) {
-    _capturer->OnNewIOSurface(ioSurface, attachment);
-  }
-}
-
-- (void)releaseCapturer {
-  std::lock_guard<std::mutex> lock(helper_mtx_);
-  _capturer = nullptr;
-}
-
-@end
-
-ScreenCapturerSckImpl::ScreenCapturerSckImpl() {
-  helper_ = [[SckHelper alloc] initWithCapturer:this];
-}
-
-ScreenCapturerSckImpl::~ScreenCapturerSckImpl() {
-  [stream_ stopCaptureWithCompletionHandler:nil];
-  [helper_ releaseCapturer];
-}
-
-int ScreenCapturerSckImpl::Init(const int fps, cb_desktop_data cb) {
-  _on_data = cb;
-
-  SckHelper *local_helper = helper_;
-  auto handler = ^(SCShareableContent *content, NSError *error) {
-    [local_helper onShareableContentCreated:content];
-  };
-
-  [SCShareableContent getShareableContentWithCompletionHandler:handler];
-
-  return 0;
-}
-
-void ScreenCapturerSckImpl::OnReceiveContent(SCShareableContent *content) {
-  if (!content) {
-    LOG_ERROR("getShareableContent failed");
-    permanent_error_ = true;
-    return;
-  }
-
-  if (!content.displays.count) {
-    LOG_ERROR("getShareableContent returned no displays");
-    permanent_error_ = true;
-    return;
-  }
-
-  SCDisplay *captured_display;
-  {
-    std::lock_guard<std::mutex> lock(mtx_);
-    for (SCDisplay *display in content.displays) {
-      if (current_display_ == display.displayID) {
-        captured_display = display;
-        break;
-      }
-    }
-    if (!captured_display) {
-      if (-1 == current_display_) {
-        LOG_ERROR("Full screen capture is not supported, falling back to first "
-                  "display");
-      } else {
-        LOG_ERROR("Display [{}] not found, falling back to first display",
-                  current_display_);
-      }
-      captured_display = content.displays.firstObject;
-    }
-  }
-
-  SCContentFilter *filter =
-      [[SCContentFilter alloc] initWithDisplay:captured_display
-                              excludingWindows:@[]];
-  SCStreamConfiguration *config = [[SCStreamConfiguration alloc] init];
-  config.pixelFormat = kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange;
-  config.showsCursor = false;
-  config.width = filter.contentRect.size.width * filter.pointPixelScale;
-  config.height = filter.contentRect.size.height * filter.pointPixelScale;
-  config.captureResolution = SCCaptureResolutionNominal;
-
-  std::lock_guard<std::mutex> lock(mtx_);
-
-  if (stream_) {
-    LOG_INFO("Updating stream configuration");
-    [stream_ updateContentFilter:filter completionHandler:nil];
-    [stream_ updateConfiguration:config completionHandler:nil];
-  } else {
-    stream_ = [[SCStream alloc] initWithFilter:filter
-                                 configuration:config
-                                      delegate:helper_];
-
-    // TODO: crbug.com/327458809 - Choose an appropriate sampleHandlerQueue for
-    // best performance.
-    NSError *add_stream_output_error;
-    bool add_stream_output_result =
-        [stream_ addStreamOutput:helper_
-                            type:SCStreamOutputTypeScreen
-              sampleHandlerQueue:nil
-                           error:&add_stream_output_error];
-    if (!add_stream_output_result) {
-      stream_ = nil;
-      LOG_ERROR("addStreamOutput failed");
-      permanent_error_ = true;
-      return;
-    }
-
-    auto handler = ^(NSError *error) {
-      if (error) {
-        // It should be safe to access `this` here, because the C++ destructor
-        // calls stopCaptureWithCompletionHandler on the stream, which cancels
-        // this handler.
-        permanent_error_ = true;
-        LOG_ERROR("startCaptureWithCompletionHandler failed");
-      } else {
-        LOG_INFO("Capture started");
-      }
-    };
-
-    [stream_ startCaptureWithCompletionHandler:handler];
-  }
-}
-
-void ScreenCapturerSckImpl::OnNewIOSurface(IOSurfaceRef io_surface,
-                                           CFDictionaryRef attachment) {
-  size_t width = IOSurfaceGetWidth(io_surface);
-  size_t height = IOSurfaceGetHeight(io_surface);
-
-  uint32_t aseed;
-  IOSurfaceLock(io_surface, kIOSurfaceLockReadOnly, &aseed);
-
-  nv12_frame_ =
-      static_cast<unsigned char *>(IOSurfaceGetBaseAddress(io_surface));
-
-  _on_data(nv12_frame_, width * height * 3 / 2, width, height);
-
-  IOSurfaceUnlock(io_surface, kIOSurfaceLockReadOnly, &aseed);
-}
-
-std::unique_ptr<ScreenCapturer> ScreenCapturerSck::CreateScreenCapturerSck() {
-  return std::make_unique<ScreenCapturerSckImpl>();
-}

src/screen_capturer/macosx/screen_capturer_sck.cpp

@@ -0,0 +1,73 @@
+#include "screen_capturer_sck.h"
+
+#include "rd_log.h"
+
+ScreenCapturerSck::ScreenCapturerSck() {}
+ScreenCapturerSck::~ScreenCapturerSck() {}
+
+int ScreenCapturerSck::Init(const int fps, cb_desktop_data cb) {
+  if (cb) {
+    on_data_ = cb;
+  } else {
+    LOG_ERROR("cb is null");
+    return -1;
+  }
+
+  screen_capturer_sck_impl_ = CreateScreenCapturerSck();
+  screen_capturer_sck_impl_->Init(fps, on_data_);
+
+  return 0;
+}
+
+int ScreenCapturerSck::Destroy() {
+  if (screen_capturer_sck_impl_) {
+    screen_capturer_sck_impl_->Destroy();
+  }
+  return 0;
+}
+
+int ScreenCapturerSck::Start() {
+  screen_capturer_sck_impl_->Start();
+  return 0;
+}
+
+int ScreenCapturerSck::Stop() {
+  if (screen_capturer_sck_impl_) {
+    screen_capturer_sck_impl_->Stop();
+  }
+  return 0;
+}
+
+int ScreenCapturerSck::Pause(int monitor_index) {
+  if (screen_capturer_sck_impl_) {
+    return screen_capturer_sck_impl_->Pause(monitor_index);
+  }
+  return 0;
+}
+
+int ScreenCapturerSck::Resume(int monitor_index) {
+  if (screen_capturer_sck_impl_) {
+    return screen_capturer_sck_impl_->Resume(monitor_index);
+  }
+  return 0;
+}
+
+int ScreenCapturerSck::SwitchTo(int monitor_index) {
+  if (screen_capturer_sck_impl_) {
+    return screen_capturer_sck_impl_->SwitchTo(monitor_index);
+  }
+
+  return -1;
+}
+
+std::vector<DisplayInfo> ScreenCapturerSck::GetDisplayInfoList() {
+  if (screen_capturer_sck_impl_) {
+    return screen_capturer_sck_impl_->GetDisplayInfoList();
+  }
+
+  return std::vector<DisplayInfo>();
+}
+
+void ScreenCapturerSck::OnFrame() {}
+
+void ScreenCapturerSck::CleanUp() {}

src/screen_capturer/macosx/screen_capturer_sck.h

@@ -22,17 +22,17 @@ class ScreenCapturerSck : public ScreenCapturer {
   ~ScreenCapturerSck();
 
  public:
-  virtual int Init(const int fps, cb_desktop_data cb);
+  int Init(const int fps, cb_desktop_data cb) override;
+  int Destroy() override;
+  int Start() override;
+  int Stop() override;
 
-  virtual int Destroy();
+  int Pause(int monitor_index) override;
+  int Resume(int monitor_index) override;
 
-  virtual int Start();
+  int SwitchTo(int monitor_index) override;
 
-  virtual int Stop();
-
-  int Pause();
-
-  int Resume();
+  std::vector<DisplayInfo> GetDisplayInfoList() override;
 
   void OnFrame();
 

src/screen_capturer/macosx/screen_capturer_sck_impl.mm

@@ -0,0 +1,488 @@
+/*
+ *  Copyright (c) 2024 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "screen_capturer_sck.h"
+
+#include <ApplicationServices/ApplicationServices.h>
+#include <CoreGraphics/CoreGraphics.h>
+#include <IOKit/IOKitLib.h>
+#include <IOKit/graphics/IOGraphicsLib.h>
+#include <IOSurface/IOSurface.h>
+#include <ScreenCaptureKit/ScreenCaptureKit.h>
+#include <atomic>
+#include <mutex>
+#include <vector>
+#include "display_info.h"
+#include "rd_log.h"
+
+static const int kFullDesktopScreenId = -1;
+class ScreenCapturerSckImpl;
+
+// The ScreenCaptureKit API was available in macOS 12.3, but full-screen capture
+// was reported to be broken before macOS 13 - see http://crbug.com/40234870.
+// Also, the `SCContentFilter` fields `contentRect` and `pointPixelScale` were
+// introduced in macOS 14.
+API_AVAILABLE(macos(14.0))
+@interface SckHelper : NSObject <SCStreamDelegate, SCStreamOutput>
+
+- (instancetype)initWithCapturer:(ScreenCapturerSckImpl *)capturer;
+
+- (void)onShareableContentCreated:(SCShareableContent *)content;
+
+// Called just before the capturer is destroyed. This avoids a dangling pointer,
+// and prevents any new calls into a deleted capturer. If any method-call on the
+// capturer is currently running on a different thread, this blocks until it
+// completes.
+- (void)releaseCapturer;
+@end
+
+class API_AVAILABLE(macos(14.0)) ScreenCapturerSckImpl : public ScreenCapturer {
+ public:
+  explicit ScreenCapturerSckImpl();
+
+  ScreenCapturerSckImpl(const ScreenCapturerSckImpl &) = delete;
+  ScreenCapturerSckImpl &operator=(const ScreenCapturerSckImpl &) = delete;
+  ~ScreenCapturerSckImpl();
+
+ public:
+  int Init(const int fps, cb_desktop_data cb) override;
+
+  int Start() override;
+
+  int SwitchTo(int monitor_index) override;
+
+  int Destroy() override;
+
+  int Stop() override;
+
+  int Pause(int monitor_index) override { return 0; }
+
+  int Resume(int monitor_index) override { return 0; }
+
+  std::vector<DisplayInfo> GetDisplayInfoList() override { return display_info_list_; }
+
+ private:
+  std::vector<DisplayInfo> display_info_list_;
+  std::map<int, CGDirectDisplayID> display_id_map_;
+  std::map<CGDirectDisplayID, int> display_id_map_reverse_;
+  std::map<CGDirectDisplayID, std::string> display_id_name_map_;
+  unsigned char *nv12_frame_ = nullptr;
+  int width_ = 0;
+  int height_ = 0;
+  int fps_ = 30;
+
+ public:
+  // Called by SckHelper when shareable content is returned by ScreenCaptureKit. `content` will be
+  // nil if an error occurred. May run on an arbitrary thread.
+  void OnShareableContentCreated(SCShareableContent *content);
+  // Called by SckHelper to notify of a newly captured frame. May run on an arbitrary thread.
+  // void OnNewIOSurface(IOSurfaceRef io_surface, CFDictionaryRef attachment);
+  void OnNewCVPixelBuffer(CVPixelBufferRef pixelBuffer, CFDictionaryRef attachment);
+
+ private:
+  // Called when starting the capturer or the configuration has changed (either from a
+  // SwitchTo() call, or the screen-resolution has changed). This tells SCK to fetch new
+  // shareable content, and the completion-handler will either start a new stream, or reconfigure
+  // the existing stream. Runs on the caller's thread.
+  void StartOrReconfigureCapturer();
+  // Helper object to receive Objective-C callbacks from ScreenCaptureKit and call into this C++
+  // object. The helper may outlive this C++ instance, if a completion-handler is passed to
+  // ScreenCaptureKit APIs and the C++ object is deleted before the handler executes.
+  SckHelper *__strong helper_;
+  // Callback for returning captured frames, or errors, to the caller. Only used on the caller's
+  // thread.
+  cb_desktop_data _on_data = nullptr;
+  // Signals that a permanent error occurred. This may be set on any thread, and is read by
+  // CaptureFrame() which runs on the caller's thread.
+  std::atomic<bool> permanent_error_ = false;
+  // Guards some variables that may be accessed on different threads.
+  std::mutex lock_;
+  // Provides captured desktop frames.
+  SCStream *__strong stream_;
+  // Currently selected display, or 0 if the full desktop is selected. This capturer does not
+  // support full-desktop capture, and will fall back to the first display.
+  CGDirectDisplayID current_display_ = 0;
+};
+
+std::string GetDisplayName(CGDirectDisplayID display_id) {
+  io_iterator_t iter;
+  io_service_t serv = 0, matched_serv = 0;
+
+  CFMutableDictionaryRef matching = IOServiceMatching("IODisplayConnect");
+  if (IOServiceGetMatchingServices(kIOMainPortDefault, matching, &iter) != KERN_SUCCESS) {
+    return "";
+  }
+
+  while ((serv = IOIteratorNext(iter)) != 0) {
+    CFDictionaryRef info = IODisplayCreateInfoDictionary(serv, kIODisplayOnlyPreferredName);
+    if (info) {
+      CFNumberRef vendorID = (CFNumberRef)CFDictionaryGetValue(info, CFSTR(kDisplayVendorID));
+      CFNumberRef productID = (CFNumberRef)CFDictionaryGetValue(info, CFSTR(kDisplayProductID));
+      uint32_t vID = 0, pID = 0;
+      if (vendorID && productID && CFNumberGetValue(vendorID, kCFNumberIntType, &vID) &&
+          CFNumberGetValue(productID, kCFNumberIntType, &pID) &&
+          vID == CGDisplayVendorNumber(display_id) && pID == CGDisplayModelNumber(display_id)) {
+        matched_serv = serv;
+        CFRelease(info);
+        break;
+      }
+      CFRelease(info);
+    }
+    IOObjectRelease(serv);
+  }
+  IOObjectRelease(iter);
+
+  if (!matched_serv) return "";
+
+  CFDictionaryRef display_info =
+      IODisplayCreateInfoDictionary(matched_serv, kIODisplayOnlyPreferredName);
+  IOObjectRelease(matched_serv);
+  if (!display_info) return "";
+
+  CFDictionaryRef product_name_dict =
+      (CFDictionaryRef)CFDictionaryGetValue(display_info, CFSTR(kDisplayProductName));
+  std::string result;
+  if (product_name_dict) {
+    CFIndex count = CFDictionaryGetCount(product_name_dict);
+    if (count > 0) {
+      std::vector<const void *> keys(count);
+      std::vector<const void *> values(count);
+      CFDictionaryGetKeysAndValues(product_name_dict, keys.data(), values.data());
+      CFStringRef name_ref = (CFStringRef)values[0];
+      if (name_ref) {
+        CFIndex maxSize =
+            CFStringGetMaximumSizeForEncoding(CFStringGetLength(name_ref), kCFStringEncodingUTF8) +
+            1;
+        std::vector<char> buffer(maxSize);
+        if (CFStringGetCString(name_ref, buffer.data(), buffer.size(), kCFStringEncodingUTF8)) {
+          result = buffer.data();
+        }
+      }
+    }
+  }
+  CFRelease(display_info);
+  return result;
+}
+
+ScreenCapturerSckImpl::ScreenCapturerSckImpl() {
+  helper_ = [[SckHelper alloc] initWithCapturer:this];
+}
+
+ScreenCapturerSckImpl::~ScreenCapturerSckImpl() {
+  display_info_list_.clear();
+  display_id_map_.clear();
+  display_id_map_reverse_.clear();
+  display_id_name_map_.clear();
+
+  if (nv12_frame_) {
+    delete[] nv12_frame_;
+    nv12_frame_ = nullptr;
+  }
+
+  [stream_ stopCaptureWithCompletionHandler:nil];
+  [helper_ releaseCapturer];
+}
+
+int ScreenCapturerSckImpl::Init(const int fps, cb_desktop_data cb) {
+  _on_data = cb;
+
+  dispatch_semaphore_t sema = dispatch_semaphore_create(0);
+  __block SCShareableContent *content = nil;
+
+  [SCShareableContent
+      getShareableContentWithCompletionHandler:^(SCShareableContent *result, NSError *error) {
+        if (error) {
+          NSLog(@"Failed to get shareable content: %@", error);
+        } else {
+          content = result;
+        }
+        dispatch_semaphore_signal(sema);
+      }];
+  dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
+
+  if (!content || content.displays.count == 0) {
+    LOG_ERROR("Failed to get display info");
+    return 0;
+  }
+
+  CGDirectDisplayID displays[10];
+  uint32_t count;
+  CGGetActiveDisplayList(10, displays, &count);
+
+  int unnamed_count = 1;
+  for (SCDisplay *display in content.displays) {
+    CGDirectDisplayID display_id = display.displayID;
+    CGRect bounds = CGDisplayBounds(display_id);
+    bool is_primary = CGDisplayIsMain(display_id);
+
+    std::string name;
+    name = GetDisplayName(display_id);
+
+    if (name.empty()) {
+      name = "Display " + std::to_string(unnamed_count++);
+    }
+
+    DisplayInfo info((void *)(uintptr_t)display_id, name, is_primary,
+                     static_cast<int>(bounds.origin.x), static_cast<int>(bounds.origin.y),
+                     static_cast<int>(bounds.origin.x + bounds.size.width),
+                     static_cast<int>(bounds.origin.y + bounds.size.height));
+
+    display_info_list_.push_back(info);
+    display_id_map_[display_info_list_.size() - 1] = display_id;
+    display_id_map_reverse_[display_id] = display_info_list_.size() - 1;
+    display_id_name_map_[display_id] = name;
+  }
+
+  return 0;
+}
+
+int ScreenCapturerSckImpl::Start() {
+  StartOrReconfigureCapturer();
+  return 0;
+}
+
+int ScreenCapturerSckImpl::SwitchTo(int monitor_index) {
+  if (stream_) {
+    [stream_ stopCaptureWithCompletionHandler:^(NSError *error) {
+      std::lock_guard<std::mutex> lock(lock_);
+      stream_ = nil;
+      current_display_ = display_id_map_[monitor_index];
+      StartOrReconfigureCapturer();
+    }];
+  } else {
+    current_display_ = display_id_map_[monitor_index];
+    StartOrReconfigureCapturer();
+  }
+  return 0;
+}
+
+int ScreenCapturerSckImpl::Destroy() {
+  std::lock_guard<std::mutex> lock(lock_);
+  if (stream_) {
+    LOG_INFO("Destroying stream");
+    [stream_ stopCaptureWithCompletionHandler:nil];
+    stream_ = nil;
+  }
+  current_display_ = 0;
+  permanent_error_ = false;
+  _on_data = nullptr;
+  [helper_ releaseCapturer];
+  helper_ = nil;
+
+  return 0;
+}
+
+int ScreenCapturerSckImpl::Stop() {
+  std::lock_guard<std::mutex> lock(lock_);
+  if (stream_) {
+    LOG_INFO("Stopping stream");
+    [stream_ stopCaptureWithCompletionHandler:nil];
+    stream_ = nil;
+  }
+  current_display_ = 0;
+
+  return 0;
+}
+
+void ScreenCapturerSckImpl::OnShareableContentCreated(SCShareableContent *content) {
+  if (!content) {
+    LOG_ERROR("getShareableContent failed");
+    permanent_error_ = true;
+    return;
+  }
+
+  if (!content.displays.count) {
+    LOG_ERROR("getShareableContent returned no displays");
+    permanent_error_ = true;
+    return;
+  }
+
+  SCDisplay *captured_display;
+  {
+    std::lock_guard<std::mutex> lock(lock_);
+    for (SCDisplay *display in content.displays) {
+      if (current_display_ == display.displayID) {
+        LOG_WARN("current display: {}, name: {}", current_display_,
+                 display_id_name_map_[current_display_]);
+        captured_display = display;
+        break;
+      }
+    }
+    if (!captured_display) {
+      captured_display = content.displays.firstObject;
+      current_display_ = captured_display.displayID;
+    }
+  }
+
+  SCContentFilter *filter = [[SCContentFilter alloc] initWithDisplay:captured_display
+                                                    excludingWindows:@[]];
+  SCStreamConfiguration *config = [[SCStreamConfiguration alloc] init];
+  config.pixelFormat = kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange;
+  config.showsCursor = false;
+  config.width = filter.contentRect.size.width * filter.pointPixelScale;
+  config.height = filter.contentRect.size.height * filter.pointPixelScale;
+  config.captureResolution = SCCaptureResolutionAutomatic;
+  config.minimumFrameInterval = CMTimeMake(1, fps_);
+
+  std::lock_guard<std::mutex> lock(lock_);
+
+  if (stream_) {
+    LOG_INFO("Updating stream configuration");
+    [stream_ updateContentFilter:filter completionHandler:nil];
+    [stream_ updateConfiguration:config completionHandler:nil];
+  } else {
+    stream_ = [[SCStream alloc] initWithFilter:filter configuration:config delegate:helper_];
+
+    // TODO: crbug.com/327458809 - Choose an appropriate sampleHandlerQueue for
+    // best performance.
+    NSError *add_stream_output_error;
+    dispatch_queue_t queue = dispatch_queue_create("ScreenCaptureKit.Queue", DISPATCH_QUEUE_SERIAL);
+    bool add_stream_output_result = [stream_ addStreamOutput:helper_
+                                                        type:SCStreamOutputTypeScreen
+                                          sampleHandlerQueue:queue
+                                                       error:&add_stream_output_error];
+
+    if (!add_stream_output_result) {
+      stream_ = nil;
+      LOG_ERROR("addStreamOutput failed");
+      permanent_error_ = true;
+      return;
+    }
+
+    auto handler = ^(NSError *error) {
+      if (error) {
+        // It should be safe to access `this` here, because the C++ destructor
+        // calls stopCaptureWithCompletionHandler on the stream, which cancels
+        // this handler.
+        permanent_error_ = true;
+        LOG_ERROR("startCaptureWithCompletionHandler failed");
+      } else {
+        LOG_INFO("Capture started");
+      }
+    };
+
+    [stream_ startCaptureWithCompletionHandler:handler];
+  }
+}
+
+void ScreenCapturerSckImpl::OnNewCVPixelBuffer(CVPixelBufferRef pixelBuffer,
+                                               CFDictionaryRef attachment) {
+  size_t width = CVPixelBufferGetWidth(pixelBuffer);
+  size_t height = CVPixelBufferGetHeight(pixelBuffer);
+
+  CVReturn status = CVPixelBufferLockBaseAddress(pixelBuffer, kCVPixelBufferLock_ReadOnly);
+  if (status != kCVReturnSuccess) {
+    LOG_ERROR("Failed to lock CVPixelBuffer base address: %d", status);
+    return;
+  }
+
+  size_t required_size = width * height * 3 / 2;
+  if (!nv12_frame_ || (width_ * height_ * 3 / 2 < required_size)) {
+    delete[] nv12_frame_;
+    nv12_frame_ = new unsigned char[required_size];
+    width_ = width;
+    height_ = height;
+  }
+
+  void *base_y = CVPixelBufferGetBaseAddressOfPlane(pixelBuffer, 0);
+  size_t stride_y = CVPixelBufferGetBytesPerRowOfPlane(pixelBuffer, 0);
+
+  void *base_uv = CVPixelBufferGetBaseAddressOfPlane(pixelBuffer, 1);
+  size_t stride_uv = CVPixelBufferGetBytesPerRowOfPlane(pixelBuffer, 1);
+
+  unsigned char *dst_y = nv12_frame_;
+  for (size_t row = 0; row < height; ++row) {
+    memcpy(dst_y + row * width, static_cast<unsigned char *>(base_y) + row * stride_y, width);
+  }
+
+  unsigned char *dst_uv = nv12_frame_ + width * height;
+  for (size_t row = 0; row < height / 2; ++row) {
+    memcpy(dst_uv + row * width, static_cast<unsigned char *>(base_uv) + row * stride_uv, width);
+  }
+
+  _on_data(nv12_frame_, width * height * 3 / 2, width, height,
+           display_id_name_map_[current_display_].c_str());
+
+  CVPixelBufferUnlockBaseAddress(pixelBuffer, kCVPixelBufferLock_ReadOnly);
+}
+
+void ScreenCapturerSckImpl::StartOrReconfigureCapturer() {
+  // The copy is needed to avoid capturing `this` in the Objective-C block. Accessing `helper_`
+  // inside the block is equivalent to `this->helper_` and would crash (UAF) if `this` is
+  // deleted before the block is executed.
+  SckHelper *local_helper = helper_;
+  auto handler = ^(SCShareableContent *content, NSError *error) {
+    [local_helper onShareableContentCreated:content];
+  };
+  [SCShareableContent getShareableContentWithCompletionHandler:handler];
+}
+
+std::unique_ptr<ScreenCapturer> ScreenCapturerSck::CreateScreenCapturerSck() {
+  return std::make_unique<ScreenCapturerSckImpl>();
+}
+
+@implementation SckHelper {
+  // This lock is to prevent the capturer being destroyed while an instance
+  // method is still running on another thread.
+  std::mutex _capturer_lock;
+  ScreenCapturerSckImpl *_capturer;
+}
+
+- (instancetype)initWithCapturer:(ScreenCapturerSckImpl *)capturer {
+  self = [super init];
+  if (self) {
+    _capturer = capturer;
+  }
+  return self;
+}
+
+- (void)onShareableContentCreated:(SCShareableContent *)content {
+  std::lock_guard<std::mutex> lock(_capturer_lock);
+  if (_capturer) {
+    _capturer->OnShareableContentCreated(content);
+  } else {
+    LOG_ERROR("Invalid capturer");
+  }
+}
+
+- (void)stream:(SCStream *)stream
+    didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
+                   ofType:(SCStreamOutputType)type {
+  CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
+  if (!pixelBuffer) {
+    return;
+  }
+
+  CFRetain(pixelBuffer);
+
+  CFArrayRef attachmentsArray = CMSampleBufferGetSampleAttachmentsArray(sampleBuffer, false);
+  if (!attachmentsArray || CFArrayGetCount(attachmentsArray) == 0) {
+    LOG_ERROR("Discarding frame with no attachments");
+    CFRelease(pixelBuffer);
+    return;
+  }
+
+  CFDictionaryRef attachment =
+      static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(attachmentsArray, 0));
+
+  std::lock_guard<std::mutex> lock(_capturer_lock);
+  if (_capturer) {
+    _capturer->OnNewCVPixelBuffer(pixelBuffer, attachment);
+  }
+
+  CFRelease(pixelBuffer);
+}
+
+- (void)releaseCapturer {
+  std::lock_guard<std::mutex> lock(_capturer_lock);
+  _capturer = nullptr;
+}
+
+@end

src/screen_capturer/screen_capturer.h

@@ -9,9 +9,12 @@
 
 #include <functional>
 
+#include "display_info.h"
+
 class ScreenCapturer {
  public:
-  typedef std::function<void(unsigned char *, int, int, int)> cb_desktop_data;
+  typedef std::function<void(unsigned char*, int, int, int, const char*)>
+      cb_desktop_data;
 
  public:
   virtual ~ScreenCapturer() {}
@@ -19,10 +22,13 @@ class ScreenCapturer {
  public:
   virtual int Init(const int fps, cb_desktop_data cb) = 0;
   virtual int Destroy() = 0;
-
   virtual int Start() = 0;
-
   virtual int Stop() = 0;
+  virtual int Pause(int monitor_index) = 0;
+  virtual int Resume(int monitor_index) = 0;
+
+  virtual std::vector<DisplayInfo> GetDisplayInfoList() = 0;
+  virtual int SwitchTo(int monitor_index) = 0;
 };
 
 #endif

src/screen_capturer/windows/screen_capturer_wgc.cpp

@@ -8,32 +8,58 @@
 #include <iostream>
 
 #include "libyuv.h"
+#include "rd_log.h"
+
+static std::vector<DisplayInfo> gs_display_list;
+
+std::string WideToUtf8(const wchar_t *wideStr) {
+  int size_needed = WideCharToMultiByte(CP_UTF8, 0, wideStr, -1, nullptr, 0,
+                                        nullptr, nullptr);
+  std::string result(size_needed, 0);
+  WideCharToMultiByte(CP_UTF8, 0, wideStr, -1, &result[0], size_needed, nullptr,
+                      nullptr);
+  result.pop_back();
+  return result;
+}
 
 BOOL WINAPI EnumMonitorProc(HMONITOR hmonitor, [[maybe_unused]] HDC hdc,
                             [[maybe_unused]] LPRECT lprc, LPARAM data) {
-  MONITORINFOEX info_ex;
-  info_ex.cbSize = sizeof(MONITORINFOEX);
+  MONITORINFOEX monitor_info_;
+  monitor_info_.cbSize = sizeof(MONITORINFOEX);
 
-  GetMonitorInfo(hmonitor, &info_ex);
-
-  if (info_ex.dwFlags == DISPLAY_DEVICE_MIRRORING_DRIVER) return true;
-
-  if (info_ex.dwFlags & MONITORINFOF_PRIMARY) {
-    *(HMONITOR *)data = hmonitor;
+  if (GetMonitorInfo(hmonitor, &monitor_info_)) {
+    if (monitor_info_.dwFlags & MONITORINFOF_PRIMARY) {
+      gs_display_list.insert(
+          gs_display_list.begin(),
+          {(void *)hmonitor, WideToUtf8(monitor_info_.szDevice),
+           (monitor_info_.dwFlags & MONITORINFOF_PRIMARY) ? true : false,
+           monitor_info_.rcMonitor.left, monitor_info_.rcMonitor.top,
+           monitor_info_.rcMonitor.right, monitor_info_.rcMonitor.bottom});
+      *(HMONITOR *)data = hmonitor;
+    } else {
+      gs_display_list.push_back(DisplayInfo(
+          (void *)hmonitor, WideToUtf8(monitor_info_.szDevice),
+          (monitor_info_.dwFlags & MONITORINFOF_PRIMARY) ? true : false,
+          monitor_info_.rcMonitor.left, monitor_info_.rcMonitor.top,
+          monitor_info_.rcMonitor.right, monitor_info_.rcMonitor.bottom));
+    }
   }
 
+  if (monitor_info_.dwFlags == DISPLAY_DEVICE_MIRRORING_DRIVER) return true;
+
   return true;
 }
 
 HMONITOR GetPrimaryMonitor() {
   HMONITOR hmonitor = nullptr;
 
+  gs_display_list.clear();
   ::EnumDisplayMonitors(NULL, NULL, EnumMonitorProc, (LPARAM)&hmonitor);
 
   return hmonitor;
 }
 
-ScreenCapturerWgc::ScreenCapturerWgc() {}
+ScreenCapturerWgc::ScreenCapturerWgc() : monitor_(nullptr) {}
 
 ScreenCapturerWgc::~ScreenCapturerWgc() {
   Stop();
@@ -64,116 +90,162 @@ bool ScreenCapturerWgc::IsWgcSupported() {
 
 int ScreenCapturerWgc::Init(const int fps, cb_desktop_data cb) {
   int error = 0;
-  if (_inited == true) return error;
+  if (inited_ == true) return error;
 
   // nv12_frame_ = new unsigned char[rect.right * rect.bottom * 3 / 2];
   // nv12_frame_scaled_ = new unsigned char[1280 * 720 * 3 / 2];
 
-  _fps = fps;
+  fps_ = fps;
 
-  _on_data = cb;
+  on_data_ = cb;
 
-  do {
-    if (!IsWgcSupported()) {
-      std::cout << "AE_UNSUPPORT" << std::endl;
-      error = 2;
-      break;
-    }
-
-    session_ = new WgcSessionImpl();
-    if (!session_) {
-      error = -1;
-      std::cout << "AE_WGC_CREATE_CAPTURER_FAILED" << std::endl;
-      break;
-    }
-
-    session_->RegisterObserver(this);
-
-    error = session_->Initialize(GetPrimaryMonitor());
-
-    _inited = true;
-  } while (0);
-
-  if (error != 0) {
+  if (!IsWgcSupported()) {
+    LOG_ERROR("WGC not supported");
+    error = 2;
+    return error;
   }
 
-  return error;
+  monitor_ = GetPrimaryMonitor();
+
+  display_info_list_ = gs_display_list;
+
+  if (display_info_list_.empty()) {
+    LOG_ERROR("No display found");
+    return -1;
+  }
+
+  for (int i = 0; i < display_info_list_.size(); i++) {
+    const auto &display = display_info_list_[i];
+    LOG_INFO(
+        "index: {}, display name: {}, is primary: {}, bounds: ({}, {}) - "
+        "({}, {})",
+        i, display.name, (display.is_primary ? "yes" : "no"), display.left,
+        display.top, display.right, display.bottom);
+
+    sessions_.push_back(
+        {std::make_unique<WgcSessionImpl>(i), false, false, false});
+    sessions_.back().session_->RegisterObserver(this);
+    error = sessions_.back().session_->Initialize((HMONITOR)display.handle);
+    if (error != 0) {
+      return error;
+    }
+    sessions_[i].inited_ = true;
+    inited_ = true;
+  }
+
+  LOG_INFO("Default on monitor {}:{}", monitor_index_,
+           display_info_list_[monitor_index_].name);
+
+  return 0;
 }
 
 int ScreenCapturerWgc::Destroy() { return 0; }
 
 int ScreenCapturerWgc::Start() {
-  if (_running == true) {
-    std::cout << "record desktop duplication is already running" << std::endl;
+  if (running_ == true) {
+    LOG_ERROR("Screen capturer already running");
     return 0;
   }
 
-  if (_inited == false) {
-    std::cout << "AE_NEED_INIT" << std::endl;
+  if (inited_ == false) {
+    LOG_ERROR("Screen capturer not inited");
     return 4;
   }
 
-  _running = true;
-  session_->Start();
+  for (int i = 0; i < sessions_.size(); i++) {
+    if (sessions_[i].inited_ == false) {
+      LOG_ERROR("Session {} not inited", i);
+      continue;
+    }
+
+    if (sessions_[i].running_) {
+      LOG_ERROR("Session {} is already running", i);
+    } else {
+      sessions_[i].session_->Start();
+
+      if (i != 0) {
+        sessions_[i].session_->Pause();
+        sessions_[i].paused_ = true;
+      }
+      sessions_[i].running_ = true;
+    }
+    running_ = true;
+  }
 
   return 0;
 }
 
-int ScreenCapturerWgc::Pause() {
-  _paused = true;
-  if (session_) session_->Pause();
+int ScreenCapturerWgc::Pause(int monitor_index) {
+  if (monitor_index >= sessions_.size() || monitor_index < 0) {
+    LOG_ERROR("Invalid session index: {}", monitor_index);
+    return -1;
+  }
+
+  if (!sessions_[monitor_index].paused_) {
+    sessions_[monitor_index].session_->Pause();
+    sessions_[monitor_index].paused_ = true;
+    LOG_INFO("Pausing session {}", monitor_index);
+  }
   return 0;
 }
 
-int ScreenCapturerWgc::Resume() {
-  _paused = false;
-  if (session_) session_->Resume();
+int ScreenCapturerWgc::Resume(int monitor_index) {
+  if (monitor_index >= sessions_.size() || monitor_index < 0) {
+    LOG_ERROR("Invalid session index: {}", monitor_index);
+    return -1;
+  }
+
+  if (sessions_[monitor_index].paused_) {
+    sessions_[monitor_index].session_->Resume();
+    sessions_[monitor_index].paused_ = false;
+    LOG_INFO("Resuming session {}", monitor_index);
+  }
   return 0;
 }
 
 int ScreenCapturerWgc::Stop() {
-  _running = false;
-
-  if (session_) session_->Stop();
+  for (int i = 0; i < sessions_.size(); i++) {
+    if (sessions_[i].running_) {
+      sessions_[i].session_->Stop();
+      sessions_[i].running_ = false;
+    }
+  }
+  running_ = false;
 
   return 0;
 }
 
-void ConvertABGRtoBGRA(const uint8_t *abgr_data, uint8_t *bgra_data, int width,
-                       int height, int abgr_stride, int bgra_stride) {
-  for (int i = 0; i < height; ++i) {
-    for (int j = 0; j < width; ++j) {
-      int abgr_index = (i * abgr_stride + j) * 4;
-      int bgra_index = (i * bgra_stride + j) * 4;
-
-      bgra_data[bgra_index + 0] = abgr_data[abgr_index + 2];  // 蓝色
-      bgra_data[bgra_index + 1] = abgr_data[abgr_index + 1];  // 绿色
-      bgra_data[bgra_index + 2] = abgr_data[abgr_index + 0];  // 红色
-      bgra_data[bgra_index + 3] = abgr_data[abgr_index + 3];  // Alpha
-    }
+int ScreenCapturerWgc::SwitchTo(int monitor_index) {
+  if (monitor_index_ == monitor_index) {
+    LOG_INFO("Already on monitor {}:{}", monitor_index_ + 1,
+             display_info_list_[monitor_index_].name);
+    return 0;
   }
+
+  if (monitor_index >= display_info_list_.size()) {
+    LOG_ERROR("Invalid monitor index: {}", monitor_index);
+    return -1;
+  }
+
+  if (!sessions_[monitor_index].inited_) {
+    LOG_ERROR("Monitor {} not inited", monitor_index);
+    return -1;
+  }
+
+  Pause(monitor_index_);
+
+  monitor_index_ = monitor_index;
+  LOG_INFO("Switching to monitor {}:{}", monitor_index_,
+           display_info_list_[monitor_index_].name);
+
+  Resume(monitor_index);
+
+  return 0;
 }
 
-void ConvertBGRAtoABGR(const uint8_t *bgra_data, uint8_t *abgr_data, int width,
-                       int height, int bgra_stride, int abgr_stride) {
-  for (int i = 0; i < height; ++i) {
-    for (int j = 0; j < width; ++j) {
-      int bgra_index = (i * bgra_stride + j) * 4;
-      int abgr_index = (i * abgr_stride + j) * 4;
-
-      abgr_data[abgr_index + 0] = bgra_data[bgra_index + 3];  // Alpha
-      abgr_data[abgr_index + 1] = bgra_data[bgra_index + 0];  // Blue
-      abgr_data[abgr_index + 2] = bgra_data[bgra_index + 1];  // Green
-      abgr_data[abgr_index + 3] = bgra_data[bgra_index + 2];  // Red
-    }
-  }
-}
-
-void ScreenCapturerWgc::OnFrame(const WgcSession::wgc_session_frame &frame) {
-  if (_on_data) {
-    // int width = 1280;
-    // int height = 720;
-
+void ScreenCapturerWgc::OnFrame(const WgcSession::wgc_session_frame &frame,
+                                int id) {
+  if (on_data_) {
     if (!nv12_frame_) {
       nv12_frame_ = new unsigned char[frame.width * frame.height * 3 / 2];
     }
@@ -183,15 +255,18 @@ void ScreenCapturerWgc::OnFrame(const WgcSession::wgc_session_frame &frame) {
                        (uint8_t *)(nv12_frame_ + frame.width * frame.height),
                        frame.width, frame.width, frame.height);
 
-    _on_data(nv12_frame_, frame.width * frame.height * 3 / 2, frame.width,
-             frame.height);
+    on_data_(nv12_frame_, frame.width * frame.height * 3 / 2, frame.width,
+             frame.height, display_info_list_[id].name.c_str());
   }
 }
 
 void ScreenCapturerWgc::CleanUp() {
-  _inited = false;
-
-  if (session_) session_->Release();
-
-  session_ = nullptr;
+  if (inited_) {
+    for (auto &session : sessions_) {
+      if (session.session_) {
+        session.session_->Stop();
+      }
+    }
+    sessions_.clear();
+  }
 }

src/screen_capturer/windows/screen_capturer_wgc.h

@@ -5,6 +5,7 @@
 #include <functional>
 #include <string>
 #include <thread>
+#include <vector>
 
 #include "screen_capturer.h"
 #include "wgc_session.h"
@@ -19,34 +20,46 @@ class ScreenCapturerWgc : public ScreenCapturer,
  public:
   bool IsWgcSupported();
 
-  virtual int Init(const int fps, cb_desktop_data cb);
-  virtual int Destroy();
+  int Init(const int fps, cb_desktop_data cb) override;
+  int Destroy() override;
+  int Start() override;
+  int Stop() override;
 
-  virtual int Start();
+  int Pause(int monitor_index) override;
+  int Resume(int monitor_index) override;
 
-  int Pause();
-  int Resume();
-  virtual int Stop();
+  std::vector<DisplayInfo> GetDisplayInfoList() { return display_info_list_; }
 
-  void OnFrame(const WgcSession::wgc_session_frame &frame);
+  int SwitchTo(int monitor_index);
+
+  void OnFrame(const WgcSession::wgc_session_frame &frame, int id);
 
  protected:
   void CleanUp();
 
  private:
-  WgcSession *session_ = nullptr;
+  HMONITOR monitor_;
+  MONITORINFOEX monitor_info_;
+  std::vector<DisplayInfo> display_info_list_;
+  int monitor_index_ = 0;
 
-  std::atomic_bool _running;
-  std::atomic_bool _paused;
-  std::atomic_bool _inited;
+ private:
+  class WgcSessionInfo {
+   public:
+    std::unique_ptr<WgcSession> session_;
+    bool inited_ = false;
+    bool running_ = false;
+    bool paused_ = false;
+  };
 
-  std::thread _thread;
+  std::vector<WgcSessionInfo> sessions_;
 
-  std::string _device_name;
+  std::atomic_bool running_;
+  std::atomic_bool inited_;
 
-  int _fps;
+  int fps_;
 
-  cb_desktop_data _on_data = nullptr;
+  cb_desktop_data on_data_ = nullptr;
 
   unsigned char *nv12_frame_ = nullptr;
   unsigned char *nv12_frame_scaled_ = nullptr;

src/screen_capturer/windows/wgc_session.h

@@ -16,7 +16,7 @@ class WgcSession {
   class wgc_session_observer {
    public:
     virtual ~wgc_session_observer() {}
-    virtual void OnFrame(const wgc_session_frame &frame) = 0;
+    virtual void OnFrame(const wgc_session_frame &frame, int id) = 0;
   };
 
  public:
@@ -33,7 +33,6 @@ class WgcSession {
   virtual int Pause() = 0;
   virtual int Resume() = 0;
 
- protected:
   virtual ~WgcSession(){};
 };
 

src/screen_capturer/windows/wgc_session_impl.cpp

@@ -23,7 +23,7 @@ HRESULT __stdcall CreateDirect3D11DeviceFromDXGIDevice(
     ::IDXGIDevice *dxgiDevice, ::IInspectable **graphicsDevice);
 }
 
-WgcSessionImpl::WgcSessionImpl() {}
+WgcSessionImpl::WgcSessionImpl(int id) : id_(id) {}
 
 WgcSessionImpl::~WgcSessionImpl() {
   Stop();
@@ -124,6 +124,8 @@ int WgcSessionImpl::Stop() {
 int WgcSessionImpl::Pause() {
   std::lock_guard locker(lock_);
 
+  is_paused_ = true;
+
   CHECK_INIT;
   return 0;
 }
@@ -131,6 +133,8 @@ int WgcSessionImpl::Pause() {
 int WgcSessionImpl::Resume() {
   std::lock_guard locker(lock_);
 
+  is_paused_ = false;
+
   CHECK_INIT;
   return 0;
 }
@@ -233,6 +237,10 @@ void WgcSessionImpl::OnFrame(
 
     // copy to mapped texture
     {
+      if (is_paused_) {
+        return;
+      }
+
       auto frame_captured =
           GetDXGIInterfaceFromObject<ID3D11Texture2D>(frame.Surface());
 
@@ -256,11 +264,13 @@ void WgcSessionImpl::OnFrame(
 
       // copy data from map_result.pData
       if (map_result.pData && observer_) {
-        observer_->OnFrame(wgc_session_frame{
-            static_cast<unsigned int>(frame_size.Width),
-            static_cast<unsigned int>(frame_size.Height), map_result.RowPitch,
-            const_cast<const unsigned char *>(
-                (unsigned char *)map_result.pData)});
+        observer_->OnFrame(
+            wgc_session_frame{static_cast<unsigned int>(frame_size.Width),
+                              static_cast<unsigned int>(frame_size.Height),
+                              map_result.RowPitch,
+                              const_cast<const unsigned char *>(
+                                  (unsigned char *)map_result.pData)},
+            id_);
       }
 
       d3d11_device_context_->Unmap(d3d11_texture_mapped_.get(), 0);

src/screen_capturer/windows/wgc_session_impl.h

@@ -35,7 +35,7 @@ class WgcSessionImpl : public WgcSession {
   } target_{0};
 
  public:
-  WgcSessionImpl();
+  WgcSessionImpl(int id);
   ~WgcSessionImpl() override;
 
  public:
@@ -72,6 +72,7 @@ class WgcSessionImpl : public WgcSession {
   // void message_func();
 
  private:
+  int id_ = -1;
   std::mutex lock_;
   bool is_initialized_ = false;
   bool is_running_ = false;

src/single_window/connection_status_window.cpp

@@ -3,171 +3,169 @@
 #include "rd_log.h"
 #include "render.h"
 
-int Render::ConnectionStatusWindow() {
-  if (show_connection_status_window_) {
-    const ImGuiViewport *viewport = ImGui::GetMainViewport();
+bool Render::ConnectionStatusWindow(
+    std::shared_ptr<SubStreamWindowProperties> &props) {
+  const ImGuiViewport *viewport = ImGui::GetMainViewport();
+  bool ret_flag = false;
+  ImGui::SetNextWindowPos(ImVec2((viewport->WorkSize.x - viewport->WorkPos.x -
+                                  connection_status_window_width_) /
+                                     2,
+                                 (viewport->WorkSize.y - viewport->WorkPos.y -
+                                  connection_status_window_height_) /
+                                     2));
 
-    ImGui::SetNextWindowPos(ImVec2((viewport->WorkSize.x - viewport->WorkPos.x -
-                                    connection_status_window_width_) /
-                                       2,
-                                   (viewport->WorkSize.y - viewport->WorkPos.y -
-                                    connection_status_window_height_) /
-                                       2));
+  ImGui::SetNextWindowSize(ImVec2(connection_status_window_width_,
+                                  connection_status_window_height_));
 
-    ImGui::SetNextWindowSize(ImVec2(connection_status_window_width_,
-                                    connection_status_window_height_));
+  ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 3.0f);
 
-    ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 3.0f);
+  ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1.0, 1.0, 1.0, 1.0));
+  ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 1.0f);
+  ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 5.0f);
 
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1.0, 1.0, 1.0, 1.0));
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 1.0f);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 5.0f);
+  ImGui::Begin("ConnectionStatusWindow", nullptr,
+               ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse |
+                   ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoTitleBar |
+                   ImGuiWindowFlags_NoSavedSettings);
+  ImGui::PopStyleVar(2);
+  ImGui::PopStyleColor();
 
-    ImGui::Begin("ConnectionStatusWindow", nullptr,
-                 ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse |
-                     ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoTitleBar |
-                     ImGuiWindowFlags_NoSavedSettings);
-    ImGui::PopStyleVar(2);
-    ImGui::PopStyleColor();
+  ImGui::SetWindowFontScale(0.5f);
+  std::string text;
 
-    ImGui::SetWindowFontScale(0.5f);
-    std::string text;
-
-    if (ConnectionStatus::Connecting == connection_status_) {
-      text = localization::p2p_connecting[localization_language_index_];
-      ImGui::SetCursorPosX(connection_status_window_width_ * 3 / 7);
-      ImGui::SetCursorPosY(connection_status_window_height_ * 2 / 3);
-    } else if (ConnectionStatus::Connected == connection_status_) {
-      text = localization::p2p_connected[localization_language_index_];
-      ImGui::SetCursorPosX(connection_status_window_width_ * 3 / 7);
-      ImGui::SetCursorPosY(connection_status_window_height_ * 2 / 3);
-      // ok
-      if (ImGui::Button(
-              localization::ok[localization_language_index_].c_str()) ||
-          ImGui::IsKeyPressed(ImGuiKey_Enter) ||
-          ImGui::IsKeyPressed(ImGuiKey_Escape)) {
-        show_connection_status_window_ = false;
+  if (ConnectionStatus::Connecting == props->connection_status_) {
+    text = localization::p2p_connecting[localization_language_index_];
+    ImGui::SetCursorPosX(connection_status_window_width_ * 3 / 7);
+    ImGui::SetCursorPosY(connection_status_window_height_ * 2 / 3);
+  } else if (ConnectionStatus::Connected == props->connection_status_) {
+    text = localization::p2p_connected[localization_language_index_];
+    ImGui::SetCursorPosX(connection_status_window_width_ * 3 / 7);
+    ImGui::SetCursorPosY(connection_status_window_height_ * 2 / 3);
+    // ok
+    if (ImGui::Button(localization::ok[localization_language_index_].c_str()) ||
+        ImGui::IsKeyPressed(ImGuiKey_Enter) ||
+        ImGui::IsKeyPressed(ImGuiKey_Escape)) {
+      show_connection_status_window_ = false;
+    }
+  } else if (ConnectionStatus::Disconnected == props->connection_status_) {
+    text = localization::p2p_disconnected[localization_language_index_];
+    ImGui::SetCursorPosX(connection_status_window_width_ * 3 / 7);
+    ImGui::SetCursorPosY(connection_status_window_height_ * 2 / 3);
+    // ok
+    if (ImGui::Button(localization::ok[localization_language_index_].c_str()) ||
+        ImGui::IsKeyPressed(ImGuiKey_Enter) ||
+        ImGui::IsKeyPressed(ImGuiKey_Escape)) {
+      show_connection_status_window_ = false;
+    }
+  } else if (ConnectionStatus::Failed == props->connection_status_) {
+    text = localization::p2p_failed[localization_language_index_];
+    ImGui::SetCursorPosX(connection_status_window_width_ * 3 / 7);
+    ImGui::SetCursorPosY(connection_status_window_height_ * 2 / 3);
+    // ok
+    if (ImGui::Button(localization::ok[localization_language_index_].c_str()) ||
+        ImGui::IsKeyPressed(ImGuiKey_Enter) ||
+        ImGui::IsKeyPressed(ImGuiKey_Escape)) {
+      show_connection_status_window_ = false;
+    }
+  } else if (ConnectionStatus::Closed == props->connection_status_) {
+    text = localization::p2p_closed[localization_language_index_];
+    ImGui::SetCursorPosX(connection_status_window_width_ * 3 / 7);
+    ImGui::SetCursorPosY(connection_status_window_height_ * 2 / 3);
+    // ok
+    if (ImGui::Button(localization::ok[localization_language_index_].c_str()) ||
+        ImGui::IsKeyPressed(ImGuiKey_Enter) ||
+        ImGui::IsKeyPressed(ImGuiKey_Escape)) {
+      show_connection_status_window_ = false;
+    }
+  } else if (ConnectionStatus::IncorrectPassword == props->connection_status_) {
+    if (!password_validating_) {
+      if (password_validating_time_ == 1) {
+        text = localization::input_password[localization_language_index_];
+      } else {
+        text = localization::reinput_password[localization_language_index_];
       }
-    } else if (ConnectionStatus::Disconnected == connection_status_) {
-      text = localization::p2p_disconnected[localization_language_index_];
-      ImGui::SetCursorPosX(connection_status_window_width_ * 3 / 7);
-      ImGui::SetCursorPosY(connection_status_window_height_ * 2 / 3);
-      // ok
-      if (ImGui::Button(
-              localization::ok[localization_language_index_].c_str()) ||
-          ImGui::IsKeyPressed(ImGuiKey_Enter) ||
-          ImGui::IsKeyPressed(ImGuiKey_Escape)) {
-        show_connection_status_window_ = false;
+
+      auto window_width = ImGui::GetWindowSize().x;
+      auto window_height = ImGui::GetWindowSize().y;
+      ImGui::SetCursorPosX((window_width - IPUT_WINDOW_WIDTH / 2) * 0.5f);
+      ImGui::SetCursorPosY(window_height * 0.4f);
+      ImGui::SetNextItemWidth(IPUT_WINDOW_WIDTH / 2);
+
+      ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f);
+
+      if (focus_on_input_widget_) {
+        ImGui::SetKeyboardFocusHere();
+        focus_on_input_widget_ = false;
       }
-    } else if (ConnectionStatus::Failed == connection_status_) {
-      text = localization::p2p_failed[localization_language_index_];
-      ImGui::SetCursorPosX(connection_status_window_width_ * 3 / 7);
-      ImGui::SetCursorPosY(connection_status_window_height_ * 2 / 3);
-      // ok
-      if (ImGui::Button(
-              localization::ok[localization_language_index_].c_str()) ||
-          ImGui::IsKeyPressed(ImGuiKey_Enter) ||
-          ImGui::IsKeyPressed(ImGuiKey_Escape)) {
-        show_connection_status_window_ = false;
-      }
-    } else if (ConnectionStatus::Closed == connection_status_) {
-      text = localization::p2p_closed[localization_language_index_];
-      ImGui::SetCursorPosX(connection_status_window_width_ * 3 / 7);
-      ImGui::SetCursorPosY(connection_status_window_height_ * 2 / 3);
-      // ok
-      if (ImGui::Button(
-              localization::ok[localization_language_index_].c_str()) ||
-          ImGui::IsKeyPressed(ImGuiKey_Enter) ||
-          ImGui::IsKeyPressed(ImGuiKey_Escape)) {
-        show_connection_status_window_ = false;
-      }
-    } else if (ConnectionStatus::IncorrectPassword == connection_status_) {
-      if (!password_validating_) {
-        if (password_validating_time_ == 1) {
-          text = localization::input_password[localization_language_index_];
-        } else {
-          text = localization::reinput_password[localization_language_index_];
-        }
 
-        auto window_width = ImGui::GetWindowSize().x;
-        auto window_height = ImGui::GetWindowSize().y;
-        ImGui::SetCursorPosX((window_width - IPUT_WINDOW_WIDTH / 2) * 0.5f);
-        ImGui::SetCursorPosY(window_height * 0.4f);
-        ImGui::SetNextItemWidth(IPUT_WINDOW_WIDTH / 2);
+      ImGui::InputText("##password", props->remote_password_,
+                       IM_ARRAYSIZE(props->remote_password_),
+                       ImGuiInputTextFlags_CharsNoBlank);
 
-        ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f);
+      ImGui::SetWindowFontScale(0.4f);
 
-        if (focus_on_input_widget_) {
-          ImGui::SetKeyboardFocusHere();
-          focus_on_input_widget_ = false;
-        }
+      ImVec2 text_size = ImGui::CalcTextSize(
+          localization::remember_password[localization_language_index_]
+              .c_str());
+      ImGui::SetCursorPosX((window_width - text_size.x) * 0.5f - 13.0f);
+      ImGui::Checkbox(
+          localization::remember_password[localization_language_index_].c_str(),
+          &(props->remember_password_));
+      ImGui::SetWindowFontScale(0.5f);
+      ImGui::PopStyleVar();
 
-        ImGui::InputText("##password", remote_password_,
-                         IM_ARRAYSIZE(remote_password_),
-                         ImGuiInputTextFlags_CharsNoBlank);
-
-        ImGui::SetWindowFontScale(0.4f);
-
-        ImVec2 text_size = ImGui::CalcTextSize(
-            localization::remember_password[localization_language_index_]
-                .c_str());
-        ImGui::SetCursorPosX((window_width - text_size.x) * 0.5f - 13.0f);
-        ImGui::Checkbox(
-            localization::remember_password[localization_language_index_]
-                .c_str(),
-            &remember_password_);
-        ImGui::SetWindowFontScale(0.5f);
-        ImGui::PopStyleVar();
-
-        ImGui::SetCursorPosX(window_width * 0.315f);
-        ImGui::SetCursorPosY(window_height * 0.75f);
-        // ok
-        if (ImGui::Button(
-                localization::ok[localization_language_index_].c_str()) ||
-            ImGui::IsKeyPressed(ImGuiKey_Enter)) {
-          show_connection_status_window_ = true;
-          password_validating_ = true;
-          rejoin_ = true;
-          focus_on_input_widget_ = true;
-        }
-
-        ImGui::SameLine();
-        // cancel
-        if (ImGui::Button(
-                localization::cancel[localization_language_index_].c_str()) ||
-            ImGui::IsKeyPressed(ImGuiKey_Escape)) {
-          memset(remote_password_, 0, sizeof(remote_password_));
-          show_connection_status_window_ = false;
-          focus_on_input_widget_ = true;
-        }
-      } else if (password_validating_) {
-        text = localization::validate_password[localization_language_index_];
-        ImGui::SetCursorPosX(connection_status_window_width_ * 3 / 7);
-        ImGui::SetCursorPosY(connection_status_window_height_ * 2 / 3);
-      }
-    } else if (ConnectionStatus::NoSuchTransmissionId == connection_status_) {
-      text = localization::no_such_id[localization_language_index_];
-      ImGui::SetCursorPosX(connection_status_window_width_ * 3 / 7);
-      ImGui::SetCursorPosY(connection_status_window_height_ * 2 / 3);
+      ImGui::SetCursorPosX(window_width * 0.315f);
+      ImGui::SetCursorPosY(window_height * 0.75f);
       // ok
       if (ImGui::Button(
               localization::ok[localization_language_index_].c_str()) ||
           ImGui::IsKeyPressed(ImGuiKey_Enter)) {
-        show_connection_status_window_ = false;
-        re_enter_remote_id_ = true;
+        show_connection_status_window_ = true;
+        password_validating_ = true;
+        props->rejoin_ = true;
+        need_to_rejoin_ = true;
+        focus_on_input_widget_ = true;
       }
+
+      ImGui::SameLine();
+      // cancel
+      if (ImGui::Button(
+              localization::cancel[localization_language_index_].c_str()) ||
+          ImGui::IsKeyPressed(ImGuiKey_Escape)) {
+        memset(props->remote_password_, 0, sizeof(props->remote_password_));
+        show_connection_status_window_ = false;
+        focus_on_input_widget_ = true;
+      }
+    } else if (password_validating_) {
+      text = localization::validate_password[localization_language_index_];
+      ImGui::SetCursorPosX(connection_status_window_width_ * 3 / 7);
+      ImGui::SetCursorPosY(connection_status_window_height_ * 2 / 3);
+    }
+  } else if (ConnectionStatus::NoSuchTransmissionId ==
+             props->connection_status_) {
+    text = localization::no_such_id[localization_language_index_];
+    ImGui::SetCursorPosX(connection_status_window_width_ * 3 / 7);
+    ImGui::SetCursorPosY(connection_status_window_height_ * 2 / 3);
+    // ok
+    if (ImGui::Button(localization::ok[localization_language_index_].c_str()) ||
+        ImGui::IsKeyPressed(ImGuiKey_Enter)) {
+      show_connection_status_window_ = false;
+      re_enter_remote_id_ = true;
+      DestroyPeer(&props->peer_);
+      ret_flag = true;
     }
-
-    auto window_width = ImGui::GetWindowSize().x;
-    auto window_height = ImGui::GetWindowSize().y;
-    auto text_width = ImGui::CalcTextSize(text.c_str()).x;
-    ImGui::SetCursorPosX((window_width - text_width) * 0.5f);
-    ImGui::SetCursorPosY(window_height * 0.2f);
-    ImGui::Text("%s", text.c_str());
-    ImGui::SetWindowFontScale(1.0f);
-
-    ImGui::End();
-    ImGui::PopStyleVar();
   }
-  return 0;
+
+  auto window_width = ImGui::GetWindowSize().x;
+  auto window_height = ImGui::GetWindowSize().y;
+  auto text_width = ImGui::CalcTextSize(text.c_str()).x;
+  ImGui::SetCursorPosX((window_width - text_width) * 0.5f);
+  ImGui::SetCursorPosY(window_height * 0.2f);
+  ImGui::Text("%s", text.c_str());
+  ImGui::SetWindowFontScale(1.0f);
+
+  ImGui::End();
+  ImGui::PopStyleVar();
+
+  return ret_flag;
 }

src/single_window/control_bar.cpp

@@ -29,42 +29,83 @@ int LossRateDisplay(float loss_rate) {
   return 0;
 }
 
-int Render::ControlBar() {
+int Render::ControlBar(std::shared_ptr<SubStreamWindowProperties>& props) {
   ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 3.0f);
 
-  ImVec2 mouse_button_pos = ImVec2(0, 0);
-  if (control_bar_expand_) {
-    ImGui::SetCursorPosX(
-        is_control_bar_in_left_ ? (control_window_width_ + 5.0f) : 38.0f);
+  if (props->control_bar_expand_) {
+    ImGui::SetCursorPosX(props->is_control_bar_in_left_
+                             ? (props->control_window_width_ + 5.0f)
+                             : 38.0f);
     // mouse control button
     ImDrawList* draw_list = ImGui::GetWindowDrawList();
 
-    if (is_control_bar_in_left_) {
-      draw_list->AddLine(
-          ImVec2(ImGui::GetCursorScreenPos().x - 5.0f,
-                 ImGui::GetCursorScreenPos().y - 7.0f),
-          ImVec2(ImGui::GetCursorScreenPos().x - 5.0f,
-                 ImGui::GetCursorScreenPos().y - 7.0f + control_window_height_),
-          IM_COL32(178, 178, 178, 255), 1.0f);
+    if (props->is_control_bar_in_left_) {
+      draw_list->AddLine(ImVec2(ImGui::GetCursorScreenPos().x - 5.0f,
+                                ImGui::GetCursorScreenPos().y - 7.0f),
+                         ImVec2(ImGui::GetCursorScreenPos().x - 5.0f,
+                                ImGui::GetCursorScreenPos().y - 7.0f +
+                                    props->control_window_height_),
+                         IM_COL32(178, 178, 178, 255), 1.0f);
     }
 
-    mouse_button_pos = ImGui::GetCursorScreenPos();
+    std::string display = ICON_FA_DISPLAY;
+    if (ImGui::Button(display.c_str(), ImVec2(25, 25))) {
+      ImGui::OpenPopup("display");
+    }
+
+    ImVec2 btn_min = ImGui::GetItemRectMin();
+    ImVec2 btn_size_actual = ImGui::GetItemRectSize();
+
+    if (ImGui::BeginPopup("display")) {
+      ImGui::SetWindowFontScale(0.5f);
+      for (int i = 0; i < props->display_info_list_.size(); i++) {
+        if (ImGui::Selectable(props->display_info_list_[i].name.c_str())) {
+          props->selected_display_ = i;
+
+          RemoteAction remote_action;
+          remote_action.type = ControlType::display_id;
+          remote_action.d = i;
+          if (props->connection_status_ == ConnectionStatus::Connected) {
+            SendDataFrame(props->peer_, (const char*)&remote_action,
+                          sizeof(remote_action), props->data_label_.c_str());
+          }
+        }
+        props->display_selectable_hovered_ = ImGui::IsWindowHovered();
+      }
+      ImGui::SetWindowFontScale(1.0f);
+      ImGui::EndPopup();
+    }
+
+    ImGui::SetWindowFontScale(0.6f);
+    ImVec2 text_size = ImGui::CalcTextSize(
+        std::to_string(props->selected_display_ + 1).c_str());
+    ImVec2 text_pos =
+        ImVec2(btn_min.x + (btn_size_actual.x - text_size.x) * 0.5f,
+               btn_min.y + (btn_size_actual.y - text_size.y) * 0.5f - 2.0f);
+    ImGui::GetWindowDrawList()->AddText(
+        text_pos, IM_COL32(0, 0, 0, 255),
+        std::to_string(props->selected_display_ + 1).c_str());
+    ImGui::SetWindowFontScale(1.0f);
+
+    ImGui::SameLine();
     float disable_mouse_x = ImGui::GetCursorScreenPos().x + 4.0f;
     float disable_mouse_y = ImGui::GetCursorScreenPos().y + 4.0f;
-    std::string mouse = mouse_control_button_pressed_ ? ICON_FA_COMPUTER_MOUSE
-                                                      : ICON_FA_COMPUTER_MOUSE;
+    std::string mouse = props->mouse_control_button_pressed_
+                            ? ICON_FA_COMPUTER_MOUSE
+                            : ICON_FA_COMPUTER_MOUSE;
     if (ImGui::Button(mouse.c_str(), ImVec2(25, 25))) {
-      if (connection_established_) {
-        control_mouse_ = !control_mouse_;
+      if (props->connection_established_) {
         start_keyboard_capturer_ = !start_keyboard_capturer_;
-        mouse_control_button_pressed_ = !mouse_control_button_pressed_;
-        mouse_control_button_label_ =
-            mouse_control_button_pressed_
+        props->control_mouse_ = !props->control_mouse_;
+        props->mouse_control_button_pressed_ =
+            !props->mouse_control_button_pressed_;
+        props->mouse_control_button_label_ =
+            props->mouse_control_button_pressed_
                 ? localization::release_mouse[localization_language_index_]
                 : localization::control_mouse[localization_language_index_];
       }
     }
-    if (!mouse_control_button_pressed_) {
+    if (!props->mouse_control_button_pressed_) {
       draw_list->AddLine(
           ImVec2(disable_mouse_x, disable_mouse_y),
           ImVec2(disable_mouse_x + 16.0f, disable_mouse_y + 14.2f),
@@ -82,26 +123,28 @@ int Render::ControlBar() {
     float disable_audio_x = ImGui::GetCursorScreenPos().x + 4;
     float disable_audio_y = ImGui::GetCursorScreenPos().y + 4.0f;
     // std::string audio = audio_capture_button_pressed_ ? ICON_FA_VOLUME_HIGH
-    //                                                   : ICON_FA_VOLUME_XMARK;
-    std::string audio = audio_capture_button_pressed_ ? ICON_FA_VOLUME_HIGH
-                                                      : ICON_FA_VOLUME_HIGH;
+    //                                                   :
+    //                                                   ICON_FA_VOLUME_XMARK;
+    std::string audio = props->audio_capture_button_pressed_
+                            ? ICON_FA_VOLUME_HIGH
+                            : ICON_FA_VOLUME_HIGH;
     if (ImGui::Button(audio.c_str(), ImVec2(25, 25))) {
-      if (connection_established_) {
-        audio_capture_ = !audio_capture_;
-        audio_capture_button_pressed_ = !audio_capture_button_pressed_;
-        audio_capture_button_label_ =
-            audio_capture_button_pressed_
+      if (props->connection_established_) {
+        props->audio_capture_button_pressed_ =
+            !props->audio_capture_button_pressed_;
+        props->audio_capture_button_label_ =
+            props->audio_capture_button_pressed_
                 ? localization::audio_capture[localization_language_index_]
                 : localization::mute[localization_language_index_];
 
         RemoteAction remote_action;
         remote_action.type = ControlType::audio_capture;
-        remote_action.a = audio_capture_button_pressed_;
-        SendDataFrame(peer_, (const char*)&remote_action,
-                      sizeof(remote_action));
+        remote_action.a = props->audio_capture_button_pressed_;
+        SendDataFrame(props->peer_, (const char*)&remote_action,
+                      sizeof(remote_action), props->data_label_.c_str());
       }
     }
-    if (!audio_capture_button_pressed_) {
+    if (!props->audio_capture_button_pressed_) {
       draw_list->AddLine(
           ImVec2(disable_audio_x, disable_audio_y),
           ImVec2(disable_audio_x + 16.0f, disable_audio_y + 14.2f),
@@ -117,18 +160,19 @@ int Render::ControlBar() {
     ImGui::SameLine();
     // net traffic stats button
     bool button_color_style_pushed = false;
-    if (net_traffic_stats_button_pressed_) {
+    if (props->net_traffic_stats_button_pressed_) {
       ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(66 / 255.0f, 150 / 255.0f,
                                                     250 / 255.0f, 1.0f));
       button_color_style_pushed = true;
     }
     std::string net_traffic_stats = ICON_FA_SIGNAL;
     if (ImGui::Button(net_traffic_stats.c_str(), ImVec2(25, 25))) {
-      net_traffic_stats_button_pressed_ = !net_traffic_stats_button_pressed_;
-      control_window_height_is_changing_ = true;
-      net_traffic_stats_button_pressed_time_ = ImGui::GetTime();
-      net_traffic_stats_button_label_ =
-          net_traffic_stats_button_pressed_
+      props->net_traffic_stats_button_pressed_ =
+          !props->net_traffic_stats_button_pressed_;
+      props->control_window_height_is_changing_ = true;
+      props->net_traffic_stats_button_pressed_time_ = ImGui::GetTime();
+      props->net_traffic_stats_button_label_ =
+          props->net_traffic_stats_button_pressed_
               ? localization::hide_net_traffic_stats
                     [localization_language_index_]
               : localization::show_net_traffic_stats
@@ -145,63 +189,61 @@ int Render::ControlBar() {
         fullscreen_button_pressed_ ? ICON_FA_COMPRESS : ICON_FA_EXPAND;
     if (ImGui::Button(fullscreen.c_str(), ImVec2(25, 25))) {
       fullscreen_button_pressed_ = !fullscreen_button_pressed_;
-      fullscreen_button_label_ =
+      props->fullscreen_button_label_ =
           fullscreen_button_pressed_
               ? localization::exit_fullscreen[localization_language_index_]
               : localization::fullscreen[localization_language_index_];
-      // save stream window last size
-      SDL_GetWindowSize(stream_window_, &stream_window_width_last_,
-                        &stream_window_height_last_);
+
       if (fullscreen_button_pressed_) {
         SDL_SetWindowFullscreen(stream_window_, SDL_WINDOW_FULLSCREEN_DESKTOP);
       } else {
         SDL_SetWindowFullscreen(stream_window_, SDL_FALSE);
       }
-      reset_control_bar_pos_ = true;
+      props->reset_control_bar_pos_ = true;
     }
 
     ImGui::SameLine();
     // close button
     std::string close_button = ICON_FA_XMARK;
     if (ImGui::Button(close_button.c_str(), ImVec2(25, 25))) {
-      SDL_Event event;
-      event.type = SDL_QUIT;
-      SDL_PushEvent(&event);
+      CleanupPeer(props);
     }
 
     ImGui::SameLine();
 
-    if (!is_control_bar_in_left_) {
-      draw_list->AddLine(
-          ImVec2(ImGui::GetCursorScreenPos().x - 3.0f,
-                 ImGui::GetCursorScreenPos().y - 7.0f),
-          ImVec2(ImGui::GetCursorScreenPos().x - 3.0f,
-                 ImGui::GetCursorScreenPos().y - 7.0f + control_window_height_),
-          IM_COL32(178, 178, 178, 255), 1.0f);
+    if (!props->is_control_bar_in_left_) {
+      draw_list->AddLine(ImVec2(ImGui::GetCursorScreenPos().x - 3.0f,
+                                ImGui::GetCursorScreenPos().y - 7.0f),
+                         ImVec2(ImGui::GetCursorScreenPos().x - 3.0f,
+                                ImGui::GetCursorScreenPos().y - 7.0f +
+                                    props->control_window_height_),
+                         IM_COL32(178, 178, 178, 255), 1.0f);
     }
   }
 
-  ImGui::SetCursorPosX(
-      is_control_bar_in_left_ ? (control_window_width_ * 2 - 20.0f) : 5.0f);
+  ImGui::SetCursorPosX(props->is_control_bar_in_left_
+                           ? (props->control_window_width_ * 2 - 20.0f)
+                           : 5.0f);
 
   std::string control_bar =
-      control_bar_expand_
-          ? (is_control_bar_in_left_ ? ICON_FA_ANGLE_LEFT : ICON_FA_ANGLE_RIGHT)
-          : (is_control_bar_in_left_ ? ICON_FA_ANGLE_RIGHT
-                                     : ICON_FA_ANGLE_LEFT);
+      props->control_bar_expand_
+          ? (props->is_control_bar_in_left_ ? ICON_FA_ANGLE_LEFT
+                                            : ICON_FA_ANGLE_RIGHT)
+          : (props->is_control_bar_in_left_ ? ICON_FA_ANGLE_RIGHT
+                                            : ICON_FA_ANGLE_LEFT);
   if (ImGui::Button(control_bar.c_str(), ImVec2(15, 25))) {
-    control_bar_expand_ = !control_bar_expand_;
-    control_bar_button_pressed_time_ = ImGui::GetTime();
-    control_window_width_is_changing_ = true;
+    props->control_bar_expand_ = !props->control_bar_expand_;
+    props->control_bar_button_pressed_time_ = ImGui::GetTime();
+    props->control_window_width_is_changing_ = true;
 
-    if (!control_bar_expand_) {
-      control_window_height_ = 40;
-      net_traffic_stats_button_pressed_ = false;
+    if (!props->control_bar_expand_) {
+      props->control_window_height_ = 40;
+      props->net_traffic_stats_button_pressed_ = false;
     }
   }
 
-  if (net_traffic_stats_button_pressed_ && control_bar_expand_) {
-    NetTrafficStats();
+  if (props->net_traffic_stats_button_pressed_ && props->control_bar_expand_) {
+    NetTrafficStats(props);
   }
 
   ImGui::PopStyleVar();
@@ -209,13 +251,15 @@ int Render::ControlBar() {
   return 0;
 }
 
-int Render::NetTrafficStats() {
-  ImGui::SetCursorPos(ImVec2(
-      is_control_bar_in_left_ ? (control_window_width_ + 5.0f) : 5.0f, 40.0f));
+int Render::NetTrafficStats(std::shared_ptr<SubStreamWindowProperties>& props) {
+  ImGui::SetCursorPos(ImVec2(props->is_control_bar_in_left_
+                                 ? (props->control_window_width_ + 5.0f)
+                                 : 5.0f,
+                             40.0f));
 
   if (ImGui::BeginTable("NetTrafficStats", 4, ImGuiTableFlags_BordersH,
-                        ImVec2(control_window_max_width_ - 10.0f,
-                               control_window_max_height_ - 40.0f))) {
+                        ImVec2(props->control_window_max_width_ - 10.0f,
+                               props->control_window_max_height_ - 40.0f))) {
     ImGui::TableSetupColumn("", ImGuiTableColumnFlags_WidthFixed);
     ImGui::TableSetupColumn("", ImGuiTableColumnFlags_WidthStretch);
     ImGui::TableSetupColumn("", ImGuiTableColumnFlags_WidthStretch);
@@ -236,43 +280,43 @@ int Render::NetTrafficStats() {
     ImGui::Text("%s",
                 localization::video[localization_language_index_].c_str());
     ImGui::TableNextColumn();
-    BitrateDisplay((int)net_traffic_stats_.video_inbound_stats.bitrate);
+    BitrateDisplay((int)props->net_traffic_stats_.video_inbound_stats.bitrate);
     ImGui::TableNextColumn();
-    BitrateDisplay((int)net_traffic_stats_.video_outbound_stats.bitrate);
+    BitrateDisplay((int)props->net_traffic_stats_.video_outbound_stats.bitrate);
     ImGui::TableNextColumn();
-    LossRateDisplay(net_traffic_stats_.video_inbound_stats.loss_rate);
+    LossRateDisplay(props->net_traffic_stats_.video_inbound_stats.loss_rate);
 
     ImGui::TableNextRow();
     ImGui::TableNextColumn();
     ImGui::Text("%s",
                 localization::audio[localization_language_index_].c_str());
     ImGui::TableNextColumn();
-    BitrateDisplay((int)net_traffic_stats_.audio_inbound_stats.bitrate);
+    BitrateDisplay((int)props->net_traffic_stats_.audio_inbound_stats.bitrate);
     ImGui::TableNextColumn();
-    BitrateDisplay((int)net_traffic_stats_.audio_outbound_stats.bitrate);
+    BitrateDisplay((int)props->net_traffic_stats_.audio_outbound_stats.bitrate);
     ImGui::TableNextColumn();
-    LossRateDisplay(net_traffic_stats_.audio_inbound_stats.loss_rate);
+    LossRateDisplay(props->net_traffic_stats_.audio_inbound_stats.loss_rate);
 
     ImGui::TableNextRow();
     ImGui::TableNextColumn();
     ImGui::Text("%s", localization::data[localization_language_index_].c_str());
     ImGui::TableNextColumn();
-    BitrateDisplay((int)net_traffic_stats_.data_inbound_stats.bitrate);
+    BitrateDisplay((int)props->net_traffic_stats_.data_inbound_stats.bitrate);
     ImGui::TableNextColumn();
-    BitrateDisplay((int)net_traffic_stats_.data_outbound_stats.bitrate);
+    BitrateDisplay((int)props->net_traffic_stats_.data_outbound_stats.bitrate);
     ImGui::TableNextColumn();
-    LossRateDisplay(net_traffic_stats_.data_inbound_stats.loss_rate);
+    LossRateDisplay(props->net_traffic_stats_.data_inbound_stats.loss_rate);
 
     ImGui::TableNextRow();
     ImGui::TableNextColumn();
     ImGui::Text("%s",
                 localization::total[localization_language_index_].c_str());
     ImGui::TableNextColumn();
-    BitrateDisplay((int)net_traffic_stats_.total_inbound_stats.bitrate);
+    BitrateDisplay((int)props->net_traffic_stats_.total_inbound_stats.bitrate);
     ImGui::TableNextColumn();
-    BitrateDisplay((int)net_traffic_stats_.total_outbound_stats.bitrate);
+    BitrateDisplay((int)props->net_traffic_stats_.total_outbound_stats.bitrate);
     ImGui::TableNextColumn();
-    LossRateDisplay(net_traffic_stats_.total_inbound_stats.loss_rate);
+    LossRateDisplay(props->net_traffic_stats_.total_inbound_stats.loss_rate);
 
     ImGui::EndTable();
   }

src/single_window/control_window.cpp

@@ -1,33 +1,41 @@
 #include "rd_log.h"
 #include "render.h"
 
-int Render::ControlWindow() {
-  double time_duration = ImGui::GetTime() - control_bar_button_pressed_time_;
-  if (control_window_width_is_changing_) {
-    if (control_bar_expand_) {
-      control_window_width_ =
-          (float)(control_window_min_width_ +
-                  (control_window_max_width_ - control_window_min_width_) * 4 *
-                      time_duration);
+int Render::ControlWindow(std::shared_ptr<SubStreamWindowProperties> &props) {
+  double time_duration =
+      ImGui::GetTime() - props->control_bar_button_pressed_time_;
+  if (props->control_window_width_is_changing_) {
+    if (props->control_bar_expand_) {
+      props->control_window_width_ =
+          (float)(props->control_window_min_width_ +
+                  (props->control_window_max_width_ -
+                   props->control_window_min_width_) *
+                      4 * time_duration);
     } else {
-      control_window_width_ =
-          (float)(control_window_max_width_ -
-                  (control_window_max_width_ - control_window_min_width_) * 4 *
-                      time_duration);
+      props->control_window_width_ =
+          (float)(props->control_window_max_width_ -
+                  (props->control_window_max_width_ -
+                   props->control_window_min_width_) *
+                      4 * time_duration);
     }
   }
 
-  time_duration = ImGui::GetTime() - net_traffic_stats_button_pressed_time_;
-  if (control_window_height_is_changing_) {
-    if (control_bar_expand_ && net_traffic_stats_button_pressed_) {
-      control_window_height_ =
-          (float)(control_window_min_height_ +
-                  (control_window_max_height_ - control_window_min_height_) *
+  time_duration =
+      ImGui::GetTime() - props->net_traffic_stats_button_pressed_time_;
+  if (props->control_window_height_is_changing_) {
+    if (props->control_bar_expand_ &&
+        props->net_traffic_stats_button_pressed_) {
+      props->control_window_height_ =
+          (float)(props->control_window_min_height_ +
+                  (props->control_window_max_height_ -
+                   props->control_window_min_height_) *
                       4 * time_duration);
-    } else if (control_bar_expand_ && !net_traffic_stats_button_pressed_) {
-      control_window_height_ =
-          (float)(control_window_max_height_ -
-                  (control_window_max_height_ - control_window_min_height_) *
+    } else if (props->control_bar_expand_ &&
+               !props->net_traffic_stats_button_pressed_) {
+      props->control_window_height_ =
+          (float)(props->control_window_max_height_ -
+                  (props->control_window_max_height_ -
+                   props->control_window_min_height_) *
                       4 * time_duration);
     }
   }
@@ -35,191 +43,176 @@ int Render::ControlWindow() {
   ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1, 1, 1, 1));
   ImGui::PushStyleVar(ImGuiStyleVar_WindowMinSize, ImVec2(0, 0));
   ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 10.0f);
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0);
+  ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
   ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, 10.0f);
   ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
 
   ImGui::SetNextWindowSize(
-      ImVec2(control_window_width_, control_window_height_), ImGuiCond_Always);
+      ImVec2(props->control_window_width_, props->control_window_height_),
+      ImGuiCond_Always);
 
-  if (0 == control_winodw_pos_.x && 0 == control_winodw_pos_.y) {
-    ImGui::SetNextWindowPos(ImVec2(0, title_bar_height_ + 1), ImGuiCond_Once);
-  }
+  ImGui::SetNextWindowPos(ImVec2(0, title_bar_height_ + 1), ImGuiCond_Once);
 
-  if (reset_control_bar_pos_) {
-    float new_control_window_pos_x, new_control_window_pos_y, new_cursor_pos_x,
-        new_cursor_pos_y;
+  float pos_x = 0;
+  float pos_y = 0;
+  float y_boundary = fullscreen_button_pressed_ ? 0 : (title_bar_height_ + 1);
+
+  if (props->reset_control_bar_pos_) {
+    float new_cursor_pos_x = 0;
+    float new_cursor_pos_y = 0;
 
     // set control window pos
-    new_control_window_pos_x = control_winodw_pos_.x;
-    if (control_winodw_pos_.y < stream_render_rect_last_.y) {
-      new_control_window_pos_y =
-          stream_render_rect_.y -
-          (stream_render_rect_last_.y - control_winodw_pos_.y);
-      if (fullscreen_button_pressed_ && new_control_window_pos_y < 0) {
-        new_control_window_pos_y = 0;
-      } else if (!fullscreen_button_pressed_ &&
-                 new_control_window_pos_y < (title_bar_height_ + 1)) {
-        new_control_window_pos_y = title_bar_height_ + 1;
-      }
-    } else if (control_winodw_pos_.y + control_window_height_ >
-               stream_render_rect_last_.y + stream_render_rect_last_.h) {
-      new_control_window_pos_y =
-          stream_render_rect_.y + stream_render_rect_.h +
-          (control_winodw_pos_.y - stream_render_rect_last_.y -
-           stream_render_rect_last_.h);
-      if (new_control_window_pos_y >
-          stream_window_height_ - control_window_height_) {
-        new_control_window_pos_y =
-            stream_window_height_ - control_window_height_;
-      }
-    } else if (control_winodw_pos_.y + control_window_height_ ==
-               stream_render_rect_last_.y + stream_render_rect_last_.h) {
-      new_control_window_pos_y = stream_render_rect_.y + stream_render_rect_.h -
-                                 control_window_height_;
+    if (props->control_window_pos_.y + props->control_window_height_ >
+        stream_window_height_) {
+      pos_y = stream_window_height_ - props->control_window_height_;
+    } else if (props->control_window_pos_.y < y_boundary) {
+      pos_y = y_boundary;
     } else {
-      new_control_window_pos_y =
-          (control_winodw_pos_.y - stream_render_rect_last_.y) /
-              (float)(stream_render_rect_last_.h) * stream_render_rect_.h +
-          stream_render_rect_.y;
+      pos_y = props->control_window_pos_.y;
     }
 
-    ImGui::SetNextWindowPos(
-        ImVec2(new_control_window_pos_x, new_control_window_pos_y),
-        ImGuiCond_Always);
+    if (props->is_control_bar_in_left_) {
+      pos_x = 0;
+    } else {
+      pos_x = stream_window_width_ - props->control_window_width_;
+    }
 
-    if (0 != mouse_diff_control_bar_pos_x_ &&
-        0 != mouse_diff_control_bar_pos_y_) {
+    ImGui::SetNextWindowPos(ImVec2(pos_x, pos_y), ImGuiCond_Always);
+
+    if (0 != props->mouse_diff_control_bar_pos_x_ &&
+        0 != props->mouse_diff_control_bar_pos_y_) {
       // set cursor pos
-      new_cursor_pos_x =
-          new_control_window_pos_x + mouse_diff_control_bar_pos_x_;
-      new_cursor_pos_y =
-          new_control_window_pos_y + mouse_diff_control_bar_pos_y_;
+      new_cursor_pos_x = pos_x + props->mouse_diff_control_bar_pos_x_;
+      new_cursor_pos_y = pos_y + props->mouse_diff_control_bar_pos_y_;
 
       SDL_WarpMouseInWindow(stream_window_, (int)new_cursor_pos_x,
                             (int)new_cursor_pos_y);
     }
-    reset_control_bar_pos_ = false;
-  } else if (!reset_control_bar_pos_ &&
-                 ImGui::IsMouseReleased(ImGuiPopupFlags_MouseButtonLeft) ||
-             control_window_width_is_changing_) {
-    if (control_winodw_pos_.x <= stream_window_width_ / 2) {
-      float pos_x = 0;
-      float pos_y =
-          (control_winodw_pos_.y >=
-               (fullscreen_button_pressed_ ? 0 : (title_bar_height_ + 1)) &&
-           control_winodw_pos_.y <=
-               stream_window_height_ - control_window_height_)
-              ? control_winodw_pos_.y
-              : (control_winodw_pos_.y < (fullscreen_button_pressed_
-                                              ? 0
-                                              : (title_bar_height_ + 1))
-                     ? (fullscreen_button_pressed_ ? 0
-                                                   : (title_bar_height_ + 1))
-                     : (stream_window_height_ - control_window_height_));
+    props->reset_control_bar_pos_ = false;
+  } else if (!props->reset_control_bar_pos_ &&
+                 ImGui::IsMouseReleased(ImGuiMouseButton_Left) ||
+             props->control_window_width_is_changing_) {
+    if (props->control_window_pos_.x <= stream_window_width_ / 2) {
+      if (props->control_window_pos_.y + props->control_window_height_ >
+          stream_window_height_) {
+        pos_y = stream_window_height_ - props->control_window_height_;
+      } else {
+        pos_y = props->control_window_pos_.y;
+      }
 
-      if (control_bar_expand_) {
-        if (control_window_width_ >= control_window_max_width_) {
-          control_window_width_ = control_window_max_width_;
-          control_window_width_is_changing_ = false;
+      if (props->control_bar_expand_) {
+        if (props->control_window_width_ >= props->control_window_max_width_) {
+          props->control_window_width_ = props->control_window_max_width_;
+          props->control_window_width_is_changing_ = false;
         } else {
-          control_window_width_is_changing_ = true;
+          props->control_window_width_is_changing_ = true;
         }
       } else {
-        if (control_window_width_ <= control_window_min_width_) {
-          control_window_width_ = control_window_min_width_;
-          control_window_width_is_changing_ = false;
+        if (props->control_window_width_ <= props->control_window_min_width_) {
+          props->control_window_width_ = props->control_window_min_width_;
+          props->control_window_width_is_changing_ = false;
         } else {
-          control_window_width_is_changing_ = true;
+          props->control_window_width_is_changing_ = true;
         }
       }
-      ImGui::SetNextWindowPos(ImVec2(pos_x, pos_y), ImGuiCond_Always);
-      is_control_bar_in_left_ = true;
-    } else if (control_winodw_pos_.x > stream_window_width_ / 2) {
-      float pos_x = 0;
-      float pos_y =
-          (control_winodw_pos_.y >=
-               (fullscreen_button_pressed_ ? 0 : (title_bar_height_ + 1)) &&
-           control_winodw_pos_.y <=
-               stream_window_height_ - control_window_height_)
-              ? control_winodw_pos_.y
-              : (control_winodw_pos_.y < (fullscreen_button_pressed_
-                                              ? 0
-                                              : (title_bar_height_ + 1))
+      props->is_control_bar_in_left_ = true;
+    } else if (props->control_window_pos_.x > stream_window_width_ / 2) {
+      pos_x = 0;
+      pos_y =
+          (props->control_window_pos_.y >= y_boundary &&
+           props->control_window_pos_.y <=
+               stream_window_height_ - props->control_window_height_)
+              ? props->control_window_pos_.y
+              : (props->control_window_pos_.y < (fullscreen_button_pressed_
+                                                     ? 0
+                                                     : (title_bar_height_ + 1))
                      ? (fullscreen_button_pressed_ ? 0
                                                    : (title_bar_height_ + 1))
-                     : (stream_window_height_ - control_window_height_));
+                     : (stream_window_height_ - props->control_window_height_));
 
-      if (control_bar_expand_) {
-        if (control_window_width_ >= control_window_max_width_) {
-          control_window_width_ = control_window_max_width_;
-          control_window_width_is_changing_ = false;
-          pos_x = stream_window_width_ - control_window_max_width_;
+      if (props->control_bar_expand_) {
+        if (props->control_window_width_ >= props->control_window_max_width_) {
+          props->control_window_width_ = props->control_window_max_width_;
+          props->control_window_width_is_changing_ = false;
+          pos_x = stream_window_width_ - props->control_window_max_width_;
         } else {
-          control_window_width_is_changing_ = true;
-          pos_x = stream_window_width_ - control_window_width_;
+          props->control_window_width_is_changing_ = true;
+          pos_x = stream_window_width_ - props->control_window_width_;
         }
       } else {
-        if (control_window_width_ <= control_window_min_width_) {
-          control_window_width_ = control_window_min_width_;
-          control_window_width_is_changing_ = false;
-          pos_x = stream_window_width_ - control_window_min_width_;
+        if (props->control_window_width_ <= props->control_window_min_width_) {
+          props->control_window_width_ = props->control_window_min_width_;
+          props->control_window_width_is_changing_ = false;
+          pos_x = stream_window_width_ - props->control_window_min_width_;
         } else {
-          control_window_width_is_changing_ = true;
-          pos_x = stream_window_width_ - control_window_width_;
+          props->control_window_width_is_changing_ = true;
+          pos_x = stream_window_width_ - props->control_window_width_;
         }
       }
-      ImGui::SetNextWindowPos(ImVec2(pos_x, pos_y), ImGuiCond_Always);
-      is_control_bar_in_left_ = false;
+      props->is_control_bar_in_left_ = false;
     }
+
+    if (props->control_window_pos_.y + props->control_window_height_ >
+        stream_window_height_) {
+      pos_y = stream_window_height_ - props->control_window_height_;
+    } else if (props->control_window_pos_.y < y_boundary) {
+      pos_y = y_boundary;
+    }
+    ImGui::SetNextWindowPos(ImVec2(pos_x, pos_y), ImGuiCond_Always);
   }
 
-  if (control_bar_expand_ && control_window_height_is_changing_) {
-    if (net_traffic_stats_button_pressed_) {
-      if (control_window_height_ >= control_window_max_height_) {
-        control_window_height_ = control_window_max_height_;
-        control_window_height_is_changing_ = false;
+  if (props->control_bar_expand_ && props->control_window_height_is_changing_) {
+    if (props->net_traffic_stats_button_pressed_) {
+      if (props->control_window_height_ >= props->control_window_max_height_) {
+        props->control_window_height_ = props->control_window_max_height_;
+        props->control_window_height_is_changing_ = false;
       } else {
-        control_window_height_is_changing_ = true;
+        props->control_window_height_is_changing_ = true;
       }
     } else {
-      if (control_window_height_ <= control_window_min_height_) {
-        control_window_height_ = control_window_min_height_;
-        control_window_height_is_changing_ = false;
+      if (props->control_window_height_ <= props->control_window_min_height_) {
+        props->control_window_height_ = props->control_window_min_height_;
+        props->control_window_height_is_changing_ = false;
       } else {
-        control_window_height_is_changing_ = true;
+        props->control_window_height_is_changing_ = true;
       }
     }
   }
 
-  ImGui::Begin("ControlWindow", nullptr,
+  std::string control_window_title = props->remote_id_ + "ControlWindow";
+  ImGui::Begin(control_window_title.c_str(), nullptr,
                ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
-                   ImGuiWindowFlags_NoScrollbar);
+                   ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoDocking);
   ImGui::PopStyleVar();
 
-  control_winodw_pos_ = ImGui::GetWindowPos();
-  SDL_GetMouseState(&mouse_pos_x_, &mouse_pos_y_);
-  mouse_diff_control_bar_pos_x_ = mouse_pos_x_ - control_winodw_pos_.x;
-  mouse_diff_control_bar_pos_y_ = mouse_pos_y_ - control_winodw_pos_.y;
+  props->control_window_pos_ = ImGui::GetWindowPos();
+  SDL_GetMouseState(&props->mouse_pos_x_, &props->mouse_pos_y_);
+  props->mouse_diff_control_bar_pos_x_ =
+      props->mouse_pos_x_ - props->control_window_pos_.x;
+  props->mouse_diff_control_bar_pos_y_ =
+      props->mouse_pos_y_ - props->control_window_pos_.y;
 
   ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
   static bool a, b, c, d, e;
   ImGui::SetNextWindowPos(
-      ImVec2(is_control_bar_in_left_
-                 ? control_winodw_pos_.x - control_window_width_
-                 : control_winodw_pos_.x,
-             control_winodw_pos_.y),
+      ImVec2(props->is_control_bar_in_left_
+                 ? props->control_window_pos_.x - props->control_window_width_
+                 : props->control_window_pos_.x,
+             props->control_window_pos_.y),
       ImGuiCond_Always);
   ImGui::SetWindowFontScale(0.5f);
 
-  ImGui::BeginChild("ControlBar",
-                    ImVec2(control_window_width_ * 2, control_window_height_),
-                    ImGuiChildFlags_Border, ImGuiWindowFlags_NoDecoration);
+  std::string control_child_window_title =
+      props->remote_id_ + "ControlChildWindow";
+  ImGui::BeginChild(
+      control_child_window_title.c_str(),
+      ImVec2(props->control_window_width_ * 2, props->control_window_height_),
+      ImGuiChildFlags_Border, ImGuiWindowFlags_NoDecoration);
   ImGui::SetWindowFontScale(1.0f);
   ImGui::PopStyleColor();
 
-  ControlBar();
-  control_bar_hovered_ = ImGui::IsWindowHovered();
+  ControlBar(props);
+  props->control_bar_hovered_ = ImGui::IsWindowHovered();
 
   ImGui::EndChild();
   ImGui::End();

src/single_window/local_peer_window.cpp

@@ -135,28 +135,6 @@ int Render::LocalWindow() {
       ImGui::SetNextItemWidth(IPUT_WINDOW_WIDTH);
       ImGui::Spacing();
 
-      if (!password_inited_) {
-        char a[] = {
-            "123456789QWERTYUPASDFGHJKLZXCVBNMqwertyupasdfghijkzxcvbnm"};
-        std::mt19937 generator((unsigned int)std::chrono::system_clock::now()
-                                   .time_since_epoch()
-                                   .count());
-        std::uniform_int_distribution<int> distribution(0,
-                                                        (int)(strlen(a) - 1));
-
-        random_password_.clear();
-        for (int i = 0; i < 6; i++) {
-          random_password_ += a[distribution(generator)];
-        }
-        password_inited_ = true;
-        if (0 != strcmp(random_password_.c_str(), password_saved_)) {
-          memcpy(password_saved_, random_password_.c_str(),
-                 sizeof(password_saved_));
-          LOG_INFO("Generate new password and save into cache file");
-          SaveSettingsIntoCacheFile();
-        }
-      }
-
       ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f);
       ImGui::InputTextWithHint(
           "##server_pwd",
@@ -196,10 +174,8 @@ int Render::LocalWindow() {
               regenerate_password_ ? ICON_FA_SPINNER : ICON_FA_ARROWS_ROTATE,
               ImVec2(22, 38))) {
         regenerate_password_ = true;
-        password_inited_ = false;
         regenerate_password_start_time_ = ImGui::GetTime();
         LeaveConnection(peer_, client_id_);
-        is_create_connection_ = false;
       }
       if (ImGui::GetTime() - regenerate_password_start_time_ > 0.3f) {
         regenerate_password_ = false;
@@ -281,12 +257,22 @@ int Render::LocalWindow() {
             focus_on_input_widget_ = true;
           } else {
             show_reset_password_window_ = false;
-            LOG_INFO("Generate new password and save into cache file");
-            memcpy(password_saved_, new_password_, sizeof(password_saved_));
-            memset(new_password_, 0, sizeof(new_password_));
+            memset(&password_saved_, 0, sizeof(password_saved_));
+            strncpy(password_saved_, new_password_,
+                    sizeof(password_saved_) - 1);
+            password_saved_[sizeof(password_saved_) - 1] = '\0';
+
+            std::string client_id_with_password =
+                std::string(client_id_) + "@" + password_saved_;
+            strncpy(client_id_with_password_, client_id_with_password.c_str(),
+                    sizeof(client_id_with_password_) - 1);
+            client_id_with_password_[sizeof(client_id_with_password_) - 1] =
+                '\0';
+
             SaveSettingsIntoCacheFile();
+
             LeaveConnection(peer_, client_id_);
-            is_create_connection_ = false;
+            DestroyPeer(&peer_);
             focus_on_input_widget_ = true;
           }
         }

src/single_window/main_window.cpp

@@ -28,7 +28,22 @@ int Render::MainWindow() {
 
   RecentConnectionsWindow();
   StatusBar();
-  ConnectionStatusWindow();
+
+  if (show_connection_status_window_) {
+    for (auto it = client_properties_.begin();
+         it != client_properties_.end();) {
+      auto& props = it->second;
+      if (focused_remote_id_ == props->remote_id_) {
+        if (ConnectionStatusWindow(props)) {
+          it = client_properties_.erase(it);
+        } else {
+          ++it;
+        }
+      } else {
+        ++it;
+      }
+    }
+  }
 
   return 0;
 }

src/single_window/recent_connections.cpp

@@ -56,17 +56,15 @@ int Render::ShowRecentConnections() {
                         ImGuiWindowFlags_NoScrollWithMouse);
   ImGui::PopStyleVar();
   ImGui::PopStyleColor();
-  size_t recent_connections_count = recent_connection_textures_.size();
+  size_t recent_connections_count = recent_connections_.size();
   int count = 0;
   float button_width = 22;
   float button_height = 22;
-  for (auto it = recent_connection_textures_.begin();
-       it != recent_connection_textures_.end(); ++it) {
-    sub_containers_pos[it->first] = ImGui::GetCursorPos();
+  for (auto& it : recent_connections_) {
+    sub_containers_pos[it.first] = ImGui::GetCursorPos();
     std::string recent_connection_sub_window_name =
-        "RecentConnectionsSubContainer" + it->first;
+        "RecentConnectionsSubContainer" + it.first;
     // recent connections sub container
-
     ImGui::BeginChild(recent_connection_sub_window_name.c_str(),
                       ImVec2(recent_connection_sub_container_width,
                              recent_connection_sub_container_height),
@@ -76,24 +74,42 @@ int Render::ShowRecentConnections() {
                           ImGuiWindowFlags_NoTitleBar |
                           ImGuiWindowFlags_NoBringToFrontOnFocus |
                           ImGuiWindowFlags_NoScrollbar);
-    std::string connection_info = it->first;
-    std::string remote_id;
-    std::string password;
-    std::string host_name;
+    std::string connection_info = it.first;
 
     // remote id length is 9
     // password length is 6
-    // connection_info -> remote_id + 'Y' + password + host_name
+    // connection_info -> remote_id + 'Y' + host_name + '@' + password
     //                 -> remote_id + 'N' + host_name
     if ('Y' == connection_info[9] && connection_info.size() >= 16) {
-      remote_id = connection_info.substr(0, 9);
-      password = connection_info.substr(10, 6);
-      host_name = connection_info.substr(16);
+      size_t pos_y = connection_info.find('Y');
+      size_t pos_at = connection_info.find('@');
+
+      if (pos_y == std::string::npos || pos_at == std::string::npos ||
+          pos_y >= pos_at) {
+        LOG_ERROR("Invalid filename");
+        continue;
+      }
+
+      it.second.remote_id = connection_info.substr(0, pos_y);
+      it.second.remote_host_name =
+          connection_info.substr(pos_y + 1, pos_at - pos_y - 1);
+      it.second.password = connection_info.substr(pos_at + 1);
+      it.second.remember_password = true;
     } else if ('N' == connection_info[9] && connection_info.size() >= 10) {
-      remote_id = connection_info.substr(0, 9);
-      host_name = connection_info.substr(10);
+      size_t pos_n = connection_info.find('N');
+      size_t pos_at = connection_info.find('@');
+
+      if (pos_n == std::string::npos) {
+        LOG_ERROR("Invalid filename");
+        continue;
+      }
+
+      it.second.remote_id = connection_info.substr(0, pos_n);
+      it.second.remote_host_name = connection_info.substr(pos_n + 1);
+      it.second.password = "";
+      it.second.remember_password = false;
     } else {
-      host_name = "unknown";
+      it.second.remote_host_name = "unknown";
     }
 
     ImVec2 image_screen_pos = ImVec2(ImGui::GetCursorScreenPos().x + 5.0f,
@@ -101,7 +117,7 @@ int Render::ShowRecentConnections() {
     ImVec2 image_pos =
         ImVec2(ImGui::GetCursorPosX() + 5.0f, ImGui::GetCursorPosY() + 5.0f);
     ImGui::SetCursorPos(image_pos);
-    ImGui::Image((ImTextureID)(intptr_t)it->second,
+    ImGui::Image((ImTextureID)(intptr_t)it.second.texture,
                  ImVec2((float)recent_connection_image_width_,
                         (float)recent_connection_image_height_));
 
@@ -113,7 +129,7 @@ int Render::ShowRecentConnections() {
 
       ImVec2 dummy_button_pos =
           ImVec2(image_pos.x, image_pos.y + recent_connection_image_height_);
-      std::string dummy_button_name = "##DummyButton" + remote_id;
+      std::string dummy_button_name = "##DummyButton" + it.second.remote_id;
       ImGui::SetCursorPos(dummy_button_pos);
       ImGui::SetWindowFontScale(0.6f);
       ImGui::Button(dummy_button_name.c_str(),
@@ -123,14 +139,14 @@ int Render::ShowRecentConnections() {
       ImGui::SetCursorPos(
           ImVec2(dummy_button_pos.x + 2.0f, dummy_button_pos.y + 1.0f));
       ImGui::SetWindowFontScale(0.65f);
-      ImGui::Text("%s", remote_id.c_str());
+      ImGui::Text("%s", it.second.remote_id.c_str());
       ImGui::SetWindowFontScale(1.0f);
       ImGui::PopStyleColor(3);
 
       if (ImGui::IsItemHovered()) {
         ImGui::BeginTooltip();
         ImGui::SetWindowFontScale(0.5f);
-        ImGui::Text("%s", host_name.c_str());
+        ImGui::Text("%s", it.second.remote_host_name.c_str());
         ImGui::SetWindowFontScale(1.0f);
         ImGui::EndTooltip();
       }
@@ -155,10 +171,11 @@ int Render::ShowRecentConnections() {
       if (ImGui::Button(recent_connection_delete_button_name.c_str(),
                         ImVec2(button_width, button_height))) {
         show_confirm_delete_connection_ = true;
+        delete_connection_name_ = it.first;
       }
 
-      if (delete_connection_) {
-        if (!thumbnail_->DeleteThumbnail(it->first)) {
+      if (delete_connection_ && delete_connection_name_ == it.first) {
+        if (!thumbnail_->DeleteThumbnail(it.first)) {
           reload_recent_connections_ = true;
           delete_connection_ = false;
         }
@@ -173,15 +190,11 @@ int Render::ShowRecentConnections() {
       ImGui::SetCursorPos(connect_button_pos);
       std::string connect = ICON_FA_ARROW_RIGHT_LONG;
       std::string connect_to_this_connection_button_name =
-          connect + "##ConnectionTo" + it->first;
+          connect + "##ConnectionTo" + it.first;
       if (ImGui::Button(connect_to_this_connection_button_name.c_str(),
                         ImVec2(button_width, button_height))) {
-        remote_id_ = remote_id;
-        if (!password.empty() && password.size() == 6) {
-          remember_password_ = true;
-        }
-        memcpy(remote_password_, password.c_str(), 6);
-        ConnectTo();
+        ConnectTo(it.second.remote_id, it.second.password.c_str(),
+                  it.second.remember_password);
       }
     }
     ImGui::SetWindowFontScale(1.0f);

src/single_window/remote_peer_window.cpp

@@ -68,18 +68,45 @@ int Render::RemoteWindow() {
 
       ImGui::PopStyleVar();
       ImGui::SameLine();
+
+      std::string remote_id = remote_id_display_;
+      remote_id.erase(remove_if(remote_id.begin(), remote_id.end(),
+                                static_cast<int (*)(int)>(&isspace)),
+                      remote_id.end());
       if (ImGui::Button(ICON_FA_ARROW_RIGHT_LONG, ImVec2(55, 38)) ||
           enter_pressed) {
         connect_button_pressed_ = true;
-        remote_id_ = remote_id_display_;
-        remote_id_.erase(remove_if(remote_id_.begin(), remote_id_.end(),
-                                   static_cast<int (*)(int)>(&isspace)),
-                         remote_id_.end());
-        ConnectTo();
+        bool found = false;
+        for (auto &[id, props] : recent_connections_) {
+          if (id.find(remote_id) != std::string::npos) {
+            found = true;
+            if (client_properties_.find(remote_id) !=
+                client_properties_.end()) {
+              if (!client_properties_[remote_id]->connection_established_) {
+                ConnectTo(props.remote_id, props.password.c_str(), false);
+              } else {
+                // todo: show warning message
+                LOG_INFO("Already connected to [{}]", remote_id);
+              }
+            } else {
+              ConnectTo(props.remote_id, props.password.c_str(), false);
+            }
+          }
+        }
+
+        if (!found) {
+          ConnectTo(remote_id, "", false);
+        }
       }
 
-      if (rejoin_) {
-        ConnectTo();
+      if (need_to_rejoin_) {
+        need_to_rejoin_ = false;
+        for (const auto &[_, props] : client_properties_) {
+          if (props->rejoin_) {
+            ConnectTo(props->remote_id_, props->remote_password_,
+                      props->remember_password_);
+          }
+        }
       }
     }
     ImGui::EndChild();
@@ -102,32 +129,51 @@ static int InputTextCallback(ImGuiInputTextCallbackData *data) {
   return 0;
 }
 
-int Render::ConnectTo() {
-  connection_status_ = ConnectionStatus::Connecting;
-  int ret = -1;
-  if (signal_connected_) {
-    if (!connection_established_) {
-      if (0 == strcmp(remote_id_.c_str(), client_id_) && !peer_reserved_) {
-        peer_reserved_ = CreatePeer(&params_);
-        if (peer_reserved_) {
-          LOG_INFO("Create peer[reserved] instance successful");
-          std::string client_id = "C-";
-          client_id += client_id_;
-          Init(peer_reserved_, client_id.c_str());
-          LOG_INFO("Peer[reserved] init finish");
-        } else {
-          LOG_INFO("Create peer[reserved] instance failed");
-        }
-      }
+int Render::ConnectTo(const std::string &remote_id, const char *password,
+                      bool remember_password) {
+  LOG_INFO("Connect to [{}]", remote_id);
+  focused_remote_id_ = remote_id;
 
-      ret = JoinConnection(peer_reserved_ ? peer_reserved_ : peer_,
-                           remote_id_.c_str(), remote_password_);
-      if (0 == ret) {
-        is_client_mode_ = true;
-        rejoin_ = false;
-      } else {
-        rejoin_ = true;
-      }
+  if (client_properties_.find(remote_id) == client_properties_.end()) {
+    client_properties_[remote_id] =
+        std::make_shared<SubStreamWindowProperties>();
+    auto props = client_properties_[remote_id];
+    props->local_id_ = "C-" + std::string(client_id_);
+    props->remote_id_ = remote_id;
+    memcpy(&props->params_, &params_, sizeof(Params));
+    props->params_.user_id = props->local_id_.c_str();
+    props->peer_ = CreatePeer(&props->params_);
+    AddAudioStream(props->peer_, props->audio_label_.c_str());
+    AddDataStream(props->peer_, props->data_label_.c_str());
+
+    if (props->peer_) {
+      LOG_INFO("[{}] Create peer instance successful", props->local_id_);
+      Init(props->peer_);
+      LOG_INFO("[{}] Peer init finish", props->local_id_);
+    } else {
+      LOG_INFO("Create peer [{}] instance failed", props->local_id_);
+    }
+
+    props->connection_status_ = ConnectionStatus::Connecting;
+  }
+  int ret = -1;
+  auto props = client_properties_[remote_id];
+  if (!props->connection_established_) {
+    props->remember_password_ = remember_password;
+    if (strcmp(password, "") != 0 &&
+        strcmp(password, props->remote_password_) != 0) {
+      strncpy(props->remote_password_, password,
+              sizeof(props->remote_password_) - 1);
+      props->remote_password_[sizeof(props->remote_password_) - 1] = '\0';
+    }
+
+    std::string remote_id_with_pwd = remote_id + "@" + password;
+    ret = JoinConnection(props->peer_, remote_id_with_pwd.c_str());
+    if (0 == ret) {
+      props->rejoin_ = false;
+    } else {
+      props->rejoin_ = true;
+      need_to_rejoin_ = true;
     }
   }
 

src/single_window/render.h

@@ -12,20 +12,105 @@
 #include <atomic>
 #include <chrono>
 #include <fstream>
+#include <mutex>
+#include <optional>
 #include <string>
+#include <unordered_map>
 
-#include "../../thirdparty/projectx/src/interface/x.h"
 #include "IconsFontAwesome6.h"
 #include "config_center.h"
 #include "device_controller_factory.h"
 #include "imgui.h"
 #include "imgui_impl_sdl2.h"
 #include "imgui_impl_sdlrenderer2.h"
+#include "imgui_internal.h"
+#include "minirtc.h"
+#include "path_manager.h"
 #include "screen_capturer_factory.h"
 #include "speaker_capturer_factory.h"
 #include "thumbnail.h"
 
 class Render {
+ public:
+  struct SubStreamWindowProperties {
+    Params params_;
+    PeerPtr *peer_ = nullptr;
+    std::string audio_label_ = "control_audio";
+    std::string data_label_ = "control_data";
+    std::string local_id_ = "";
+    std::string remote_id_ = "";
+    bool exit_ = false;
+    bool signal_connected_ = false;
+    SignalStatus signal_status_ = SignalStatus::SignalClosed;
+    bool connection_established_ = false;
+    bool rejoin_ = false;
+    bool net_traffic_stats_button_pressed_ = false;
+    bool mouse_control_button_pressed_ = false;
+    bool mouse_controller_is_started_ = false;
+    bool audio_capture_button_pressed_ = false;
+    bool control_mouse_ = false;
+    bool streaming_ = false;
+    bool is_control_bar_in_left_ = true;
+    bool control_bar_hovered_ = false;
+    bool display_selectable_hovered_ = false;
+    bool control_bar_expand_ = true;
+    bool reset_control_bar_pos_ = false;
+    bool control_window_width_is_changing_ = false;
+    bool control_window_height_is_changing_ = false;
+    bool p2p_mode_ = true;
+    bool remember_password_ = false;
+    char remote_password_[7] = "";
+    float sub_stream_window_width_ = 1280;
+    float sub_stream_window_height_ = 720;
+    float control_window_min_width_ = 20;
+    float control_window_max_width_ = 230;
+    float control_window_min_height_ = 40;
+    float control_window_max_height_ = 150;
+    float control_window_width_ = 230;
+    float control_window_height_ = 40;
+    float control_bar_pos_x_ = 0;
+    float control_bar_pos_y_ = 30;
+    float mouse_diff_control_bar_pos_x_ = 0;
+    float mouse_diff_control_bar_pos_y_ = 0;
+    double control_bar_button_pressed_time_ = 0;
+    double net_traffic_stats_button_pressed_time_ = 0;
+    unsigned char *dst_buffer_ = nullptr;
+    size_t dst_buffer_capacity_ = 0;
+    int mouse_pos_x_ = 0;
+    int mouse_pos_y_ = 0;
+    int mouse_pos_x_last_ = 0;
+    int mouse_pos_y_last_ = 0;
+    int texture_width_ = 1280;
+    int texture_height_ = 720;
+    int video_width_ = 0;
+    int video_height_ = 0;
+    int video_width_last_ = 0;
+    int video_height_last_ = 0;
+    int selected_display_ = 0;
+    size_t video_size_ = 0;
+    bool tab_selected_ = false;
+    bool tab_opened_ = true;
+    std::optional<float> pos_x_before_docked_;
+    std::optional<float> pos_y_before_docked_;
+    float render_window_x_ = 0;
+    float render_window_y_ = 0;
+    float render_window_width_ = 0;
+    float render_window_height_ = 0;
+    std::string fullscreen_button_label_ = "Fullscreen";
+    std::string net_traffic_stats_button_label_ = "Show Net Traffic Stats";
+    std::string mouse_control_button_label_ = "Mouse Control";
+    std::string audio_capture_button_label_ = "Audio Capture";
+    std::string remote_host_name_ = "";
+    std::vector<DisplayInfo> display_info_list_;
+    SDL_Texture *stream_texture_ = nullptr;
+    SDL_Rect stream_render_rect_;
+    SDL_Rect stream_render_rect_last_;
+    ImVec2 control_window_pos_;
+    ConnectionStatus connection_status_ = ConnectionStatus::Closed;
+    TraversalMode traversal_mode_ = TraversalMode::UnknownMode;
+    XNetTrafficStats net_traffic_stats_;
+  };
+
  public:
   Render();
   ~Render();
@@ -33,6 +118,26 @@ class Render {
  public:
   int Run();
 
+ private:
+  void InitializeLogger();
+  void InitializeSettings();
+  void InitializeSDL();
+  void InitializeModules();
+  void InitializeMainWindow();
+  void MainLoop();
+  void UpdateLabels();
+  void UpdateInteractions();
+  void HandleRecentConnections();
+  void HandleStreamWindow();
+  void Cleanup();
+  void CleanupFactories();
+  void CleanupPeer(std::shared_ptr<SubStreamWindowProperties> props);
+  void CleanupPeers();
+  void CleanSubStreamWindowProperties(
+      std::shared_ptr<SubStreamWindowProperties> props);
+  void UpdateRenderRect();
+  void ProcessSdlEvent();
+
  private:
   int CreateStreamRenderWindow();
   int TitleBar(bool main_window);
@@ -42,17 +147,17 @@ class Render {
   int RemoteWindow();
   int RecentConnectionsWindow();
   int SettingWindow();
-  int ControlWindow();
-  int ControlBar();
+  int ControlWindow(std::shared_ptr<SubStreamWindowProperties> &props);
+  int ControlBar(std::shared_ptr<SubStreamWindowProperties> &props);
   int AboutWindow();
   int StatusBar();
-  int ConnectionStatusWindow();
-  int LoadRecentConnections();
+  bool ConnectionStatusWindow(
+      std::shared_ptr<SubStreamWindowProperties> &props);
   int ShowRecentConnections();
 
  private:
-  int CreateRtcConnection();
-  int ConnectTo();
+  int ConnectTo(const std::string &remote_id, const char *password,
+                bool remember_password);
   int CreateMainWindow();
   int DestroyMainWindow();
   int CreateStreamWindow();
@@ -65,7 +170,9 @@ class Render {
   int DrawMainWindow();
   int DrawStreamWindow();
   int ConfirmDeleteConnection();
-  int NetTrafficStats();
+  int NetTrafficStats(std::shared_ptr<SubStreamWindowProperties> &props);
+  void DrawConnectionStatusText(
+      std::shared_ptr<SubStreamWindowProperties> &props);
 
  public:
   static void OnReceiveVideoBufferCb(const XVideoFrame *video_frame,
@@ -80,7 +187,8 @@ class Render {
                                     const char *user_id, size_t user_id_size,
                                     void *user_data);
 
-  static void OnSignalStatusCb(SignalStatus status, void *user_data);
+  static void OnSignalStatusCb(SignalStatus status, const char *user_id,
+                               size_t user_id_size, void *user_data);
 
   static void OnConnectionStatusCb(ConnectionStatus status, const char *user_id,
                                    size_t user_id_size, void *user_data);
@@ -88,17 +196,22 @@ class Render {
   static void NetStatusReport(const char *client_id, size_t client_id_size,
                               TraversalMode mode,
                               const XNetTrafficStats *net_traffic_stats,
+                              const char *user_id, const size_t user_id_size,
                               void *user_data);
 
   static SDL_HitTestResult HitTestCallback(SDL_Window *window,
                                            const SDL_Point *area, void *data);
 
- private:
-  int ProcessMouseKeyEvent(SDL_Event &event);
-  int ProcessMouseEvent(SDL_Event &event);
+  static std::vector<char> SerializeRemoteAction(const RemoteAction &action);
 
-  int SendKeyEvent(int key_code, bool is_down);
-  int ProcessKeyEvent(int key_code, bool is_down);
+  static bool DeserializeRemoteAction(const char *data, size_t size,
+                                      RemoteAction &out);
+
+  static void FreeRemoteAction(RemoteAction &action);
+
+ private:
+  int SendKeyCommand(int key_code, bool is_down);
+  int ProcessMouseEvent(SDL_Event &event);
 
   static void SdlCaptureAudioIn(void *userdata, Uint8 *stream, int len);
   static void SdlCaptureAudioOut(void *userdata, Uint8 *stream, int len);
@@ -107,6 +220,7 @@ class Render {
   int SaveSettingsIntoCacheFile();
   int LoadSettingsFromCacheFile();
 
+  int ScreenCapturerInit();
   int StartScreenCapturer();
   int StopScreenCapturer();
 
@@ -125,9 +239,8 @@ class Render {
   int AudioDeviceDestroy();
 
  private:
-  typedef struct {
-    char client_id[10];
-    char password[7];
+  struct CDCache {
+    char client_id_with_password[17];
     int language;
     int video_quality;
     int video_encode_format;
@@ -136,64 +249,67 @@ class Render {
 
     unsigned char key[16];
     unsigned char iv[16];
-  } CDCache;
+  };
 
  private:
   CDCache cd_cache_;
   std::mutex cd_cache_mutex_;
-
   ConfigCenter config_center_;
   ConfigCenter::LANGUAGE localization_language_ =
       ConfigCenter::LANGUAGE::CHINESE;
-
+  std::unique_ptr<PathManager> path_manager_;
+  std::string cert_path_;
+  std::string exec_log_path_;
+  std::string dll_log_path_;
+  std::string cache_path_;
+  std::string imgui_cache_path_;
   int localization_language_index_ = -1;
   int localization_language_index_last_ = -1;
-
   bool modules_inited_ = false;
-
- private:
-  std::string window_title = "Remote Desk Client";
-  std::string mac_addr_str_ = "";
-  std::string connect_button_label_ = "Connect";
-  std::string fullscreen_button_label_ = "Fullscreen";
-  std::string net_traffic_stats_button_label_ = "Show Net Traffic Stats";
-  std::string mouse_control_button_label_ = "Mouse Control";
-  std::string audio_capture_button_label_ = "Audio Capture";
-  std::string settings_button_label_ = "Setting";
-  char input_password_tmp_[7] = "";
-  char input_password_[7] = "";
-  std::string random_password_ = "";
-  char remote_password_[7] = "";
-  char new_password_[7] = "";
-  char remote_id_display_[12] = "";
-  std::string remote_id_ = "";
-  char client_password_[20] = "";
-
- private:
+  /* ------ all windows property start ------ */
   float title_bar_width_ = 640;
   float title_bar_height_ = 30;
-  int screen_width_ = 1280;
-  int screen_height_ = 720;
+  /* ------ all windows property end ------ */
+
+  /* ------ main window property start ------ */
+  // thumbnail
+  unsigned char aes128_key_[16];
+  unsigned char aes128_iv_[16];
+  std::unique_ptr<Thumbnail> thumbnail_;
+
+  // recent connections
+  std::vector<std::pair<std::string, Thumbnail::RecentConnection>>
+      recent_connections_;
+  int recent_connection_image_width_ = 160;
+  int recent_connection_image_height_ = 90;
+  uint32_t recent_connection_image_save_time_ = 0;
+
+  // main window render
+  SDL_Window *main_window_ = nullptr;
+  SDL_Renderer *main_renderer_ = nullptr;
+  ImGuiContext *main_ctx_ = nullptr;
+  bool exit_ = false;
+
+  // main window properties
+  bool start_mouse_controller_ = false;
+  bool mouse_controller_is_started_ = false;
+  bool start_screen_capturer_ = false;
+  bool screen_capturer_is_started_ = false;
+  bool start_keyboard_capturer_ = false;
+  bool keyboard_capturer_is_started_ = false;
+  bool foucs_on_main_window_ = false;
+  bool foucs_on_stream_window_ = false;
+  bool audio_capture_ = false;
+  int main_window_width_real_ = 720;
+  int main_window_height_real_ = 540;
+  float main_window_dpi_scaling_w_ = 1.0f;
+  float main_window_dpi_scaling_h_ = 1.0f;
   float main_window_width_default_ = 640;
   float main_window_height_default_ = 480;
   float main_window_width_ = 640;
   float main_window_height_ = 480;
   float main_window_width_last_ = 640;
   float main_window_height_last_ = 480;
-  int stream_window_width_default_ = 1280;
-  int stream_window_height_default_ = 720;
-  float stream_window_width_ = 1280;
-  float stream_window_height_ = 720;
-  int stream_window_width_last_ = 1280;
-  int stream_window_height_last_ = 720;
-  float stream_window_width_before_maximized_ = 1280;
-  float stream_window_height_before_maximized_ = 720;
-  float control_window_min_width_ = 20;
-  float control_window_max_width_ = 200;
-  float control_window_min_height_ = 40;
-  float control_window_max_height_ = 150;
-  float control_window_width_ = 200;
-  float control_window_height_ = 40;
   float local_window_width_ = 320;
   float local_window_height_ = 235;
   float remote_window_width_ = 320;
@@ -212,141 +328,82 @@ class Render {
   float notification_window_height_ = 80;
   float about_window_width_ = 200;
   float about_window_height_ = 150;
+  int screen_width_ = 1280;
+  int screen_height_ = 720;
+  int selected_display_ = 0;
+  std::string connect_button_label_ = "Connect";
+  char input_password_tmp_[7] = "";
+  char input_password_[7] = "";
+  std::string random_password_ = "";
+  char new_password_[7] = "";
+  char remote_id_display_[12] = "";
+  unsigned char audio_buffer_[720];
+  int audio_len_ = 0;
+  bool audio_buffer_fresh_ = false;
+  bool need_to_rejoin_ = false;
+  bool just_created_ = false;
+  std::string controlled_remote_id_ = "";
+  std::string focused_remote_id_ = "";
+  bool need_to_send_host_info_ = false;
+  SDL_Event last_mouse_event;
 
-  float control_bar_pos_x_ = 0;
-  float control_bar_pos_y_ = 30;
-  float mouse_diff_control_bar_pos_x_ = 0;
-  float mouse_diff_control_bar_pos_y_ = 0;
-  int mouse_pos_x_ = 0;
-  int mouse_pos_y_ = 0;
-  int mouse_pos_x_last_ = 0;
-  int mouse_pos_y_last_ = 0;
-
-  int main_window_width_real_ = 720;
-  int main_window_height_real_ = 540;
-  float main_window_dpi_scaling_w_ = 1.0f;
-  float main_window_dpi_scaling_h_ = 1.0f;
+  // stream window render
+  SDL_Window *stream_window_ = nullptr;
+  SDL_Renderer *stream_renderer_ = nullptr;
+  ImGuiContext *stream_ctx_ = nullptr;
 
+  // stream window properties
+  bool need_to_create_stream_window_ = false;
+  bool stream_window_created_ = false;
+  bool stream_window_inited_ = false;
+  bool window_maximized_ = false;
+  bool stream_window_grabbed_ = false;
+  bool control_mouse_ = false;
+  int stream_window_width_default_ = 1280;
+  int stream_window_height_default_ = 720;
+  float stream_window_width_ = 1280;
+  float stream_window_height_ = 720;
+  uint32_t stream_pixformat_ = 0;
   int stream_window_width_real_ = 1280;
   int stream_window_height_real_ = 720;
   float stream_window_dpi_scaling_w_ = 1.0f;
   float stream_window_dpi_scaling_h_ = 1.0f;
 
-  int texture_width_ = 1280;
-  int texture_height_ = 720;
-
-  int video_width_ = 1280;
-  int video_height_ = 720;
-  size_t video_size_ = 1280 * 720 * 3;
-
-  SDL_Window *main_window_ = nullptr;
-  SDL_Renderer *main_renderer_ = nullptr;
-  ImGuiContext *main_ctx_ = nullptr;
-
-  SDL_Window *stream_window_ = nullptr;
-  SDL_Renderer *stream_renderer_ = nullptr;
-  ImGuiContext *stream_ctx_ = nullptr;
-  bool stream_window_created_ = false;
-  bool stream_window_inited_ = false;
-
-  // recent connections
-  std::map<std::string, SDL_Texture *> recent_connection_textures_;
-  int recent_connection_image_width_ = 160;
-  int recent_connection_image_height_ = 90;
-  uint32_t recent_connection_image_save_time_ = 0;
-
-  // video window
-  SDL_Texture *stream_texture_ = nullptr;
-  SDL_Rect stream_render_rect_;
-  SDL_Rect stream_render_rect_last_;
-  uint32_t stream_pixformat_ = 0;
-  std::string host_name_ = "";
-
-  unsigned char aes128_key_[16];
-  unsigned char aes128_iv_[16];
-  std::unique_ptr<Thumbnail> thumbnail_;
-
-  bool resizable_ = false;
   bool label_inited_ = false;
-  bool exit_ = false;
-  bool exit_video_window_ = false;
-  bool connection_established_ = false;
   bool connect_button_pressed_ = false;
   bool password_validating_ = false;
   uint32_t password_validating_time_ = 0;
-  bool fullscreen_button_pressed_ = false;
-  bool net_traffic_stats_button_pressed_ = false;
-  bool mouse_control_button_pressed_ = false;
-  bool audio_capture_button_pressed_ = false;
   bool show_settings_window_ = false;
-  bool is_create_connection_ = false;
-  bool audio_buffer_fresh_ = false;
   bool rejoin_ = false;
-  bool control_mouse_ = false;
-  bool stream_window_grabbed_ = false;
-  bool audio_capture_ = true;
   bool local_id_copied_ = false;
   bool show_password_ = true;
-  bool password_inited_ = false;
   bool regenerate_password_ = false;
   bool show_about_window_ = false;
   bool show_connection_status_window_ = false;
   bool show_reset_password_window_ = false;
+  bool fullscreen_button_pressed_ = false;
   bool focus_on_input_widget_ = true;
-  bool window_maximized_ = false;
-  bool streaming_ = false;
   bool is_client_mode_ = false;
-  bool is_control_bar_in_left_ = true;
-  bool is_control_bar_in_top_ = true;
-  bool control_bar_hovered_ = false;
-  bool control_bar_expand_ = true;
-  bool reset_control_bar_pos_ = false;
-  bool control_window_width_is_changing_ = false;
-  bool control_window_height_is_changing_ = false;
   bool reload_recent_connections_ = true;
-  bool hostname_sent_ = false;
   bool show_confirm_delete_connection_ = false;
   bool delete_connection_ = false;
-  bool remember_password_ = false;
+  bool is_tab_bar_hovered_ = false;
+  std::string delete_connection_name_ = "";
   bool re_enter_remote_id_ = false;
-
   double copy_start_time_ = 0;
   double regenerate_password_start_time_ = 0;
-  double control_bar_button_pressed_time_ = 0;
-  double net_traffic_stats_button_pressed_time_ = 0;
-
-  ImVec2 control_winodw_pos_;
-
-  int fps_ = 0;
-  uint32_t start_time_;
-  uint32_t end_time_;
-  uint32_t elapsed_time_;
-  uint32_t frame_count_ = 0;
-
- private:
-  ConnectionStatus connection_status_ = ConnectionStatus::Closed;
   SignalStatus signal_status_ = SignalStatus::SignalClosed;
   std::string signal_status_str_ = "";
-  std::string connection_status_str_ = "";
   bool signal_connected_ = false;
-  bool p2p_mode_ = true;
-
- private:
   PeerPtr *peer_ = nullptr;
   PeerPtr *peer_reserved_ = nullptr;
+  std::string video_primary_label_ = "primary_display";
+  std::string video_secondary_label_ = "secondary_display";
+  std::string audio_label_ = "audio";
+  std::string data_label_ = "data";
   Params params_;
-  TraversalMode traversal_mode_ = TraversalMode::UnknownMode;
-  XNetTrafficStats net_traffic_stats_;
-
- private:
   SDL_AudioDeviceID input_dev_;
   SDL_AudioDeviceID output_dev_;
-  unsigned char audio_buffer_[720];
-  int audio_len_ = 0;
-  unsigned char *dst_buffer_ = nullptr;
-  size_t dst_buffer_capacity_ = 0;
-
- private:
   ScreenCapturerFactory *screen_capturer_factory_ = nullptr;
   ScreenCapturer *screen_capturer_ = nullptr;
   SpeakerCapturerFactory *speaker_capturer_factory_ = nullptr;
@@ -354,34 +411,30 @@ class Render {
   DeviceControllerFactory *device_controller_factory_ = nullptr;
   MouseController *mouse_controller_ = nullptr;
   KeyboardCapturer *keyboard_capturer_ = nullptr;
+  std::vector<DisplayInfo> display_info_list_;
   uint64_t last_frame_time_;
-
- private:
   char client_id_[10] = "";
   char client_id_display_[12] = "";
+  char client_id_with_password_[17] = "";
   char password_saved_[7] = "";
   int language_button_value_ = 0;
   int video_quality_button_value_ = 0;
   int video_encode_format_button_value_ = 0;
   bool enable_hardware_video_codec_ = false;
   bool enable_turn_ = false;
-
   int language_button_value_last_ = 0;
   int video_quality_button_value_last_ = 0;
   int video_encode_format_button_value_last_ = 0;
   bool enable_hardware_video_codec_last_ = false;
   bool enable_turn_last_ = false;
-
- private:
-  std::atomic<bool> start_screen_capturer_{false};
-  std::atomic<bool> start_mouse_controller_{false};
-  std::atomic<bool> start_keyboard_capturer_{false};
-  std::atomic<bool> screen_capturer_is_started_{false};
-  std::atomic<bool> mouse_controller_is_started_{false};
-  std::atomic<bool> keyboard_capturer_is_started_{false};
-
- private:
   bool settings_window_pos_reset_ = true;
+  /* ------ main window property end ------ */
+
+  /* ------ sub stream window property start ------ */
+  std::unordered_map<std::string, std::shared_ptr<SubStreamWindowProperties>>
+      client_properties_;
+  void CloseTab(decltype(client_properties_)::iterator &it);
+  /* ------ stream window property end ------ */
 };
 
 #endif

src/single_window/render_callback_func.cpp

@@ -4,86 +4,16 @@
 #include "rd_log.h"
 #include "render.h"
 
-// Refresh Event
-#define REFRESH_EVENT (SDL_USEREVENT + 1)
 #define NV12_BUFFER_SIZE 1280 * 720 * 3 / 2
 
-#ifdef REMOTE_DESK_DEBUG
+#define STREAM_FRASH (SDL_USEREVENT + 1)
+
+#ifdef DESK_PORT_DEBUG
 #else
 #define MOUSE_CONTROL 1
 #endif
 
-int Render::ProcessMouseKeyEvent(SDL_Event &event) {
-  if (!control_mouse_ || !connection_established_) {
-    return 0;
-  }
-
-  if (SDL_KEYDOWN == event.type || SDL_KEYUP == event.type) {
-  } else {
-    ProcessMouseEvent(event);
-  }
-
-  return 0;
-}
-
-int Render::ProcessMouseEvent(SDL_Event &event) {
-  float ratio_x = (float)video_width_ / (float)stream_render_rect_.w;
-  float ratio_y = (float)video_height_ / (float)stream_render_rect_.h;
-
-  if (event.button.x <= stream_render_rect_.x) {
-    event.button.x = 0;
-  } else if (event.button.x > stream_render_rect_.x &&
-             event.button.x < stream_render_rect_.x + stream_render_rect_.w) {
-    event.button.x -= stream_render_rect_.x;
-  } else if (event.button.x >= stream_render_rect_.x + stream_render_rect_.w) {
-    event.button.x = stream_render_rect_.w;
-  }
-
-  if (event.button.y <= stream_render_rect_.y) {
-    event.button.y = 0;
-  } else if (event.button.y > stream_render_rect_.y &&
-             event.button.y < stream_render_rect_.y + stream_render_rect_.h) {
-    event.button.y -= stream_render_rect_.y;
-  } else if (event.button.y >= stream_render_rect_.y + stream_render_rect_.h) {
-    event.button.y = stream_render_rect_.h;
-  }
-
-  RemoteAction remote_action;
-  remote_action.m.x = (size_t)(event.button.x * ratio_x);
-  remote_action.m.y = (size_t)(event.button.y * ratio_y);
-
-  if (SDL_MOUSEBUTTONDOWN == event.type) {
-    remote_action.type = ControlType::mouse;
-    if (SDL_BUTTON_LEFT == event.button.button) {
-      remote_action.m.flag = MouseFlag::left_down;
-    } else if (SDL_BUTTON_RIGHT == event.button.button) {
-      remote_action.m.flag = MouseFlag::right_down;
-    }
-    if (control_bar_hovered_) {
-      remote_action.m.flag = MouseFlag::move;
-    }
-    SendDataFrame(peer_, (const char *)&remote_action, sizeof(remote_action));
-  } else if (SDL_MOUSEBUTTONUP == event.type) {
-    remote_action.type = ControlType::mouse;
-    if (SDL_BUTTON_LEFT == event.button.button) {
-      remote_action.m.flag = MouseFlag::left_up;
-    } else if (SDL_BUTTON_RIGHT == event.button.button) {
-      remote_action.m.flag = MouseFlag::right_up;
-    }
-    if (control_bar_hovered_) {
-      remote_action.m.flag = MouseFlag::move;
-    }
-    SendDataFrame(peer_, (const char *)&remote_action, sizeof(remote_action));
-  } else if (SDL_MOUSEMOTION == event.type) {
-    remote_action.type = ControlType::mouse;
-    remote_action.m.flag = MouseFlag::move;
-    SendDataFrame(peer_, (const char *)&remote_action, sizeof(remote_action));
-  }
-
-  return 0;
-}
-
-int Render::SendKeyEvent(int key_code, bool is_down) {
+int Render::SendKeyCommand(int key_code, bool is_down) {
   RemoteAction remote_action;
   remote_action.type = ControlType::keyboard;
   if (is_down) {
@@ -93,14 +23,113 @@ int Render::SendKeyEvent(int key_code, bool is_down) {
   }
   remote_action.k.key_value = key_code;
 
-  SendDataFrame(peer_, (const char *)&remote_action, sizeof(remote_action));
+  if (!controlled_remote_id_.empty()) {
+    if (client_properties_.find(controlled_remote_id_) !=
+        client_properties_.end()) {
+      auto props = client_properties_[controlled_remote_id_];
+      if (props->connection_status_ == ConnectionStatus::Connected) {
+        SendDataFrame(props->peer_, (const char *)&remote_action,
+                      sizeof(remote_action), props->data_label_.c_str());
+      }
+    }
+  }
 
   return 0;
 }
 
-int Render::ProcessKeyEvent(int key_code, bool is_down) {
-  if (keyboard_capturer_) {
-    keyboard_capturer_->SendKeyboardCommand(key_code, is_down);
+int Render::ProcessMouseEvent(SDL_Event &event) {
+  controlled_remote_id_ = "";
+  int video_width, video_height = 0;
+  int render_width, render_height = 0;
+  float ratio_x, ratio_y = 0;
+  RemoteAction remote_action;
+
+  for (auto &it : client_properties_) {
+    auto props = it.second;
+    if (!props->control_mouse_) {
+      continue;
+    }
+
+    if (event.button.x >= props->stream_render_rect_.x &&
+        event.button.x <=
+            props->stream_render_rect_.x + props->stream_render_rect_.w &&
+        event.button.y >= props->stream_render_rect_.y &&
+        event.button.y <=
+            props->stream_render_rect_.y + props->stream_render_rect_.h) {
+      controlled_remote_id_ = it.first;
+      render_width = props->stream_render_rect_.w;
+      render_height = props->stream_render_rect_.h;
+      last_mouse_event.button.x = event.button.x;
+      last_mouse_event.button.y = event.button.y;
+
+      remote_action.m.x =
+          (float)(event.button.x - props->stream_render_rect_.x) / render_width;
+      remote_action.m.y =
+          (float)(event.button.y - props->stream_render_rect_.y) /
+          render_height;
+
+      if (SDL_MOUSEBUTTONDOWN == event.type) {
+        remote_action.type = ControlType::mouse;
+        if (SDL_BUTTON_LEFT == event.button.button) {
+          remote_action.m.flag = MouseFlag::left_down;
+        } else if (SDL_BUTTON_RIGHT == event.button.button) {
+          remote_action.m.flag = MouseFlag::right_down;
+        } else if (SDL_BUTTON_MIDDLE == event.button.button) {
+          remote_action.m.flag = MouseFlag::middle_down;
+        }
+      } else if (SDL_MOUSEBUTTONUP == event.type) {
+        remote_action.type = ControlType::mouse;
+        if (SDL_BUTTON_LEFT == event.button.button) {
+          remote_action.m.flag = MouseFlag::left_up;
+        } else if (SDL_BUTTON_RIGHT == event.button.button) {
+          remote_action.m.flag = MouseFlag::right_up;
+        } else if (SDL_BUTTON_MIDDLE == event.button.button) {
+          remote_action.m.flag = MouseFlag::middle_up;
+        }
+      } else if (SDL_MOUSEMOTION == event.type) {
+        remote_action.type = ControlType::mouse;
+        remote_action.m.flag = MouseFlag::move;
+      }
+
+      if (props->control_bar_hovered_ || props->display_selectable_hovered_) {
+        remote_action.m.flag = MouseFlag::move;
+      }
+      SendDataFrame(props->peer_, (const char *)&remote_action,
+                    sizeof(remote_action), props->data_label_.c_str());
+    } else if (SDL_MOUSEWHEEL == event.type &&
+               last_mouse_event.button.x >= props->stream_render_rect_.x &&
+               last_mouse_event.button.x <= props->stream_render_rect_.x +
+                                                props->stream_render_rect_.w &&
+               last_mouse_event.button.y >= props->stream_render_rect_.y &&
+               last_mouse_event.button.y <= props->stream_render_rect_.y +
+                                                props->stream_render_rect_.h) {
+      int scroll_x = event.wheel.x;
+      int scroll_y = event.wheel.y;
+      if (event.wheel.direction == SDL_MOUSEWHEEL_FLIPPED) {
+        scroll_x = -scroll_x;
+        scroll_y = -scroll_y;
+      }
+
+      remote_action.type = ControlType::mouse;
+      if (scroll_x == 0) {
+        remote_action.m.flag = MouseFlag::wheel_vertical;
+        remote_action.m.s = scroll_y;
+      } else if (scroll_y == 0) {
+        remote_action.m.flag = MouseFlag::wheel_horizontal;
+        remote_action.m.s = scroll_x;
+      }
+
+      render_width = props->stream_render_rect_.w;
+      render_height = props->stream_render_rect_.h;
+      remote_action.m.x =
+          (float)(event.button.x - props->stream_render_rect_.x) / render_width;
+      remote_action.m.y =
+          (float)(event.button.y - props->stream_render_rect_.y) /
+          render_height;
+
+      SendDataFrame(props->peer_, (const char *)&remote_action,
+                    sizeof(remote_action), props->data_label_.c_str());
+    }
   }
 
   return 0;
@@ -113,9 +142,14 @@ void Render::SdlCaptureAudioIn(void *userdata, Uint8 *stream, int len) {
   }
 
   if (1) {
-    if ("Connected" == render->connection_status_str_) {
-      SendAudioFrame(render->peer_, (const char *)stream, len);
+    for (auto it : render->client_properties_) {
+      auto props = it.second;
+      if (props->connection_status_ == ConnectionStatus::Connected) {
+        SendAudioFrame(props->peer_, (const char *)stream, len,
+                       render->audio_label_.c_str());
+      }
     }
+
   } else {
     memcpy(render->audio_buffer_, stream, len);
     render->audio_len_ = len;
@@ -128,8 +162,11 @@ void Render::SdlCaptureAudioOut([[maybe_unused]] void *userdata,
                                 [[maybe_unused]] Uint8 *stream,
                                 [[maybe_unused]] int len) {
   // Render *render = (Render *)userdata;
-  // if ("Connected" == render->connection_status_str_) {
-  //   SendAudioFrame(render->peer_,  (const char *)stream, len);
+  // for (auto it : render->client_properties_) {
+  //   auto props = it.second;
+  //   if (props->connection_status_ == SignalStatus::SignalConnected) {
+  //     SendAudioFrame(props->peer_, (const char *)stream, len);
+  //   }
   // }
 
   // if (!render->audio_buffer_fresh_) {
@@ -150,41 +187,60 @@ void Render::SdlCaptureAudioOut([[maybe_unused]] void *userdata,
 }
 
 void Render::OnReceiveVideoBufferCb(const XVideoFrame *video_frame,
-                                    [[maybe_unused]] const char *user_id,
-                                    [[maybe_unused]] size_t user_id_size,
+                                    const char *user_id, size_t user_id_size,
                                     void *user_data) {
   Render *render = (Render *)user_data;
   if (!render) {
     return;
   }
 
-  if (render->connection_established_) {
-    if (!render->dst_buffer_) {
-      render->dst_buffer_capacity_ = video_frame->size;
-      render->dst_buffer_ = new unsigned char[video_frame->size];
+  std::string remote_id(user_id, user_id_size);
+  if (render->client_properties_.find(remote_id) ==
+      render->client_properties_.end()) {
+    return;
+  }
+  SubStreamWindowProperties *props =
+      render->client_properties_.find(remote_id)->second.get();
+
+  if (props->connection_established_) {
+    if (!props->dst_buffer_) {
+      props->dst_buffer_capacity_ = video_frame->size;
+      props->dst_buffer_ = new unsigned char[video_frame->size];
     }
 
-    if (render->dst_buffer_capacity_ < video_frame->size) {
-      delete render->dst_buffer_;
-      render->dst_buffer_capacity_ = video_frame->size;
-      render->dst_buffer_ = new unsigned char[video_frame->size];
+    if (props->dst_buffer_capacity_ < video_frame->size) {
+      delete props->dst_buffer_;
+      props->dst_buffer_capacity_ = video_frame->size;
+      props->dst_buffer_ = new unsigned char[video_frame->size];
     }
 
-    memcpy(render->dst_buffer_, video_frame->data, video_frame->size);
-    render->video_width_ = video_frame->width;
-    render->video_height_ = video_frame->height;
-    render->video_size_ = video_frame->size;
+    memcpy(props->dst_buffer_, video_frame->data, video_frame->size);
+    bool need_to_update_render_rect = false;
+    if (props->video_width_ != props->video_width_last_ ||
+        props->video_height_ != props->video_height_last_) {
+      need_to_update_render_rect = true;
+      props->video_width_last_ = props->video_width_;
+      props->video_height_last_ = props->video_height_;
+    }
+    props->video_width_ = video_frame->width;
+    props->video_height_ = video_frame->height;
+    props->video_size_ = video_frame->size;
+
+    if (need_to_update_render_rect) {
+      render->UpdateRenderRect();
+    }
 
     SDL_Event event;
-    event.type = REFRESH_EVENT;
+    event.type = STREAM_FRASH;
+    event.user.type = STREAM_FRASH;
+    event.user.data1 = props;
     SDL_PushEvent(&event);
-    render->streaming_ = true;
+    props->streaming_ = true;
   }
 }
 
 void Render::OnReceiveAudioBufferCb(const char *data, size_t size,
-                                    [[maybe_unused]] const char *user_id,
-                                    [[maybe_unused]] size_t user_id_size,
+                                    const char *user_id, size_t user_id_size,
                                     void *user_data) {
   Render *render = (Render *)user_data;
   if (!render) {
@@ -203,141 +259,207 @@ void Render::OnReceiveDataBufferCb(const char *data, size_t size,
     return;
   }
 
-  std::string user(user_id, user_id_size);
   RemoteAction remote_action;
   memcpy(&remote_action, data, size);
 
-  if (ControlType::mouse == remote_action.type && render->mouse_controller_) {
-    render->mouse_controller_->SendCommand(remote_action);
-  } else if (ControlType::audio_capture == remote_action.type) {
-    if (remote_action.a) {
-      render->StartSpeakerCapturer();
+  std::string remote_id(user_id, user_id_size);
+  if (render->client_properties_.find(remote_id) !=
+      render->client_properties_.end()) {
+    // local
+    auto props = render->client_properties_.find(remote_id)->second;
+    RemoteAction host_info;
+    if (DeserializeRemoteAction(data, size, host_info)) {
+      if (ControlType::host_infomation == host_info.type &&
+          props->remote_host_name_.empty()) {
+        props->remote_host_name_ =
+            std::string(host_info.i.host_name, host_info.i.host_name_size);
+        LOG_INFO("Remote hostname: [{}]", props->remote_host_name_);
+
+        for (int i = 0; i < host_info.i.display_num; i++) {
+          props->display_info_list_.push_back(DisplayInfo(
+              std::string(host_info.i.display_list[i]), host_info.i.left[i],
+              host_info.i.top[i], host_info.i.right[i], host_info.i.bottom[i]));
+          LOG_INFO("Remote display [{}:{}], bound [({}, {}) ({}, {})]", i + 1,
+                   props->display_info_list_[i].name,
+                   props->display_info_list_[i].left,
+                   props->display_info_list_[i].top,
+                   props->display_info_list_[i].right,
+                   props->display_info_list_[i].bottom);
+        }
+      }
     } else {
-      render->StopSpeakerCapturer();
+      props->remote_host_name_ = std::string(remote_action.i.host_name,
+                                             remote_action.i.host_name_size);
+      LOG_INFO("Remote hostname: [{}]", props->remote_host_name_);
+      LOG_ERROR("No remote display detected");
     }
-  } else if (ControlType::keyboard == remote_action.type) {
-    render->ProcessKeyEvent((int)remote_action.k.key_value,
-                            remote_action.k.flag == KeyFlag::key_down);
-  } else if (ControlType::host_infomation == remote_action.type) {
-    render->host_name_ =
-        std::string(remote_action.i.host_name, remote_action.i.host_name_size);
-    LOG_INFO("Remote hostname: [{}]", render->host_name_);
-  }
-}
-
-void Render::OnSignalStatusCb(SignalStatus status, void *user_data) {
-  Render *render = (Render *)user_data;
-  if (!render) {
-    return;
-  }
-
-  render->signal_status_ = status;
-  if (SignalStatus::SignalConnecting == status) {
-    render->signal_status_str_ = "SignalConnecting";
-    render->signal_connected_ = false;
-  } else if (SignalStatus::SignalConnected == status) {
-    render->signal_status_str_ = "SignalConnected";
-    render->signal_connected_ = true;
-  } else if (SignalStatus::SignalFailed == status) {
-    render->signal_status_str_ = "SignalFailed";
-    render->signal_connected_ = false;
-  } else if (SignalStatus::SignalClosed == status) {
-    render->signal_status_str_ = "SignalClosed";
-    render->signal_connected_ = false;
-  } else if (SignalStatus::SignalReconnecting == status) {
-    render->signal_status_str_ = "SignalReconnecting";
-    render->signal_connected_ = false;
-  } else if (SignalStatus::SignalServerClosed == status) {
-    render->signal_status_str_ = "SignalServerClosed";
-    render->signal_connected_ = false;
-    render->is_create_connection_ = false;
-  }
-}
-
-void Render::OnConnectionStatusCb(ConnectionStatus status,
-                                  [[maybe_unused]] const char *user_id,
-                                  [[maybe_unused]] const size_t user_id_size,
-                                  void *user_data) {
-  Render *render = (Render *)user_data;
-  if (!render) {
-    return;
-  }
-
-  render->connection_status_ = status;
-  render->show_connection_status_window_ = true;
-  if (ConnectionStatus::Connecting == status) {
-    render->connection_status_str_ = "Connecting";
-  } else if (ConnectionStatus::Gathering == status) {
-    render->connection_status_str_ = "Gathering";
-  } else if (ConnectionStatus::Connected == status) {
-    render->connection_status_str_ = "Connected";
-    render->connection_established_ = true;
-    if (render->peer_reserved_ || !render->is_client_mode_) {
-      render->start_screen_capturer_ = true;
-      render->start_mouse_controller_ = true;
-    }
-    if (!render->hostname_sent_) {
-      // TODO: self and remote hostname
-      std::string host_name = GetHostName();
-      RemoteAction remote_action;
-      remote_action.type = ControlType::host_infomation;
-      memcpy(&remote_action.i.host_name, host_name.data(), host_name.size());
-      remote_action.i.host_name_size = host_name.size();
-      int ret = SendDataFrame(render->peer_, (const char *)&remote_action,
-                              sizeof(remote_action));
-      if (0 == ret) {
-        render->hostname_sent_ = true;
+    FreeRemoteAction(host_info);
+  } else {
+    // remote
+    if (ControlType::mouse == remote_action.type && render->mouse_controller_) {
+      render->mouse_controller_->SendMouseCommand(remote_action,
+                                                  render->selected_display_);
+    } else if (ControlType::audio_capture == remote_action.type) {
+      if (remote_action.a) {
+        render->StartSpeakerCapturer();
+        render->audio_capture_ = true;
+      } else {
+        render->StopSpeakerCapturer();
+        render->audio_capture_ = false;
+      }
+    } else if (ControlType::keyboard == remote_action.type &&
+               render->keyboard_capturer_) {
+      render->keyboard_capturer_->SendKeyboardCommand(
+          (int)remote_action.k.key_value,
+          remote_action.k.flag == KeyFlag::key_down);
+    } else if (ControlType::display_id == remote_action.type) {
+      if (render->screen_capturer_) {
+        render->selected_display_ = remote_action.d;
+        render->screen_capturer_->SwitchTo(remote_action.d);
       }
     }
-  } else if (ConnectionStatus::Disconnected == status) {
-    render->connection_status_str_ = "Disconnected";
-    render->password_validating_time_ = 0;
-  } else if (ConnectionStatus::Failed == status) {
-    render->connection_status_str_ = "Failed";
-    render->password_validating_time_ = 0;
-  } else if (ConnectionStatus::Closed == status) {
-    render->connection_status_str_ = "Closed";
-    render->password_validating_time_ = 0;
-    render->start_screen_capturer_ = false;
-    render->start_mouse_controller_ = false;
-    render->connection_established_ = false;
-    render->control_mouse_ = false;
-    render->mouse_control_button_pressed_ = false;
-    render->start_keyboard_capturer_ = false;
-    render->hostname_sent_ = false;
-    if (render->audio_capture_) {
-      render->StopSpeakerCapturer();
-      render->audio_capture_ = false;
-      render->audio_capture_button_pressed_ = false;
+  }
+}
+
+void Render::OnSignalStatusCb(SignalStatus status, const char *user_id,
+                              size_t user_id_size, void *user_data) {
+  Render *render = (Render *)user_data;
+  if (!render) {
+    return;
+  }
+
+  std::string client_id(user_id, user_id_size);
+  if (client_id == render->client_id_) {
+    render->signal_status_ = status;
+    if (SignalStatus::SignalConnecting == status) {
+      render->signal_connected_ = false;
+    } else if (SignalStatus::SignalConnected == status) {
+      render->signal_connected_ = true;
+      LOG_INFO("[{}] connected to signal server", client_id);
+    } else if (SignalStatus::SignalFailed == status) {
+      render->signal_connected_ = false;
+    } else if (SignalStatus::SignalClosed == status) {
+      render->signal_connected_ = false;
+    } else if (SignalStatus::SignalReconnecting == status) {
+      render->signal_connected_ = false;
+    } else if (SignalStatus::SignalServerClosed == status) {
+      render->signal_connected_ = false;
     }
-    render->exit_video_window_ = false;
-    if (!render->rejoin_) {
-      memset(render->remote_password_, 0, sizeof(render->remote_password_));
+  } else {
+    if (client_id.rfind("C-", 0) != 0) {
+      return;
     }
-    if (render->dst_buffer_) {
-      memset(render->dst_buffer_, 0, render->dst_buffer_capacity_);
-      SDL_UpdateTexture(render->stream_texture_, NULL, render->dst_buffer_,
-                        render->texture_width_);
+
+    std::string remote_id(client_id.begin() + 2, client_id.end());
+    if (render->client_properties_.find(remote_id) ==
+        render->client_properties_.end()) {
+      return;
     }
-  } else if (ConnectionStatus::IncorrectPassword == status) {
-    render->connection_status_str_ = "Incorrect password";
-    render->password_validating_ = false;
-    render->password_validating_time_++;
-    if (render->connect_button_pressed_) {
-      render->connection_established_ = false;
-      render->connect_button_label_ =
-          render->connect_button_pressed_
-              ? localization::disconnect[render->localization_language_index_]
-              : localization::connect[render->localization_language_index_];
+    auto props = render->client_properties_.find(remote_id)->second;
+    props->signal_status_ = status;
+    if (SignalStatus::SignalConnecting == status) {
+      props->signal_connected_ = false;
+    } else if (SignalStatus::SignalConnected == status) {
+      props->signal_connected_ = true;
+      LOG_INFO("[{}] connected to signal server", remote_id);
+    } else if (SignalStatus::SignalFailed == status) {
+      props->signal_connected_ = false;
+    } else if (SignalStatus::SignalClosed == status) {
+      props->signal_connected_ = false;
+    } else if (SignalStatus::SignalReconnecting == status) {
+      props->signal_connected_ = false;
+    } else if (SignalStatus::SignalServerClosed == status) {
+      props->signal_connected_ = false;
     }
-  } else if (ConnectionStatus::NoSuchTransmissionId == status) {
-    render->connection_status_str_ = "No such transmission id";
-    if (render->connect_button_pressed_) {
-      render->connection_established_ = false;
-      render->connect_button_label_ =
-          render->connect_button_pressed_
-              ? localization::disconnect[render->localization_language_index_]
-              : localization::connect[render->localization_language_index_];
+  }
+}
+
+void Render::OnConnectionStatusCb(ConnectionStatus status, const char *user_id,
+                                  const size_t user_id_size, void *user_data) {
+  Render *render = (Render *)user_data;
+  if (!render) return;
+
+  std::string remote_id(user_id, user_id_size);
+  auto it = render->client_properties_.find(remote_id);
+  auto props = (it != render->client_properties_.end()) ? it->second : nullptr;
+
+  if (props) {
+    render->is_client_mode_ = true;
+    render->show_connection_status_window_ = true;
+    props->connection_status_ = status;
+
+    switch (status) {
+      case ConnectionStatus::Connected:
+        if (!render->need_to_create_stream_window_ &&
+            !render->client_properties_.empty()) {
+          render->need_to_create_stream_window_ = true;
+        }
+        props->connection_established_ = true;
+        props->stream_render_rect_ = {
+            0, (int)render->title_bar_height_,
+            (int)render->stream_window_width_,
+            (int)(render->stream_window_height_ - render->title_bar_height_)};
+        break;
+      case ConnectionStatus::Disconnected:
+      case ConnectionStatus::Failed:
+      case ConnectionStatus::Closed:
+        render->password_validating_time_ = 0;
+        render->start_screen_capturer_ = false;
+        render->start_mouse_controller_ = false;
+        render->start_keyboard_capturer_ = false;
+        render->control_mouse_ = false;
+        props->connection_established_ = false;
+        props->mouse_control_button_pressed_ = false;
+        if (props->dst_buffer_) {
+          memset(props->dst_buffer_, 0, props->dst_buffer_capacity_);
+          SDL_UpdateTexture(props->stream_texture_, NULL, props->dst_buffer_,
+                            props->texture_width_);
+        }
+        render->CleanSubStreamWindowProperties(props);
+        break;
+      case ConnectionStatus::IncorrectPassword:
+        render->password_validating_ = false;
+        render->password_validating_time_++;
+        if (render->connect_button_pressed_) {
+          render->connect_button_pressed_ = false;
+          props->connection_established_ = false;
+          render->connect_button_label_ =
+              localization::connect[render->localization_language_index_];
+        }
+        break;
+      case ConnectionStatus::NoSuchTransmissionId:
+        if (render->connect_button_pressed_) {
+          props->connection_established_ = false;
+          render->connect_button_label_ =
+              localization::connect[render->localization_language_index_];
+        }
+        break;
+      default:
+        break;
+    }
+  } else {
+    render->is_client_mode_ = false;
+    render->show_connection_status_window_ = true;
+
+    switch (status) {
+      case ConnectionStatus::Connected:
+        render->need_to_send_host_info_ = true;
+        render->start_screen_capturer_ = true;
+        render->start_mouse_controller_ = true;
+        break;
+      case ConnectionStatus::Closed:
+        render->start_screen_capturer_ = false;
+        render->start_mouse_controller_ = false;
+        render->start_keyboard_capturer_ = false;
+        render->need_to_send_host_info_ = false;
+        if (props) props->connection_established_ = false;
+        if (render->audio_capture_) {
+          render->StopSpeakerCapturer();
+          render->audio_capture_ = false;
+        }
+        break;
+      default:
+        break;
     }
   }
 }
@@ -345,21 +467,53 @@ void Render::OnConnectionStatusCb(ConnectionStatus status,
 void Render::NetStatusReport(const char *client_id, size_t client_id_size,
                              TraversalMode mode,
                              const XNetTrafficStats *net_traffic_stats,
+                             const char *user_id, const size_t user_id_size,
                              void *user_data) {
   Render *render = (Render *)user_data;
   if (!render) {
     return;
   }
 
-  if (0 == strcmp(render->client_id_, "")) {
+  if (strchr(client_id, '@') != nullptr && strchr(user_id, '-') == nullptr) {
+    std::string id, password;
+    const char *at_pos = strchr(client_id, '@');
+    if (at_pos == nullptr) {
+      id = client_id;
+      password.clear();
+    } else {
+      id.assign(client_id, at_pos - client_id);
+      password = at_pos + 1;
+    }
+
     memset(&render->client_id_, 0, sizeof(render->client_id_));
-    memcpy(render->client_id_, client_id, client_id_size);
-    LOG_INFO("Use client id [{}] and save id into cache file", client_id);
+    strncpy(render->client_id_, id.c_str(), sizeof(render->client_id_) - 1);
+    render->client_id_[sizeof(render->client_id_) - 1] = '\0';
+
+    memset(&render->password_saved_, 0, sizeof(render->password_saved_));
+    strncpy(render->password_saved_, password.c_str(),
+            sizeof(render->password_saved_) - 1);
+    render->password_saved_[sizeof(render->password_saved_) - 1] = '\0';
+
+    memset(&render->client_id_with_password_, 0,
+           sizeof(render->client_id_with_password_));
+    strncpy(render->client_id_with_password_, client_id,
+            sizeof(render->client_id_with_password_) - 1);
+    render->client_id_with_password_[sizeof(render->client_id_with_password_) -
+                                     1] = '\0';
+
+    LOG_INFO("Use client id [{}] and save id into cache file", id);
     render->SaveSettingsIntoCacheFile();
   }
-  if (render->traversal_mode_ != mode) {
-    render->traversal_mode_ = mode;
-    LOG_INFO("Net mode: [{}]", int(render->traversal_mode_));
+
+  std::string remote_id(user_id, user_id_size);
+  if (render->client_properties_.find(remote_id) ==
+      render->client_properties_.end()) {
+    return;
+  }
+  auto props = render->client_properties_.find(remote_id)->second;
+  if (props->traversal_mode_ != mode) {
+    props->traversal_mode_ = mode;
+    LOG_INFO("Net mode: [{}]", int(props->traversal_mode_));
   }
 
   if (!net_traffic_stats) {
@@ -368,6 +522,6 @@ void Render::NetStatusReport(const char *client_id, size_t client_id_size,
 
   // only display client side net status if connected to itself
   if (!(render->peer_reserved_ && !strstr(client_id, "C-"))) {
-    render->net_traffic_stats_ = *net_traffic_stats;
+    props->net_traffic_stats_ = *net_traffic_stats;
   }
 }

src/single_window/setting_window.cpp

@@ -70,7 +70,7 @@ int Render::SettingWindow() {
 
       ImGui::Separator();
 
-      if (streaming_) {
+      if (stream_window_inited_) {
         ImGui::BeginDisabled();
       }
 
@@ -161,7 +161,7 @@ int Render::SettingWindow() {
         ImGui::Checkbox("##enable_turn", &enable_turn_);
       }
 
-      if (streaming_) {
+      if (stream_window_inited_) {
         ImGui::EndDisabled();
       }
 
@@ -234,10 +234,9 @@ int Render::SettingWindow() {
         LoadSettingsFromCacheFile();
 
         // Recreate peer instance
-        if (!streaming_) {
+        if (!stream_window_inited_) {
           LOG_INFO("Recreate peer instance");
           DestroyPeer(&peer_);
-          is_create_connection_ = false;
           CreateConnectionPeer();
         }
       }

src/single_window/stb_image.h

@@ -711,7 +711,7 @@ typedef unsigned char validate_uint32[sizeof(stbi__uint32) == 4 ? 1 : -1];
 #ifdef STBI_HAS_LROTL
 #define stbi_lrot(x, y) _lrotl(x, y)
 #else
-#define stbi_lrot(x, y) (((x) << (y)) | ((x) >> (-(y)&31)))
+#define stbi_lrot(x, y) (((x) << (y)) | ((x) >> (-(y) & 31)))
 #endif
 
 #if defined(STBI_MALLOC) && defined(STBI_FREE) && \
@@ -1784,7 +1784,7 @@ static stbi__uint32 stbi__get32le(stbi__context *s) {
 #endif
 
 #define STBI__BYTECAST(x) \
-  ((stbi_uc)((x)&255))  // truncate int to byte without warnings
+  ((stbi_uc)((x) & 255))  // truncate int to byte without warnings
 
 #if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && \
     defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) &&  \
@@ -1831,7 +1831,7 @@ static unsigned char *stbi__convert_format(unsigned char *data, int img_n,
     unsigned char *src = data + j * x * img_n;
     unsigned char *dest = good + j * x * req_comp;
 
-#define STBI__COMBO(a, b) ((a)*8 + (b))
+#define STBI__COMBO(a, b) ((a) * 8 + (b))
 #define STBI__CASE(a, b)  \
   case STBI__COMBO(a, b): \
     for (i = x - 1; i >= 0; --i, src += a, dest += b)
@@ -1931,7 +1931,7 @@ static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n,
     stbi__uint16 *src = data + j * x * img_n;
     stbi__uint16 *dest = good + j * x * req_comp;
 
-#define STBI__COMBO(a, b) ((a)*8 + (b))
+#define STBI__COMBO(a, b) ((a) * 8 + (b))
 #define STBI__CASE(a, b)  \
   case STBI__COMBO(a, b): \
     for (i = x - 1; i >= 0; --i, src += a, dest += b)
@@ -2590,8 +2590,8 @@ stbi_inline static stbi_uc stbi__clamp(int x) {
   return (stbi_uc)x;
 }
 
-#define stbi__f2f(x) ((int)(((x)*4096 + 0.5)))
-#define stbi__fsh(x) ((x)*4096)
+#define stbi__f2f(x) ((int)(((x) * 4096 + 0.5)))
+#define stbi__fsh(x) ((x) * 4096)
 
 // derived from jidctint -- DCT_ISLOW
 #define STBI__IDCT_1D(s0, s1, s2, s3, s4, s5, s6, s7)     \
@@ -3694,7 +3694,7 @@ static int stbi__decode_jpeg_image(stbi__jpeg *j) {
   if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0;
   m = stbi__get_marker(j);
   while (!stbi__EOI(m)) {
-    if (stbi__SOS(m)) {
+    if (stbi__SOS(m) == true) {
       if (!stbi__process_scan_header(j)) return 0;
       if (!stbi__parse_entropy_coded_data(j)) return 0;
       if (j->marker == STBI__MARKER_none) {
@@ -3704,7 +3704,7 @@ static int stbi__decode_jpeg_image(stbi__jpeg *j) {
       }
       m = stbi__get_marker(j);
       if (STBI__RESTART(m)) m = stbi__get_marker(j);
-    } else if (stbi__DNL(m)) {
+    } else if (stbi__DNL(m) == true) {
       int Ld = stbi__get16be(j->s);
       stbi__uint32 NL = stbi__get16be(j->s);
       if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG");
@@ -3929,7 +3929,7 @@ static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near,
 
 // this is a reduced-precision calculation of YCbCr-to-RGB introduced
 // to make sure the code produces the same results in both SIMD and scalar
-#define stbi__float2fixed(x) (((int)((x)*4096.0f + 0.5f)) << 8)
+#define stbi__float2fixed(x) (((int)((x) * 4096.0f + 0.5f)) << 8)
 static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y,
                                    const stbi_uc *pcb, const stbi_uc *pcr,
                                    int count, int step) {
@@ -7579,8 +7579,7 @@ static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) {
     buffer[len++] = c;
     if (len == STBI__HDR_BUFLEN - 1) {
       // flush to end of line
-      while (!stbi__at_eof(z) && stbi__get8(z) != '\n')
-        ;
+      while (!stbi__at_eof(z) && stbi__get8(z) != '\n');
       break;
     }
     c = (char)stbi__get8(z);

src/single_window/stb_image_write.h

@@ -270,7 +270,7 @@ STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean);
 #define STBIW_ASSERT(x) assert(x)
 #endif
 
-#define STBIW_UCHAR(x) (unsigned char)((x)&0xff)
+#define STBIW_UCHAR(x) (unsigned char)((x) & 0xff)
 
 #ifdef STB_IMAGE_WRITE_STATIC
 static int stbi_write_png_compression_level = 8;
@@ -816,8 +816,8 @@ static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp,
         sprintf_s(buffer, sizeof(buffer),
                   "EXPOSURE=          1.0000000000000\n\n-Y %d +X %d\n", y, x);
 #else
-    len = sprintf(buffer, "EXPOSURE=          1.0000000000000\n\n-Y %d +X %d\n",
-                  y, x);
+    len = snprintf(buffer, sizeof(buffer),
+                   "EXPOSURE=          1.0000000000000\n\n-Y %d +X %d\n", y, x);
 #endif
     s->func(s->context, buffer, len);
 
@@ -857,7 +857,7 @@ STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp,
 #ifndef STBIW_ZLIB_COMPRESS
 // stretchy buffer; stbiw__sbpush() == vector<>::push_back() -- stbiw__sbcount()
 // == vector<>::size()
-#define stbiw__sbraw(a) ((int *)(void *)(a)-2)
+#define stbiw__sbraw(a) ((int *)(void *)(a) - 2)
 #define stbiw__sbm(a) stbiw__sbraw(a)[0]
 #define stbiw__sbn(a) stbiw__sbraw(a)[1]
 
@@ -931,9 +931,9 @@ static unsigned int stbiw__zhash(unsigned char *data) {
 #define stbiw__zlib_huffa(b, c) stbiw__zlib_add(stbiw__zlib_bitrev(b, c), c)
 // default huffman tables
 #define stbiw__zlib_huff1(n) stbiw__zlib_huffa(0x30 + (n), 8)
-#define stbiw__zlib_huff2(n) stbiw__zlib_huffa(0x190 + (n)-144, 9)
-#define stbiw__zlib_huff3(n) stbiw__zlib_huffa(0 + (n)-256, 7)
-#define stbiw__zlib_huff4(n) stbiw__zlib_huffa(0xc0 + (n)-280, 8)
+#define stbiw__zlib_huff2(n) stbiw__zlib_huffa(0x190 + (n) - 144, 9)
+#define stbiw__zlib_huff3(n) stbiw__zlib_huffa(0 + (n) - 256, 7)
+#define stbiw__zlib_huff4(n) stbiw__zlib_huffa(0xc0 + (n) - 280, 8)
 #define stbiw__zlib_huff(n)            \
   ((n) <= 143   ? stbiw__zlib_huff1(n) \
    : (n) <= 255 ? stbiw__zlib_huff2(n) \
@@ -951,7 +951,7 @@ STBIWDEF unsigned char *stbi_zlib_compress(unsigned char *data, int data_len,
 #ifdef STBIW_ZLIB_COMPRESS
   // user provided a zlib compress implementation, use that
   return STBIW_ZLIB_COMPRESS(data, data_len, out_len, quality);
-#else  // use builtin
+#else   // use builtin
   static unsigned short lengthc[] = {
       3,  4,  5,  6,  7,  8,  9,  10, 11,  13,  15,  17,  19,  23,  27,
       31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 259};
@@ -1024,12 +1024,10 @@ STBIWDEF unsigned char *stbi_zlib_compress(unsigned char *data, int data_len,
     if (bestloc) {
       int d = (int)(data + i - bestloc);  // distance back
       STBIW_ASSERT(d <= 32767 && best <= 258);
-      for (j = 0; best > lengthc[j + 1] - 1; ++j)
-        ;
+      for (j = 0; best > lengthc[j + 1] - 1; ++j);
       stbiw__zlib_huff(j + 257);
       if (lengtheb[j]) stbiw__zlib_add(best - lengthc[j], lengtheb[j]);
-      for (j = 0; d > distc[j + 1] - 1; ++j)
-        ;
+      for (j = 0; d > distc[j + 1] - 1; ++j);
       stbiw__zlib_add(stbiw__zlib_bitrev(j, 5), 5);
       if (disteb[j]) stbiw__zlib_add(d - distc[j], disteb[j]);
       i += best;

src/single_window/stream_window.cpp

@@ -2,25 +2,198 @@
 #include "rd_log.h"
 #include "render.h"
 
+void Render::DrawConnectionStatusText(
+    std::shared_ptr<SubStreamWindowProperties>& props) {
+  std::string text;
+  switch (props->connection_status_) {
+    case ConnectionStatus::Disconnected:
+      text = localization::p2p_disconnected[localization_language_index_];
+      break;
+    case ConnectionStatus::Failed:
+      text = localization::p2p_failed[localization_language_index_];
+      break;
+    case ConnectionStatus::Closed:
+      text = localization::p2p_closed[localization_language_index_];
+      break;
+    default:
+      break;
+  }
+
+  if (!text.empty()) {
+    ImVec2 size = ImGui::GetWindowSize();
+    ImVec2 text_size = ImGui::CalcTextSize(text.c_str());
+    ImGui::SetCursorPos(
+        ImVec2((size.x - text_size.x) * 0.5f,
+               (size.y - text_size.y - title_bar_height_) * 0.5f));
+    ImGui::TextColored(ImVec4(1.0f, 1.0f, 1.0f, 1.0f), "%s", text.c_str());
+  }
+}
+
+void Render::CloseTab(decltype(client_properties_)::iterator& it) {
+  CleanupPeer(it->second);
+  it = client_properties_.erase(it);
+  if (client_properties_.empty()) {
+    SDL_Event event;
+    event.type = SDL_QUIT;
+    SDL_PushEvent(&event);
+  }
+}
+
 int Render::StreamWindow() {
   ImGui::SetNextWindowPos(
       ImVec2(0, fullscreen_button_pressed_ ? 0 : title_bar_height_),
       ImGuiCond_Always);
-  ImGui::SetNextWindowSize(
-      ImVec2(stream_window_width_, stream_window_height_ - title_bar_height_),
-      ImGuiCond_Always);
-  ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1, 1, 1, 0));
-  ImGui::PushStyleColor(ImGuiCol_Border,
-                        ImVec4(178 / 255.0f, 178 / 255.0f, 178 / 255.0f,
-                               fullscreen_button_pressed_ ? 0 : 1.0f));
+  ImGui::SetNextWindowSize(ImVec2(stream_window_width_, stream_window_height_),
+                           ImGuiCond_Always);
+  ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
+  ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0, 0, 0, 0));
+  ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0, 0, 0, 0));
   ImGui::Begin("VideoBg", nullptr,
                ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoDecoration |
-                   ImGuiWindowFlags_NoBringToFrontOnFocus);
+                   ImGuiWindowFlags_NoBringToFrontOnFocus |
+                   ImGuiWindowFlags_NoDocking);
   ImGui::PopStyleColor(2);
+  ImGui::PopStyleVar();
 
-  ControlWindow();
+  ImGuiWindowFlags stream_window_flag =
+      ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoDecoration |
+      ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoMove;
 
-  ImGui::End();
+  if (!fullscreen_button_pressed_) {
+    ImGui::SetNextWindowPos(ImVec2(20, 0), ImGuiCond_Always);
+    ImGui::SetNextWindowSize(ImVec2(0, 20), ImGuiCond_Always);
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 8.0f));
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
+    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0, 0, 0, 0.0f));
+    ImGui::Begin("TabBar", nullptr,
+                 ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoDecoration |
+                     ImGuiWindowFlags_NoBringToFrontOnFocus |
+                     ImGuiWindowFlags_NoDocking);
+    ImGui::PopStyleColor();
+    ImGui::PopStyleVar(2);
+
+    if (ImGui::BeginTabBar("StreamTabBar",
+                           ImGuiTabBarFlags_Reorderable |
+                               ImGuiTabBarFlags_AutoSelectNewTabs)) {
+      is_tab_bar_hovered_ = ImGui::IsWindowHovered();
+
+      for (auto it = client_properties_.begin();
+           it != client_properties_.end();) {
+        auto& props = it->second;
+        if (!props->tab_opened_) {
+          CloseTab(it);
+          continue;
+        }
+
+        ImGui::SetWindowFontScale(0.6f);
+        if (ImGui::BeginTabItem(props->remote_id_.c_str(),
+                                &props->tab_opened_)) {
+          props->tab_selected_ = true;
+          ImGui::SetWindowFontScale(1.0f);
+
+          ImGui::SetNextWindowSize(
+              ImVec2(stream_window_width_, stream_window_height_),
+              ImGuiCond_Always);
+          ImGui::SetNextWindowPos(
+              ImVec2(0, fullscreen_button_pressed_ ? 0 : title_bar_height_),
+              ImGuiCond_Always);
+          ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
+          ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
+          ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0, 0, 0, 0.0f));
+          ImGui::Begin(props->remote_id_.c_str(), nullptr, stream_window_flag);
+          ImGui::PopStyleColor();
+          ImGui::PopStyleVar(2);
+
+          ImVec2 pos = ImGui::GetWindowPos();
+          ImVec2 size = ImGui::GetWindowSize();
+          props->render_window_x_ = pos.x;
+          props->render_window_y_ = pos.y;
+          props->render_window_width_ = size.x;
+          props->render_window_height_ = size.y;
+          UpdateRenderRect();
+
+          ControlWindow(props);
+
+          focused_remote_id_ = props->remote_id_;
+
+          if (!props->peer_) {
+            it = client_properties_.erase(it);
+            if (client_properties_.empty()) {
+              SDL_Event event;
+              event.type = SDL_QUIT;
+              SDL_PushEvent(&event);
+            }
+          } else {
+            DrawConnectionStatusText(props);
+            ++it;
+          }
+
+          ImGui::End();
+          ImGui::EndTabItem();
+        } else {
+          props->tab_selected_ = false;
+          ImGui::SetWindowFontScale(1.0f);
+          ++it;
+        }
+      }
+
+      ImGui::EndTabBar();
+    }
+
+    ImGui::End();  // End TabBar
+  } else {
+    for (auto it = client_properties_.begin();
+         it != client_properties_.end();) {
+      auto& props = it->second;
+      if (!props->tab_opened_) {
+        CloseTab(it);
+        continue;
+      }
+
+      if (props->tab_selected_) {
+        ImGui::SetNextWindowSize(
+            ImVec2(stream_window_width_, stream_window_height_),
+            ImGuiCond_Always);
+        ImGui::SetNextWindowPos(ImVec2(0, 0), ImGuiCond_Always);
+        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
+        ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
+        ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0, 0, 0, 0.0f));
+        ImGui::Begin(props->remote_id_.c_str(), nullptr, stream_window_flag);
+        ImGui::PopStyleColor();
+        ImGui::PopStyleVar(2);
+
+        ImVec2 pos = ImGui::GetWindowPos();
+        ImVec2 size = ImGui::GetWindowSize();
+        props->render_window_x_ = pos.x;
+        props->render_window_y_ = pos.y;
+        props->render_window_width_ = size.x;
+        props->render_window_height_ = size.y;
+        UpdateRenderRect();
+
+        ControlWindow(props);
+        ImGui::End();
+
+        if (!props->peer_) {
+          fullscreen_button_pressed_ = false;
+          SDL_SetWindowFullscreen(stream_window_, SDL_FALSE);
+          it = client_properties_.erase(it);
+          if (client_properties_.empty()) {
+            SDL_Event event;
+            event.type = SDL_QUIT;
+            SDL_PushEvent(&event);
+          }
+        } else {
+          DrawConnectionStatusText(props);
+          ++it;
+        }
+      } else {
+        ++it;
+      }
+    }
+  }
+
+  // UpdateRenderRect();
+  ImGui::End();  // End VideoBg
 
   return 0;
-}
+}

src/single_window/thumbnail.cpp

@@ -23,87 +23,6 @@
 
 static std::string test;
 
-void ScaleYUV420pToABGR(char* dst_buffer_, int video_width_, int video_height_,
-                        int scaled_video_width_, int scaled_video_height_,
-                        char* rgba_buffer_) {
-  int src_y_size = video_width_ * video_height_;
-  int src_uv_size = (video_width_ + 1) / 2 * (video_height_ + 1) / 2;
-  int dst_y_size = scaled_video_width_ * scaled_video_height_;
-  int dst_uv_size =
-      (scaled_video_width_ + 1) / 2 * (scaled_video_height_ + 1) / 2;
-
-  uint8_t* src_y = reinterpret_cast<uint8_t*>(dst_buffer_);
-  uint8_t* src_u = src_y + src_y_size;
-  uint8_t* src_v = src_u + src_uv_size;
-
-  std::unique_ptr<uint8_t[]> dst_y(new uint8_t[dst_y_size]);
-  std::unique_ptr<uint8_t[]> dst_u(new uint8_t[dst_uv_size]);
-  std::unique_ptr<uint8_t[]> dst_v(new uint8_t[dst_uv_size]);
-
-  libyuv::I420Scale(src_y, video_width_, src_u, (video_width_ + 1) / 2, src_v,
-                    (video_width_ + 1) / 2, video_width_, video_height_,
-                    dst_y.get(), scaled_video_width_, dst_u.get(),
-                    (scaled_video_width_ + 1) / 2, dst_v.get(),
-                    (scaled_video_width_ + 1) / 2, scaled_video_width_,
-                    scaled_video_height_, libyuv::kFilterBilinear);
-
-  libyuv::I420ToABGR(
-      dst_y.get(), scaled_video_width_, dst_u.get(),
-      (scaled_video_width_ + 1) / 2, dst_v.get(), (scaled_video_width_ + 1) / 2,
-      reinterpret_cast<uint8_t*>(rgba_buffer_), scaled_video_width_ * 4,
-      scaled_video_width_, scaled_video_height_);
-}
-
-Thumbnail::Thumbnail() {
-  RAND_bytes(aes128_key_, sizeof(aes128_key_));
-  RAND_bytes(aes128_iv_, sizeof(aes128_iv_));
-  std::filesystem::create_directory(image_path_);
-}
-
-Thumbnail::Thumbnail(unsigned char* aes128_key, unsigned char* aes128_iv) {
-  memcpy(aes128_key_, aes128_key, sizeof(aes128_key_));
-  memcpy(aes128_iv_, aes128_iv, sizeof(aes128_iv_));
-  std::filesystem::create_directory(image_path_);
-}
-
-Thumbnail::~Thumbnail() {
-  if (rgba_buffer_) {
-    delete[] rgba_buffer_;
-    rgba_buffer_ = nullptr;
-  }
-}
-
-int Thumbnail::SaveToThumbnail(const char* yuv420p, int width, int height,
-                               const std::string& remote_id,
-                               const std::string& host_name,
-                               const std::string& password) {
-  if (!rgba_buffer_) {
-    rgba_buffer_ = new char[thumbnail_width_ * thumbnail_height_ * 4];
-  }
-
-  if (yuv420p) {
-    ScaleYUV420pToABGR((char*)yuv420p, width, height, thumbnail_width_,
-                       thumbnail_height_, rgba_buffer_);
-
-    std::string image_name;
-    if (password.empty()) {
-      image_name = remote_id + 'N' + host_name;
-    } else {
-      // delete the file which has no password in its name
-      std::string filename_without_password = remote_id + "N" + host_name;
-      DeleteThumbnail(filename_without_password);
-
-      image_name = remote_id + 'Y' + password + host_name;
-    }
-
-    std::string ciphertext = AES_encrypt(image_name, aes128_key_, aes128_iv_);
-    std::string file_path = image_path_ + ciphertext;
-    stbi_write_png(file_path.data(), thumbnail_width_, thumbnail_height_, 4,
-                   rgba_buffer_, thumbnail_width_ * 4);
-  }
-  return 0;
-}
-
 bool LoadTextureFromMemory(const void* data, size_t data_size,
                            SDL_Renderer* renderer, SDL_Texture** out_texture,
                            int* out_width, int* out_height) {
@@ -163,6 +82,205 @@ bool LoadTextureFromFile(const char* file_name, SDL_Renderer* renderer,
   return ret;
 }
 
+void ScaleNv12ToABGR(char* src, int src_w, int src_h, int dst_w, int dst_h,
+                     char* dst_rgba) {
+  uint8_t* y = reinterpret_cast<uint8_t*>(src);
+  uint8_t* uv = y + src_w * src_h;
+
+  float src_aspect = float(src_w) / src_h;
+  float dst_aspect = float(dst_w) / dst_h;
+  int fit_w = dst_w, fit_h = dst_h;
+  if (src_aspect > dst_aspect) {
+    fit_h = int(dst_w / src_aspect);
+  } else {
+    fit_w = int(dst_h * src_aspect);
+  }
+
+  std::vector<uint8_t> y_i420(src_w * src_h);
+  std::vector<uint8_t> u_i420((src_w / 2) * (src_h / 2));
+  std::vector<uint8_t> v_i420((src_w / 2) * (src_h / 2));
+  libyuv::NV12ToI420(y, src_w, uv, src_w, y_i420.data(), src_w, u_i420.data(),
+                     src_w / 2, v_i420.data(), src_w / 2, src_w, src_h);
+
+  std::vector<uint8_t> y_fit(fit_w * fit_h);
+  std::vector<uint8_t> u_fit((fit_w + 1) / 2 * (fit_h + 1) / 2);
+  std::vector<uint8_t> v_fit((fit_w + 1) / 2 * (fit_h + 1) / 2);
+  libyuv::I420Scale(y_i420.data(), src_w, u_i420.data(), src_w / 2,
+                    v_i420.data(), src_w / 2, src_w, src_h, y_fit.data(), fit_w,
+                    u_fit.data(), (fit_w + 1) / 2, v_fit.data(),
+                    (fit_w + 1) / 2, fit_w, fit_h, libyuv::kFilterBilinear);
+
+  std::vector<uint8_t> abgr(fit_w * fit_h * 4);
+  libyuv::I420ToABGR(y_fit.data(), fit_w, u_fit.data(), (fit_w + 1) / 2,
+                     v_fit.data(), (fit_w + 1) / 2, abgr.data(), fit_w * 4,
+                     fit_w, fit_h);
+
+  memset(dst_rgba, 0, dst_w * dst_h * 4);
+  for (int i = 0; i < dst_w * dst_h; ++i) {
+    dst_rgba[i * 4 + 3] = 0xFF;
+  }
+
+  for (int y = 0; y < fit_h; ++y) {
+    int dst_offset =
+        ((y + (dst_h - fit_h) / 2) * dst_w + (dst_w - fit_w) / 2) * 4;
+    memcpy(dst_rgba + dst_offset, abgr.data() + y * fit_w * 4, fit_w * 4);
+  }
+}
+
+Thumbnail::Thumbnail(std::string save_path) {
+  if (!save_path.empty()) {
+    save_path_ = save_path;
+  }
+
+  RAND_bytes(aes128_key_, sizeof(aes128_key_));
+  RAND_bytes(aes128_iv_, sizeof(aes128_iv_));
+  std::filesystem::create_directories(save_path_);
+}
+
+Thumbnail::Thumbnail(std::string save_path, unsigned char* aes128_key,
+                     unsigned char* aes128_iv) {
+  if (!save_path.empty()) {
+    save_path_ = save_path;
+  }
+
+  memcpy(aes128_key_, aes128_key, sizeof(aes128_key_));
+  memcpy(aes128_iv_, aes128_iv, sizeof(aes128_iv_));
+  std::filesystem::create_directories(save_path_);
+}
+
+Thumbnail::~Thumbnail() {
+  if (rgba_buffer_) {
+    delete[] rgba_buffer_;
+    rgba_buffer_ = nullptr;
+  }
+}
+
+int Thumbnail::SaveToThumbnail(const char* yuv420p, int width, int height,
+                               const std::string& remote_id,
+                               const std::string& host_name,
+                               const std::string& password) {
+  if (!rgba_buffer_) {
+    rgba_buffer_ = new char[thumbnail_width_ * thumbnail_height_ * 4];
+  }
+
+  if (yuv420p) {
+    ScaleNv12ToABGR((char*)yuv420p, width, height, thumbnail_width_,
+                    thumbnail_height_, rgba_buffer_);
+  } else {
+    // If yuv420p is null, fill the buffer with black pixels
+    memset(rgba_buffer_, 0x00, thumbnail_width_ * thumbnail_height_ * 4);
+    for (int i = 0; i < thumbnail_width_ * thumbnail_height_; ++i) {
+      // Set alpha channel to opaque
+      rgba_buffer_[i * 4 + 3] = 0xFF;
+    }
+  }
+
+  std::string image_file_name;
+  if (password.empty()) {
+    return 0;
+  } else {
+    // delete the old thumbnail
+    std::string filename_with_remote_id = remote_id;
+    DeleteThumbnail(filename_with_remote_id);
+  }
+
+  std::string cipher_password = AES_encrypt(password, aes128_key_, aes128_iv_);
+  image_file_name = remote_id + 'Y' + host_name + '@' + cipher_password;
+  std::string file_path = save_path_ + image_file_name;
+  stbi_write_png(file_path.data(), thumbnail_width_, thumbnail_height_, 4,
+                 rgba_buffer_, thumbnail_width_ * 4);
+
+  return 0;
+}
+
+int Thumbnail::LoadThumbnail(
+    SDL_Renderer* renderer,
+    std::vector<std::pair<std::string, Thumbnail::RecentConnection>>&
+        recent_connections,
+    int* width, int* height) {
+  for (auto& it : recent_connections) {
+    if (it.second.texture != nullptr) {
+      SDL_DestroyTexture(it.second.texture);
+      it.second.texture = nullptr;
+    }
+  }
+  recent_connections.clear();
+
+  std::vector<std::filesystem::path> image_paths =
+      FindThumbnailPath(save_path_);
+
+  if (image_paths.size() == 0) {
+    return -1;
+  } else {
+    for (int i = 0; i < image_paths.size(); i++) {
+      size_t pos1 = image_paths[i].string().find('/') + 1;
+      std::string cipher_image_name = image_paths[i].filename().string();
+      std::string remote_id;
+      std::string cipher_password;
+      std::string remote_host_name;
+      std::string original_image_name;
+
+      if ('Y' == cipher_image_name[9] && cipher_image_name.size() >= 16) {
+        size_t pos_y = cipher_image_name.find('Y');
+        size_t pos_at = cipher_image_name.find('@');
+
+        if (pos_y == std::string::npos || pos_at == std::string::npos ||
+            pos_y >= pos_at) {
+          LOG_ERROR("Invalid filename");
+          continue;
+        }
+
+        remote_id = cipher_image_name.substr(0, pos_y);
+        remote_host_name =
+            cipher_image_name.substr(pos_y + 1, pos_at - pos_y - 1);
+        cipher_password = cipher_image_name.substr(pos_at + 1);
+
+        original_image_name =
+            remote_id + 'Y' + remote_host_name + "@" +
+            AES_decrypt(cipher_password, aes128_key_, aes128_iv_);
+      } else {
+        size_t pos_n = cipher_image_name.find('N');
+        size_t pos_at = cipher_image_name.find('@');
+
+        if (pos_n == std::string::npos) {
+          LOG_ERROR("Invalid filename");
+          continue;
+        }
+
+        remote_id = cipher_image_name.substr(0, pos_n);
+        remote_host_name = cipher_image_name.substr(pos_n + 1);
+
+        original_image_name =
+            remote_id + 'N' + remote_host_name + "@" +
+            AES_decrypt(cipher_password, aes128_key_, aes128_iv_);
+      }
+
+      std::string image_path = save_path_ + cipher_image_name;
+      recent_connections.emplace_back(
+          std::make_pair(original_image_name, Thumbnail::RecentConnection()));
+      LoadTextureFromFile(image_path.c_str(), renderer,
+                          &(recent_connections[i].second.texture), width,
+                          height);
+    }
+    return 0;
+  }
+  return 0;
+}
+
+int Thumbnail::DeleteThumbnail(const std::string& filename_keyword) {
+  for (const auto& entry : std::filesystem::directory_iterator(save_path_)) {
+    if (entry.is_regular_file()) {
+      const std::string filename = entry.path().filename().string();
+      std::string id_hostname = filename_keyword.substr(0, filename.find('@'));
+      if (filename.find(id_hostname) != std::string::npos) {
+        std::filesystem::remove(entry.path());
+      }
+    }
+  }
+
+  return 0;
+}
+
 std::vector<std::filesystem::path> Thumbnail::FindThumbnailPath(
     const std::filesystem::path& directory) {
   std::vector<std::filesystem::path> thumbnails_path;
@@ -172,75 +290,25 @@ std::vector<std::filesystem::path> Thumbnail::FindThumbnailPath(
     return thumbnails_path;
   }
 
-  thumbnails_sorted_by_write_time_.clear();
-
   for (const auto& entry : std::filesystem::directory_iterator(directory)) {
     if (entry.is_regular_file()) {
-      std::time_t last_write_time = std::chrono::system_clock::to_time_t(
-          time_point_cast<std::chrono::system_clock::duration>(
-              entry.last_write_time() -
-              std::filesystem::file_time_type::clock::now() +
-              std::chrono::system_clock::now()));
-
-      thumbnails_sorted_by_write_time_[last_write_time] = entry.path();
+      thumbnails_path.push_back(entry.path());
     }
   }
 
-  for (auto it = thumbnails_sorted_by_write_time_.rbegin();
-       it != thumbnails_sorted_by_write_time_.rend(); ++it) {
-    thumbnails_path.push_back(it->second);
-  }
+  std::sort(thumbnails_path.begin(), thumbnails_path.end(),
+            [](const std::filesystem::path& a, const std::filesystem::path& b) {
+              return std::filesystem::last_write_time(a) >
+                     std::filesystem::last_write_time(b);
+            });
 
   return thumbnails_path;
 }
 
-int Thumbnail::LoadThumbnail(SDL_Renderer* renderer,
-                             std::map<std::string, SDL_Texture*>& textures,
-                             int* width, int* height) {
-  for (auto& it : textures) {
-    if (it.second != nullptr) {
-      SDL_DestroyTexture(it.second);
-      it.second = nullptr;
-    }
-  }
-  textures.clear();
-
-  std::vector<std::filesystem::path> image_paths =
-      FindThumbnailPath(image_path_);
-
-  if (image_paths.size() == 0) {
-    return -1;
-  } else {
-    for (int i = 0; i < image_paths.size(); i++) {
-      size_t pos1 = image_paths[i].string().find('/') + 1;
-      std::string cipher_image_name = image_paths[i].string().substr(pos1);
-      std::string original_image_name =
-          AES_decrypt(cipher_image_name, aes128_key_, aes128_iv_);
-      std::string image_path = image_path_ + cipher_image_name;
-      textures[original_image_name] = nullptr;
-      LoadTextureFromFile(image_path.c_str(), renderer,
-                          &(textures[original_image_name]), width, height);
-    }
-    return 0;
-  }
-  return 0;
-}
-
-int Thumbnail::DeleteThumbnail(const std::string& file_name) {
-  std::string ciphertext = AES_encrypt(file_name, aes128_key_, aes128_iv_);
-  std::string file_path = image_path_ + ciphertext;
-  if (std::filesystem::exists(file_path)) {
-    std::filesystem::remove(file_path);
-    return 0;
-  } else {
-    return -1;
-  }
-}
-
 int Thumbnail::DeleteAllFilesInDirectory() {
-  if (std::filesystem::exists(image_path_) &&
-      std::filesystem::is_directory(image_path_)) {
-    for (const auto& entry : std::filesystem::directory_iterator(image_path_)) {
+  if (std::filesystem::exists(save_path_) &&
+      std::filesystem::is_directory(save_path_)) {
+    for (const auto& entry : std::filesystem::directory_iterator(save_path_)) {
       if (std::filesystem::is_regular_file(entry.status())) {
         std::filesystem::remove(entry.path());
       }

src/single_window/thumbnail.h

@@ -11,11 +11,23 @@
 
 #include <filesystem>
 #include <map>
+#include <unordered_map>
+#include <vector>
 
 class Thumbnail {
  public:
-  Thumbnail();
-  explicit Thumbnail(unsigned char* aes128_key, unsigned char* aes128_iv);
+  struct RecentConnection {
+    SDL_Texture* texture = nullptr;
+    std::string remote_id;
+    std::string remote_host_name;
+    std::string password;
+    bool remember_password = false;
+  };
+
+ public:
+  Thumbnail(std::string save_path);
+  explicit Thumbnail(std::string save_path, unsigned char* aes128_key,
+                     unsigned char* aes128_iv);
   ~Thumbnail();
 
  public:
@@ -24,11 +36,13 @@ class Thumbnail {
                       const std::string& host_name,
                       const std::string& password);
 
-  int LoadThumbnail(SDL_Renderer* renderer,
-                    std::map<std::string, SDL_Texture*>& textures, int* width,
-                    int* height);
+  int LoadThumbnail(
+      SDL_Renderer* renderer,
+      std::vector<std::pair<std::string, Thumbnail::RecentConnection>>&
+          recent_connections,
+      int* width, int* height);
 
-  int DeleteThumbnail(const std::string& file_name);
+  int DeleteThumbnail(const std::string& filename_keyword);
 
   int DeleteAllFilesInDirectory();
 
@@ -62,8 +76,7 @@ class Thumbnail {
   int thumbnail_width_ = 160;
   int thumbnail_height_ = 90;
   char* rgba_buffer_ = nullptr;
-  std::string image_path_ = "thumbnails/";
-  std::map<std::time_t, std::filesystem::path> thumbnails_sorted_by_write_time_;
+  std::string save_path_ = "thumbnails/";
 
   unsigned char aes128_key_[16];
   unsigned char aes128_iv_[16];

src/single_window/title_bar.cpp

@@ -1,4 +1,5 @@
 #include "localization.h"
+#include "rd_log.h"
 #include "render.h"
 
 #define BUTTON_PADDING 36.0f

src/speaker_capturer/linux/speaker_capturer_linux.cpp

@@ -1,13 +1,268 @@
 #include "speaker_capturer_linux.h"
 
-SpeakerCapturerLinux::SpeakerCapturerLinux() {}
+#include <pulse/error.h>
+#include <pulse/introspect.h>
 
-SpeakerCapturerLinux::~SpeakerCapturerLinux() {}
+#include <condition_variable>
+#include <iostream>
+#include <thread>
 
-int SpeakerCapturerLinux::Init(speaker_data_cb cb) { return 0; }
-int SpeakerCapturerLinux::Destroy() { return 0; }
-int SpeakerCapturerLinux::Start() { return 0; }
-int SpeakerCapturerLinux::Stop() { return 0; }
+#include "rd_log.h"
 
-int SpeakerCapturerLinux::Pause() { return 0; }
-int SpeakerCapturerLinux::Resume() { return 0; }
+constexpr int kSampleRate = 48000;
+constexpr pa_sample_format_t kFormat = PA_SAMPLE_S16LE;
+constexpr int kChannels = 1;
+constexpr size_t kFrameSizeBytes = 480 * sizeof(int16_t);
+
+SpeakerCapturerLinux::SpeakerCapturerLinux()
+    : inited_(false), paused_(false), stop_flag_(false) {}
+SpeakerCapturerLinux::~SpeakerCapturerLinux() {
+  Stop();
+  Destroy();
+}
+
+int SpeakerCapturerLinux::Init(speaker_data_cb cb) {
+  if (inited_) return 0;
+  cb_ = cb;
+  inited_ = true;
+  return 0;
+}
+
+int SpeakerCapturerLinux::Destroy() {
+  inited_ = false;
+  return 0;
+}
+
+std::string SpeakerCapturerLinux::GetDefaultMonitorSourceName() {
+  std::string monitor_name;
+  std::mutex mtx;
+  std::condition_variable cv;
+  bool ready = false;
+
+  pa_mainloop* mainloop = pa_mainloop_new();
+  pa_mainloop_api* api = pa_mainloop_get_api(mainloop);
+  pa_context* context = pa_context_new(api, "GetMonitor");
+
+  struct CallbackState {
+    std::string* name;
+    std::mutex* mtx;
+    std::condition_variable* cv;
+    bool* ready;
+  } state{&monitor_name, &mtx, &cv, &ready};
+
+  pa_context_set_state_callback(
+      context,
+      [](pa_context* c, void* userdata) {
+        auto* state = static_cast<CallbackState*>(userdata);
+        if (pa_context_get_state(c) == PA_CONTEXT_READY) {
+          pa_operation* operation = pa_context_get_server_info(
+              c,
+              [](pa_context*, const pa_server_info* info, void* userdata) {
+                auto* state = static_cast<CallbackState*>(userdata);
+                if (info && info->default_sink_name) {
+                  *(state->name) =
+                      std::string(info->default_sink_name) + ".monitor";
+                }
+                {
+                  std::lock_guard<std::mutex> lock(*(state->mtx));
+                  *(state->ready) = true;
+                }
+                state->cv->notify_one();
+              },
+              userdata);
+          if (operation) {
+            pa_operation_unref(operation);
+          }
+        }
+      },
+      &state);
+
+  pa_context_connect(context, nullptr, PA_CONTEXT_NOFLAGS, nullptr);
+
+  std::thread loop_thread([&]() {
+    int ret = 0;
+    pa_mainloop_run(mainloop, &ret);
+  });
+
+  {
+    std::unique_lock<std::mutex> lock(mtx);
+    cv.wait_for(lock, std::chrono::seconds(2), [&] { return ready; });
+  }
+
+  pa_context_disconnect(context);
+  pa_context_unref(context);
+  pa_mainloop_quit(mainloop, 0);
+  loop_thread.join();
+  pa_mainloop_free(mainloop);
+
+  return monitor_name;
+}
+
+int SpeakerCapturerLinux::Start() {
+  if (!inited_ || mainloop_thread_.joinable()) return -1;
+  stop_flag_ = false;
+
+  mainloop_thread_ = std::thread([this]() {
+    std::string monitor_name = GetDefaultMonitorSourceName();
+    if (monitor_name.empty()) {
+      LOG_ERROR("Failed to get monitor source");
+      return;
+    }
+
+    mainloop_ = pa_threaded_mainloop_new();
+    pa_mainloop_api* api = pa_threaded_mainloop_get_api(mainloop_);
+    context_ = pa_context_new(api, "SpeakerCapturer");
+
+    pa_context_set_state_callback(
+        context_,
+        [](pa_context* c, void* userdata) {
+          auto self = static_cast<SpeakerCapturerLinux*>(userdata);
+          pa_context_state_t state = pa_context_get_state(c);
+          if (state == PA_CONTEXT_READY || state == PA_CONTEXT_FAILED ||
+              state == PA_CONTEXT_TERMINATED) {
+            pa_threaded_mainloop_signal(self->mainloop_, 0);
+          }
+        },
+        this);
+
+    if (pa_threaded_mainloop_start(mainloop_) < 0) {
+      LOG_ERROR("Failed to start mainloop");
+      Cleanup();
+      return;
+    }
+
+    pa_threaded_mainloop_lock(mainloop_);
+
+    if (pa_context_connect(context_, nullptr, PA_CONTEXT_NOFLAGS, nullptr) <
+        0) {
+      LOG_ERROR("Failed to connect context");
+      pa_threaded_mainloop_unlock(mainloop_);
+      Cleanup();
+      return;
+    }
+
+    while (true) {
+      pa_context_state_t state = pa_context_get_state(context_);
+      if (state == PA_CONTEXT_READY) break;
+      if (!PA_CONTEXT_IS_GOOD(state) || stop_flag_) {
+        pa_threaded_mainloop_unlock(mainloop_);
+        Cleanup();
+        return;
+      }
+      pa_threaded_mainloop_wait(mainloop_);
+    }
+
+    pa_sample_spec ss = {kFormat, kSampleRate, kChannels};
+    stream_ = pa_stream_new(context_, "Capture", &ss, nullptr);
+
+    pa_stream_set_read_callback(
+        stream_,
+        [](pa_stream* s, size_t len, void* u) {
+          auto self = static_cast<SpeakerCapturerLinux*>(u);
+          if (self->paused_ || self->stop_flag_) return;
+
+          const void* data = nullptr;
+          if (pa_stream_peek(s, &data, &len) < 0 || !data) return;
+
+          const uint8_t* p = static_cast<const uint8_t*>(data);
+          self->frame_cache_.insert(self->frame_cache_.end(), p, p + len);
+
+          while (self->frame_cache_.size() >= kFrameSizeBytes) {
+            std::vector<uint8_t> temp_frame(
+                self->frame_cache_.begin(),
+                self->frame_cache_.begin() + kFrameSizeBytes);
+            self->cb_(temp_frame.data(), kFrameSizeBytes, "audio");
+            self->frame_cache_.erase(
+                self->frame_cache_.begin(),
+                self->frame_cache_.begin() + kFrameSizeBytes);
+          }
+
+          pa_stream_drop(s);
+        },
+        this);
+
+    pa_buffer_attr attr = {.maxlength = (uint32_t)-1,
+                           .tlength = 0,
+                           .prebuf = 0,
+                           .minreq = 0,
+                           .fragsize = (uint32_t)kFrameSizeBytes};
+
+    if (pa_stream_connect_record(stream_, monitor_name.c_str(), &attr,
+                                 PA_STREAM_ADJUST_LATENCY) < 0) {
+      LOG_ERROR("Failed to connect stream");
+      pa_threaded_mainloop_unlock(mainloop_);
+      Cleanup();
+      return;
+    }
+
+    while (true) {
+      pa_stream_state_t s = pa_stream_get_state(stream_);
+      if (s == PA_STREAM_READY) break;
+      if (!PA_STREAM_IS_GOOD(s) || stop_flag_) {
+        pa_threaded_mainloop_unlock(mainloop_);
+        Cleanup();
+        return;
+      }
+      pa_threaded_mainloop_wait(mainloop_);
+    }
+
+    pa_threaded_mainloop_unlock(mainloop_);
+
+    while (!stop_flag_)
+      std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  });
+
+  return 0;
+}
+
+int SpeakerCapturerLinux::Stop() {
+  stop_flag_ = true;
+
+  if (mainloop_) {
+    pa_threaded_mainloop_lock(mainloop_);
+    pa_threaded_mainloop_signal(mainloop_, 0);
+    pa_threaded_mainloop_unlock(mainloop_);
+  }
+
+  if (mainloop_thread_.joinable()) {
+    mainloop_thread_.join();
+  }
+
+  Cleanup();
+  return 0;
+}
+
+void SpeakerCapturerLinux::Cleanup() {
+  if (mainloop_) {
+    pa_threaded_mainloop_stop(mainloop_);
+    pa_threaded_mainloop_lock(mainloop_);
+
+    if (stream_) {
+      pa_stream_disconnect(stream_);
+      pa_stream_unref(stream_);
+      stream_ = nullptr;
+    }
+
+    if (context_) {
+      pa_context_disconnect(context_);
+      pa_context_unref(context_);
+      context_ = nullptr;
+    }
+
+    pa_threaded_mainloop_unlock(mainloop_);
+    pa_threaded_mainloop_free(mainloop_);
+    mainloop_ = nullptr;
+  }
+
+  frame_cache_.clear();
+}
+
+int SpeakerCapturerLinux::Pause() {
+  paused_ = true;
+  return 0;
+}
+
+int SpeakerCapturerLinux::Resume() {
+  paused_ = false;
+  return 0;
+}

src/speaker_capturer/linux/speaker_capturer_linux.h

@@ -1,12 +1,18 @@
 /*
  * @Author: DI JUNKUN
- * @Date: 2024-08-02
- * Copyright (c) 2024 by DI JUNKUN, All Rights Reserved.
+ * @Date: 2025-07-15
+ * Copyright (c) 2025 by DI JUNKUN, All Rights Reserved.
  */
 
 #ifndef _SPEAKER_CAPTURER_LINUX_H_
 #define _SPEAKER_CAPTURER_LINUX_H_
 
+#include <pulse/pulseaudio.h>
+
+#include <atomic>
+#include <functional>
+#include <mutex>
+#include <string>
 #include <thread>
 #include <vector>
 
@@ -17,22 +23,32 @@ class SpeakerCapturerLinux : public SpeakerCapturer {
   SpeakerCapturerLinux();
   ~SpeakerCapturerLinux();
 
- public:
-  virtual int Init(speaker_data_cb cb);
-  virtual int Destroy();
-  virtual int Start();
-  virtual int Stop();
+  int Init(speaker_data_cb cb) override;
+  int Destroy() override;
+  int Start() override;
+  int Stop() override;
 
   int Pause();
   int Resume();
 
  private:
-  speaker_data_cb cb_ = nullptr;
+  std::string GetDefaultMonitorSourceName();
+  void Cleanup();
 
  private:
-  bool inited_ = false;
-  // thread
-  std::thread capture_thread_;
+  speaker_data_cb cb_ = nullptr;
+
+  std::atomic<bool> inited_;
+  std::atomic<bool> paused_;
+  std::atomic<bool> stop_flag_;
+
+  std::thread mainloop_thread_;
+  pa_threaded_mainloop* mainloop_ = nullptr;
+  pa_context* context_ = nullptr;
+  pa_stream* stream_ = nullptr;
+
+  std::mutex state_mtx_;
+  std::vector<uint8_t> frame_cache_;
 };
 
 #endif

src/speaker_capturer/macosx/speaker_capturer_macosx.cpp

@@ -1,14 +0,0 @@
-
-#include "speaker_capturer_macosx.h"
-
-SpeakerCapturerMacosx::SpeakerCapturerMacosx() {}
-
-SpeakerCapturerMacosx::~SpeakerCapturerMacosx() {}
-
-int SpeakerCapturerMacosx::Init(speaker_data_cb cb) { return 0; }
-int SpeakerCapturerMacosx::Destroy() { return 0; }
-int SpeakerCapturerMacosx::Start() { return 0; }
-int SpeakerCapturerMacosx::Stop() { return 0; }
-
-int SpeakerCapturerMacosx::Pause() { return 0; }
-int SpeakerCapturerMacosx::Resume() { return 0; }

src/speaker_capturer/macosx/speaker_capturer_macosx.h

@@ -26,13 +26,12 @@ class SpeakerCapturerMacosx : public SpeakerCapturer {
   int Pause();
   int Resume();
 
- private:
+ public:
   speaker_data_cb cb_ = nullptr;
-
- private:
   bool inited_ = false;
-  // thread
-  std::thread capture_thread_;
+
+  class Impl;
+  Impl* impl_ = nullptr;
 };
 
 #endif

src/speaker_capturer/macosx/speaker_capturer_macosx.mm

@@ -0,0 +1,264 @@
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+#import <ScreenCaptureKit/ScreenCaptureKit.h>
+
+#include "rd_log.h"
+#include "speaker_capturer_macosx.h"
+
+@interface SpeakerCaptureDelegate : NSObject <SCStreamDelegate, SCStreamOutput>
+@property(nonatomic, assign) SpeakerCapturerMacosx* owner;
+- (instancetype)initWithOwner:(SpeakerCapturerMacosx*)owner;
+@end
+
+@implementation SpeakerCaptureDelegate
+- (instancetype)initWithOwner:(SpeakerCapturerMacosx*)owner {
+  self = [super init];
+  if (self) {
+    _owner = owner;
+  }
+  return self;
+}
+
+- (void)stream:(SCStream*)stream
+    didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
+                   ofType:(SCStreamOutputType)type {
+  if (type == SCStreamOutputTypeAudio) {
+    CMBlockBufferRef blockBuffer = CMSampleBufferGetDataBuffer(sampleBuffer);
+    size_t length = CMBlockBufferGetDataLength(blockBuffer);
+    char* dataPtr = NULL;
+    CMBlockBufferGetDataPointer(blockBuffer, 0, NULL, NULL, &dataPtr);
+    CMAudioFormatDescriptionRef formatDesc = CMSampleBufferGetFormatDescription(sampleBuffer);
+    const AudioStreamBasicDescription* asbd =
+        CMAudioFormatDescriptionGetStreamBasicDescription(formatDesc);
+
+    if (_owner->cb_ && dataPtr && length > 0 && asbd) {
+      std::vector<short> out_pcm16;
+      if (asbd->mFormatFlags & kAudioFormatFlagIsFloat) {
+        int channels = asbd->mChannelsPerFrame;
+        int samples = (int)(length / sizeof(float));
+        float* floatData = (float*)dataPtr;
+        std::vector<short> pcm16(samples);
+        for (int i = 0; i < samples; ++i) {
+          float v = floatData[i];
+          if (v > 1.0f) v = 1.0f;
+          if (v < -1.0f) v = -1.0f;
+          pcm16[i] = (short)(v * 32767.0f);
+        }
+
+        if (channels > 1) {
+          int mono_samples = samples / channels;
+          out_pcm16.resize(mono_samples);
+          for (int i = 0; i < mono_samples; ++i) {
+            int sum = 0;
+            for (int c = 0; c < channels; ++c) {
+              sum += pcm16[i * channels + c];
+            }
+            out_pcm16[i] = sum / channels;
+          }
+        } else {
+          out_pcm16 = std::move(pcm16);
+        }
+      } else if (asbd->mBitsPerChannel == 16) {
+        int channels = asbd->mChannelsPerFrame;
+        int samples = (int)(length / 2);
+        short* src = (short*)dataPtr;
+        if (channels > 1) {
+          int mono_samples = samples / channels;
+          out_pcm16.resize(mono_samples);
+          for (int i = 0; i < mono_samples; ++i) {
+            int sum = 0;
+            for (int c = 0; c < channels; ++c) {
+              sum += src[i * channels + c];
+            }
+            out_pcm16[i] = sum / channels;
+          }
+        } else {
+          out_pcm16.assign(src, src + samples);
+        }
+      }
+
+      size_t frame_bytes = 960;  // 480 * 2
+      size_t total_bytes = out_pcm16.size() * sizeof(short);
+      unsigned char* p = (unsigned char*)out_pcm16.data();
+      for (size_t offset = 0; offset + frame_bytes <= total_bytes; offset += frame_bytes) {
+        _owner->cb_(p + offset, frame_bytes, "audio");
+      }
+    }
+  }
+}
+@end
+
+class SpeakerCapturerMacosx::Impl {
+ public:
+  SCStreamConfiguration* config = nil;
+  SCStream* stream = nil;
+  SpeakerCaptureDelegate* delegate = nil;
+  dispatch_queue_t queue = nil;
+  SCShareableContent* content = nil;
+  SCDisplay* mainDisplay = nil;
+
+  ~Impl() {
+    if (stream) {
+      [stream stopCaptureWithCompletionHandler:^(NSError* _Nullable error){
+      }];
+      stream = nil;
+    }
+    delegate = nil;
+    if (queue) {
+      queue = nil;
+    }
+    content = nil;
+    mainDisplay = nil;
+    config = nil;
+  }
+};
+
+SpeakerCapturerMacosx::SpeakerCapturerMacosx() {
+  impl_ = new Impl();
+  inited_ = false;
+  cb_ = nullptr;
+}
+
+SpeakerCapturerMacosx::~SpeakerCapturerMacosx() {
+  Destroy();
+  delete impl_;
+  impl_ = nullptr;
+}
+
+int SpeakerCapturerMacosx::Init(speaker_data_cb cb) {
+  if (inited_) {
+    return 0;
+  }
+  cb_ = cb;
+
+  impl_->config = [[SCStreamConfiguration alloc] init];
+  impl_->config.capturesAudio = YES;
+  impl_->config.sampleRate = 48000;
+  impl_->config.channelCount = 1;
+
+  dispatch_semaphore_t sema = dispatch_semaphore_create(0);
+  __block NSError* error = nil;
+  [SCShareableContent
+      getShareableContentWithCompletionHandler:^(SCShareableContent* c, NSError* e) {
+        impl_->content = c;
+        error = e;
+        dispatch_semaphore_signal(sema);
+      }];
+  dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
+
+  if (error || !impl_->content) {
+    LOG_ERROR("Failed to get shareable content: {}",
+              std::string([error.localizedDescription UTF8String]));
+    return -1;
+  }
+
+  CGDirectDisplayID mainDisplayId = CGMainDisplayID();
+  impl_->mainDisplay = nil;
+  for (SCDisplay* d in impl_->content.displays) {
+    if (d.displayID == mainDisplayId) {
+      impl_->mainDisplay = d;
+      break;
+    }
+  }
+  if (!impl_->mainDisplay) {
+    LOG_ERROR("Main display not found");
+    return -1;
+  }
+
+  if (!impl_->queue) {
+    impl_->queue = dispatch_queue_create("SpeakerAudio.Queue", DISPATCH_QUEUE_SERIAL);
+  }
+
+  inited_ = true;
+  return 0;
+}
+
+int SpeakerCapturerMacosx::Start() {
+  if (!inited_) {
+    return -1;
+  }
+
+  if (impl_->stream) {
+    dispatch_semaphore_t semaStop = dispatch_semaphore_create(0);
+    [impl_->stream stopCaptureWithCompletionHandler:^(NSError* error) {
+      dispatch_semaphore_signal(semaStop);
+    }];
+    dispatch_semaphore_wait(semaStop, DISPATCH_TIME_FOREVER);
+    impl_->stream = nil;
+    impl_->delegate = nil;
+  }
+
+  impl_->delegate = [[SpeakerCaptureDelegate alloc] initWithOwner:this];
+  SCContentFilter* filter = [[SCContentFilter alloc] initWithDisplay:impl_->mainDisplay
+                                                    excludingWindows:@[]];
+  impl_->stream = [[SCStream alloc] initWithFilter:filter
+                                     configuration:impl_->config
+                                          delegate:impl_->delegate];
+
+  NSError* addOutputError = nil;
+  BOOL ok = [impl_->stream addStreamOutput:impl_->delegate
+                                      type:SCStreamOutputTypeAudio
+                        sampleHandlerQueue:impl_->queue
+                                     error:&addOutputError];
+  if (!ok || addOutputError) {
+    LOG_ERROR("addStreamOutput error: {}",
+              std::string([addOutputError.localizedDescription UTF8String]));
+    impl_->stream = nil;
+    impl_->delegate = nil;
+    return -1;
+  }
+
+  dispatch_semaphore_t semaStart = dispatch_semaphore_create(0);
+  __block int ret = 0;
+  [impl_->stream startCaptureWithCompletionHandler:^(NSError* _Nullable error) {
+    if (error) {
+      LOG_ERROR("startCaptureWithCompletionHandler error: {}",
+                std::string([error.localizedDescription UTF8String]));
+      ret = -1;
+    }
+    dispatch_semaphore_signal(semaStart);
+  }];
+  dispatch_semaphore_wait(semaStart, DISPATCH_TIME_FOREVER);
+
+  return ret;
+}
+
+int SpeakerCapturerMacosx::Stop() {
+  if (!inited_) return -1;
+  if (!impl_->stream) return -1;
+
+  dispatch_semaphore_t sema = dispatch_semaphore_create(0);
+  [impl_->stream stopCaptureWithCompletionHandler:^(NSError* error) {
+    if (error) {
+      LOG_ERROR("stopCaptureWithCompletionHandler error: {}",
+                std::string([error.localizedDescription UTF8String]));
+    }
+    dispatch_semaphore_signal(sema);
+  }];
+  dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
+
+  impl_->stream = nil;
+  impl_->delegate = nil;
+
+  return 0;
+}
+
+int SpeakerCapturerMacosx::Destroy() {
+  Stop();
+  cb_ = nullptr;
+
+  if (impl_) {
+    impl_->config = nil;
+    impl_->content = nil;
+    impl_->mainDisplay = nil;
+    if (impl_->queue) {
+      impl_->queue = nil;
+    }
+  }
+  inited_ = false;
+  return 0;
+}
+
+int SpeakerCapturerMacosx::Pause() { return 0; }
+
+int SpeakerCapturerMacosx::Resume() { return Start(); }

src/speaker_capturer/speaker_capturer.h

@@ -11,7 +11,8 @@
 
 class SpeakerCapturer {
  public:
-  typedef std::function<void(unsigned char *, size_t)> speaker_data_cb;
+  typedef std::function<void(unsigned char *, size_t, const char *)>
+      speaker_data_cb;
 
  public:
   virtual ~SpeakerCapturer() {}

src/speaker_capturer/windows/speaker_capturer_wasapi.cpp

@@ -24,7 +24,8 @@ void data_callback(ma_device* pDevice, void* pOutput, const void* pInput,
     }
 
     ptr->GetCallback()((unsigned char*)pInput,
-                       frameCount * ma_get_bytes_per_frame(format_, channels_));
+                       frameCount * ma_get_bytes_per_frame(format_, channels_),
+                       "audio");
   }
 
   (void)pOutput;

test/audio_capture/audio_capture_wasapi.cpp

@@ -1,303 +0,0 @@
-// MyAudioSink.cpp : 定义控制台应用程序的入口点。
-//
-
-// #define  _CRT_SECURE_NO_WARNINGS
-
-#include <Audioclient.h>
-#include <Devicetopology.h>
-#include <Endpointvolume.h>
-#include <Mmdeviceapi.h>
-#include <tchar.h>
-
-#include <iostream>
-//-----------------------------------------------------------
-// Record an audio stream from the default audio capture
-// device. The RecordAudioStream function allocates a shared
-// buffer big enough to hold one second of PCM audio data.
-// The function uses this buffer to stream data from the
-// capture device. The main loop runs every 1/2 second.
-//-----------------------------------------------------------
-
-// REFERENCE_TIME time units per second and per millisecond
-#define REFTIMES_PER_SEC 10000000
-#define REFTIMES_PER_MILLISEC 10000
-
-#define EXIT_ON_ERROR(hres) \
-  if (FAILED(hres)) {       \
-    goto Exit;              \
-  }
-
-#define SAFE_RELEASE(punk) \
-  if ((punk) != NULL) {    \
-    (punk)->Release();     \
-    (punk) = NULL;         \
-  }
-
-#define IS_INPUT_DEVICE 0  // 切换输入和输出音频设备
-
-#define BUFFER_TIME_100NS (5 * 10000000)
-
-const CLSID CLSID_MMDeviceEnumerator = __uuidof(MMDeviceEnumerator);
-const IID IID_IMMDeviceEnumerator = __uuidof(IMMDeviceEnumerator);
-const IID IID_IAudioClient = __uuidof(IAudioClient);
-const IID IID_IAudioCaptureClient = __uuidof(IAudioCaptureClient);
-
-const IID IID_IDeviceTopology = __uuidof(IDeviceTopology);
-const IID IID_IAudioVolumeLevel = __uuidof(IAudioVolumeLevel);
-const IID IID_IPart = __uuidof(IPart);
-const IID IID_IConnector = __uuidof(IConnector);
-const IID IID_IAudioEndpointVolume = __uuidof(IAudioEndpointVolume);
-
-class MyAudioSink {
- public:
-  // WAVEFORMATEX *pwfx = NULL;
-  int SetFormat(WAVEFORMATEX *pwfx);
-
-  int CopyData(SHORT *pData, UINT32 numFramesAvailable, BOOL *pbDone);
-};
-
-int MyAudioSink::SetFormat(WAVEFORMATEX *pwfx) {
-  printf("wFormatTag is %x\n", pwfx->wFormatTag);
-  printf("nChannels is %x\n", pwfx->nChannels);
-  printf("nSamplesPerSec is %d\n", pwfx->nSamplesPerSec);
-  printf("nAvgBytesPerSec is %d\n", pwfx->nAvgBytesPerSec);
-  printf("wBitsPerSample is %d\n", pwfx->wBitsPerSample);
-
-  return 0;
-}
-
-FILE *fp;
-
-int MyAudioSink::CopyData(SHORT *pData, UINT32 numFramesAvailable,
-                          BOOL *pbDone) {
-  if (pData != NULL) {
-    size_t t = sizeof(SHORT);
-    for (int i = 0; i < numFramesAvailable / t; i++) {
-      double dbVal = pData[i];
-      pData[i] = dbVal;  // 可以通过不同的分母来控制声音大小
-    }
-    fwrite(pData, numFramesAvailable, 1, fp);
-  }
-
-  return 0;
-}
-
-/// pwfx->nSamplesPerSec    = 44100;
-/// 不支持修改采样率， 看来只能等得到数据之后再 swr 转换了
-BOOL AdjustFormatTo16Bits(WAVEFORMATEX *pwfx) {
-  BOOL bRet(FALSE);
-
-  if (pwfx->wFormatTag == WAVE_FORMAT_IEEE_FLOAT) {
-    pwfx->wFormatTag = WAVE_FORMAT_PCM;
-    pwfx->wBitsPerSample = 16;
-    pwfx->nBlockAlign = pwfx->nChannels * pwfx->wBitsPerSample / 8;
-    pwfx->nAvgBytesPerSec = pwfx->nBlockAlign * pwfx->nSamplesPerSec;
-
-    bRet = TRUE;
-  } else if (pwfx->wFormatTag == WAVE_FORMAT_EXTENSIBLE) {
-    PWAVEFORMATEXTENSIBLE pEx = reinterpret_cast<PWAVEFORMATEXTENSIBLE>(pwfx);
-    if (IsEqualGUID(KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, pEx->SubFormat)) {
-      pEx->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
-      pEx->Samples.wValidBitsPerSample = 16;
-      pwfx->wBitsPerSample = 16;
-      pwfx->nBlockAlign = pwfx->nChannels * pwfx->wBitsPerSample / 8;
-      pwfx->nAvgBytesPerSec = pwfx->nBlockAlign * pwfx->nSamplesPerSec;
-
-      bRet = TRUE;
-    }
-  }
-
-  return bRet;
-}
-
-typedef unsigned long long uint64_t;
-static bool have_clockfreq = false;
-static LARGE_INTEGER clock_freq;
-static inline uint64_t get_clockfreq(void) {
-  if (!have_clockfreq) QueryPerformanceFrequency(&clock_freq);
-  return clock_freq.QuadPart;
-}
-uint64_t os_gettime_ns(void) {
-  LARGE_INTEGER current_time;
-  double time_val;
-
-  QueryPerformanceCounter(&current_time);
-  time_val = (double)current_time.QuadPart;
-  time_val *= 1000000000.0;
-  time_val /= (double)get_clockfreq();
-
-  return (uint64_t)time_val;
-}
-
-HRESULT RecordAudioStream(MyAudioSink *pMySink) {
-  HRESULT hr;
-  REFERENCE_TIME hnsActualDuration;
-  UINT32 bufferFrameCount;
-  UINT32 numFramesAvailable;
-  BYTE *pData;
-  DWORD flags;
-  REFERENCE_TIME hnsDefaultDevicePeriod(0);
-
-  REFERENCE_TIME hnsRequestedDuration = REFTIMES_PER_SEC;
-  IMMDeviceEnumerator *pEnumerator = NULL;
-  IMMDevice *pDevice = NULL;
-  IAudioClient *pAudioClient = NULL;
-  IAudioCaptureClient *pCaptureClient = NULL;
-  WAVEFORMATEX *pwfx = NULL;
-  UINT32 packetLength = 0;
-  BOOL bDone = FALSE;
-  HANDLE hTimerWakeUp = NULL;
-  UINT64 pos, ts;
-
-  hr = CoCreateInstance(CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL,
-                        IID_IMMDeviceEnumerator, (void **)&pEnumerator);
-
-  EXIT_ON_ERROR(hr)
-
-  if (IS_INPUT_DEVICE)
-    hr = pEnumerator->GetDefaultAudioEndpoint(eCapture, eCommunications,
-                                              &pDevice);  // 输入
-  else
-    hr = pEnumerator->GetDefaultAudioEndpoint(eRender, eConsole,
-                                              &pDevice);  // 输出
-
-  // wchar_t *w_id;
-  // os_utf8_to_wcs_ptr(device_id.c_str(), device_id.size(), &w_id);
-  // hr = pEnumerator->GetDevice(w_id, &pDevice);
-  // bfree(w_id);
-
-  EXIT_ON_ERROR(hr)
-
-  hr = pDevice->Activate(IID_IAudioClient, CLSCTX_ALL, NULL,
-                         (void **)&pAudioClient);
-
-  EXIT_ON_ERROR(hr)
-
-  hr = pAudioClient->GetMixFormat(&pwfx);
-
-  EXIT_ON_ERROR(hr)
-
-  // The GetDevicePeriod method retrieves the length of the periodic interval
-  // separating successive processing passes by the audio engine on the data in
-  // the endpoint buffer.
-  hr = pAudioClient->GetDevicePeriod(&hnsDefaultDevicePeriod, NULL);
-
-  EXIT_ON_ERROR(hr)
-
-  AdjustFormatTo16Bits(pwfx);
-
-  // 平时创建定时器使用的是WINAPI  SetTimer，不过该函数一般用于有界面的时候。
-  // 无界面的情况下，可以选择微软提供的CreateWaitableTimer和SetWaitableTimer
-  // API。
-  hTimerWakeUp = CreateWaitableTimer(NULL, FALSE, NULL);
-
-  DWORD flag;
-  if (IS_INPUT_DEVICE)
-    flag = 0;
-  else
-    flag = AUDCLNT_STREAMFLAGS_LOOPBACK;
-
-  if (IS_INPUT_DEVICE)
-    hr = pAudioClient->Initialize(AUDCLNT_SHAREMODE_SHARED, flag /*0*/, 0, 0,
-                                  pwfx, NULL);  // 输入
-  else
-    hr = pAudioClient->Initialize(AUDCLNT_SHAREMODE_SHARED, flag /*0*/, 0, 0,
-                                  pwfx, NULL);  // 输出
-
-  EXIT_ON_ERROR(hr)
-
-  // Get the size of the allocated buffer.
-  hr = pAudioClient->GetBufferSize(&bufferFrameCount);
-  EXIT_ON_ERROR(hr)
-
-  hr = pAudioClient->GetService(IID_IAudioCaptureClient,
-                                (void **)&pCaptureClient);
-
-  EXIT_ON_ERROR(hr)
-
-  LARGE_INTEGER liFirstFire;
-  liFirstFire.QuadPart =
-      -hnsDefaultDevicePeriod / 2;  // negative means relative time
-  LONG lTimeBetweenFires = (LONG)hnsDefaultDevicePeriod / 2 /
-                           (10 * 1000);  // convert to milliseconds
-
-  BOOL bOK = SetWaitableTimer(hTimerWakeUp, &liFirstFire, lTimeBetweenFires,
-                              NULL, NULL, FALSE);
-
-  // Notify the audio sink which format to use.
-  hr = pMySink->SetFormat(pwfx);
-  EXIT_ON_ERROR(hr)
-
-  // Calculate the actual duration of the allocated buffer.
-  hnsActualDuration =
-      (double)REFTIMES_PER_SEC * bufferFrameCount / pwfx->nSamplesPerSec;
-
-  /*************************************************************/
-  hr = pAudioClient->Start();  // Start recording.
-  EXIT_ON_ERROR(hr)
-  HANDLE waitArray[1] = {/*htemp hEventStop,*/ hTimerWakeUp};
-
-  // Each loop fills about half of the shared buffer.
-  while (bDone == FALSE) {
-    // Sleep for half the buffer duration.
-    // Sleep(hnsActualDuration/REFTIMES_PER_MILLISEC/2);//这句貌似不加也可以
-    // WaitForSingleObject(hTimerWakeUp,INFINITE);
-    int a = sizeof(waitArray);
-    int aa = sizeof(waitArray[0]);
-    WaitForMultipleObjects(sizeof(waitArray) / sizeof(waitArray[0]), waitArray,
-                           FALSE, INFINITE);
-    // WaitForMultipleObjects(sizeof(waitArray) / sizeof(waitArray[0]),
-    // waitArray, FALSE, INFINITE);
-
-    hr = pCaptureClient->GetNextPacketSize(&packetLength);
-    EXIT_ON_ERROR(hr)
-
-    while (packetLength != 0) {
-      // Get the available data in the shared buffer.
-      hr = pCaptureClient->GetBuffer(&pData, &numFramesAvailable, &flags, NULL,
-                                     &ts);
-      ts = ts * 100;
-      uint64_t timestamp =
-          os_gettime_ns();  // ts是设备时间，timestamp是系统时间
-      EXIT_ON_ERROR(hr)
-
-      // 位运算，flags的标志符为2（静音状态）时，将pData置为NULL
-      if (flags & AUDCLNT_BUFFERFLAGS_SILENT) {
-        pData = NULL;  // Tell CopyData to write silence.
-      }
-
-      // Copy the available capture data to the audio sink.
-      hr = pMySink->CopyData((SHORT *)pData,
-                             numFramesAvailable * pwfx->nBlockAlign, &bDone);
-      EXIT_ON_ERROR(hr)
-
-      hr = pCaptureClient->ReleaseBuffer(numFramesAvailable);
-      EXIT_ON_ERROR(hr)
-
-      hr = pCaptureClient->GetNextPacketSize(&packetLength);
-      EXIT_ON_ERROR(hr)
-    }
-  }
-
-  hr = pAudioClient->Stop();  // Stop recording.
-  EXIT_ON_ERROR(hr)
-
-Exit:
-  CoTaskMemFree(pwfx);
-  SAFE_RELEASE(pEnumerator)
-  SAFE_RELEASE(pDevice)
-  SAFE_RELEASE(pAudioClient)
-  SAFE_RELEASE(pCaptureClient)
-
-  return hr;
-}
-
-int _tmain(int argc, _TCHAR *argv[]) {
-  fopen_s(&fp, "record.pcm", "wb");
-  CoInitialize(NULL);
-  MyAudioSink test;
-
-  RecordAudioStream(&test);
-
-  return 0;
-}

test/audio_capture/ffmpeg_audio.cpp

@@ -1,232 +0,0 @@
-extern "C" {
-#include <libavcodec/avcodec.h>
-#include <libavdevice/avdevice.h>
-#include <libavfilter/avfilter.h>
-#include <libavformat/avformat.h>
-#include <libavutil/channel_layout.h>
-#include <libavutil/imgutils.h>
-#include <libavutil/opt.h>
-#include <libavutil/samplefmt.h>
-#include <libswresample/swresample.h>
-#include <libswscale/swscale.h>
-};
-
-static int get_format_from_sample_fmt(const char **fmt,
-                                      enum AVSampleFormat sample_fmt) {
-  int i;
-  struct sample_fmt_entry {
-    enum AVSampleFormat sample_fmt;
-    const char *fmt_be, *fmt_le;
-  } sample_fmt_entries[] = {
-      {AV_SAMPLE_FMT_U8, "u8", "u8"},
-      {AV_SAMPLE_FMT_S16, "s16be", "s16le"},
-      {AV_SAMPLE_FMT_S32, "s32be", "s32le"},
-      {AV_SAMPLE_FMT_FLT, "f32be", "f32le"},
-      {AV_SAMPLE_FMT_DBL, "f64be", "f64le"},
-  };
-  *fmt = NULL;
-
-  for (i = 0; i < FF_ARRAY_ELEMS(sample_fmt_entries); i++) {
-    struct sample_fmt_entry *entry = &sample_fmt_entries[i];
-    if (sample_fmt == entry->sample_fmt) {
-      *fmt = AV_NE(entry->fmt_be, entry->fmt_le);
-      return 0;
-    }
-  }
-
-  fprintf(stderr, "Sample format %s not supported as output format\n",
-          av_get_sample_fmt_name(sample_fmt));
-  return AVERROR(EINVAL);
-}
-
-/**
- * Fill dst buffer with nb_samples, generated starting from t. <20><><EFBFBD><EFBFBD>ģʽ<C4A3><CABD>
- */
-static void fill_samples(double *dst, int nb_samples, int nb_channels,
-                         int sample_rate, double *t) {
-  int i, j;
-  double tincr = 1.0 / sample_rate, *dstp = dst;
-  const double c = 2 * M_PI * 440.0;
-
-  /* generate sin tone with 440Hz frequency and duplicated channels */
-  for (i = 0; i < nb_samples; i++) {
-    *dstp = sin(c * *t);
-    for (j = 1; j < nb_channels; j++) dstp[j] = dstp[0];
-    dstp += nb_channels;
-    *t += tincr;
-  }
-}
-
-int main(int argc, char **argv) {
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  int64_t src_ch_layout = AV_CH_LAYOUT_MONO;
-  int src_rate = 44100;
-  enum AVSampleFormat src_sample_fmt = AV_SAMPLE_FMT_DBL;
-  int src_nb_channels = 0;
-  uint8_t **src_data = NULL;  // <20><><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>
-  int src_linesize;
-  int src_nb_samples = 1024;
-
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  int64_t dst_ch_layout = AV_CH_LAYOUT_STEREO;
-  int dst_rate = 48000;
-  enum AVSampleFormat dst_sample_fmt = AV_SAMPLE_FMT_S16;
-  int dst_nb_channels = 0;
-  uint8_t **dst_data = NULL;  // <20><><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>
-  int dst_linesize;
-  int dst_nb_samples;
-  int max_dst_nb_samples;
-
-  // <20><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
-  const char *dst_filename = NULL;  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>pcm<63><6D><EFBFBD><EFBFBD><EFBFBD>أ<EFBFBD>Ȼ<EFBFBD>󲥷<EFBFBD><F3B2A5B7><EFBFBD>֤
-  FILE *dst_file;
-
-  int dst_bufsize;
-  const char *fmt;
-
-  // <20>ز<EFBFBD><D8B2><EFBFBD>ʵ<EFBFBD><CAB5>
-  struct SwrContext *swr_ctx;
-
-  double t;
-  int ret;
-
-  dst_filename = "res.pcm";
-
-  dst_file = fopen(dst_filename, "wb");
-  if (!dst_file) {
-    fprintf(stderr, "Could not open destination file %s\n", dst_filename);
-    exit(1);
-  }
-
-  // <20><><EFBFBD><EFBFBD><EFBFBD>ز<EFBFBD><D8B2><EFBFBD><EFBFBD><EFBFBD>
-  /* create resampler context */
-  swr_ctx = swr_alloc();
-  if (!swr_ctx) {
-    fprintf(stderr, "Could not allocate resampler context\n");
-    ret = AVERROR(ENOMEM);
-    goto end;
-  }
-
-  // <20><><EFBFBD><EFBFBD><EFBFBD>ز<EFBFBD><D8B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  /* set options */
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  av_opt_set_int(swr_ctx, "in_channel_layout", src_ch_layout, 0);
-  av_opt_set_int(swr_ctx, "in_sample_rate", src_rate, 0);
-  av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt", src_sample_fmt, 0);
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  av_opt_set_int(swr_ctx, "out_channel_layout", dst_ch_layout, 0);
-  av_opt_set_int(swr_ctx, "out_sample_rate", dst_rate, 0);
-  av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt", dst_sample_fmt, 0);
-
-  // <20><>ʼ<EFBFBD><CABC><EFBFBD>ز<EFBFBD><D8B2><EFBFBD>
-  /* initialize the resampling context */
-  if ((ret = swr_init(swr_ctx)) < 0) {
-    fprintf(stderr, "Failed to initialize the resampling context\n");
-    goto end;
-  }
-
-  /* allocate source and destination samples buffers */
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դ<EFBFBD><D4B4>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  src_nb_channels = av_get_channel_layout_nb_channels(src_ch_layout);
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դ<EFBFBD><D4B4><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD><DAB4>ռ<EFBFBD>
-  ret = av_samples_alloc_array_and_samples(&src_data, &src_linesize,
-                                           src_nb_channels, src_nb_samples,
-                                           src_sample_fmt, 0);
-  if (ret < 0) {
-    fprintf(stderr, "Could not allocate source samples\n");
-    goto end;
-  }
-
-  /* compute the number of converted samples: buffering is avoided
-   * ensuring that the output buffer will contain at least all the
-   * converted input samples */
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  max_dst_nb_samples = dst_nb_samples =
-      av_rescale_rnd(src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);
-
-  /* buffer is going to be directly written to a rawaudio file, no alignment
-   */
-  dst_nb_channels = av_get_channel_layout_nb_channels(dst_ch_layout);
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD>
-  ret = av_samples_alloc_array_and_samples(&dst_data, &dst_linesize,
-                                           dst_nb_channels, dst_nb_samples,
-                                           dst_sample_fmt, 0);
-  if (ret < 0) {
-    fprintf(stderr, "Could not allocate destination samples\n");
-    goto end;
-  }
-
-  t = 0;
-  do {
-    /* generate synthetic audio */
-    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դ
-    fill_samples((double *)src_data[0], src_nb_samples, src_nb_channels,
-                 src_rate, &t);
-
-    /* compute destination number of samples */
-    int64_t delay = swr_get_delay(swr_ctx, src_rate);
-    dst_nb_samples =
-        av_rescale_rnd(delay + src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);
-    if (dst_nb_samples > max_dst_nb_samples) {
-      av_freep(&dst_data[0]);
-      ret = av_samples_alloc(dst_data, &dst_linesize, dst_nb_channels,
-                             dst_nb_samples, dst_sample_fmt, 1);
-      if (ret < 0) break;
-      max_dst_nb_samples = dst_nb_samples;
-    }
-    //        int fifo_size = swr_get_out_samples(swr_ctx,src_nb_samples);
-    //        printf("fifo_size:%d\n", fifo_size);
-    //        if(fifo_size < 1024)
-    //            continue;
-
-    /* convert to destination format */
-    //        ret = swr_convert(swr_ctx, dst_data, dst_nb_samples, (const
-    //        uint8_t **)src_data, src_nb_samples);
-    ret = swr_convert(swr_ctx, dst_data, dst_nb_samples,
-                      (const uint8_t **)src_data, src_nb_samples);
-    if (ret < 0) {
-      fprintf(stderr, "Error while converting\n");
-      goto end;
-    }
-    dst_bufsize = av_samples_get_buffer_size(&dst_linesize, dst_nb_channels,
-                                             ret, dst_sample_fmt, 1);
-    if (dst_bufsize < 0) {
-      fprintf(stderr, "Could not get sample buffer size\n");
-      goto end;
-    }
-    printf("t:%f in:%d out:%d\n", t, src_nb_samples, ret);
-    fwrite(dst_data[0], 1, dst_bufsize, dst_file);
-  } while (t < 10);
-
-  ret = swr_convert(swr_ctx, dst_data, dst_nb_samples, NULL, 0);
-  if (ret < 0) {
-    fprintf(stderr, "Error while converting\n");
-    goto end;
-  }
-  dst_bufsize = av_samples_get_buffer_size(&dst_linesize, dst_nb_channels, ret,
-                                           dst_sample_fmt, 1);
-  if (dst_bufsize < 0) {
-    fprintf(stderr, "Could not get sample buffer size\n");
-    goto end;
-  }
-  printf("flush in:%d out:%d\n", 0, ret);
-  fwrite(dst_data[0], 1, dst_bufsize, dst_file);
-
-  if ((ret = get_format_from_sample_fmt(&fmt, dst_sample_fmt)) < 0) goto end;
-  fprintf(stderr,
-          "Resampling succeeded. Play the output file with the command:\n"
-          "ffplay -f %s -channel_layout %" PRId64 " -channels %d -ar %d %s\n",
-          fmt, dst_ch_layout, dst_nb_channels, dst_rate, dst_filename);
-
-end:
-  fclose(dst_file);
-
-  if (src_data) av_freep(&src_data[0]);
-  av_freep(&src_data);
-
-  if (dst_data) av_freep(&dst_data[0]);
-  av_freep(&dst_data);
-
-  swr_free(&swr_ctx);
-  return ret < 0;
-}

test/audio_capture/miniaudio.cpp

@@ -1,96 +0,0 @@
-/*
-Demonstrates how to implement loopback recording.
-
-This example simply captures data from your default playback device until you
-press Enter. The output is saved to the file specified on the command line.
-
-Loopback mode is when you record audio that is played from a given speaker. It
-is only supported on WASAPI, but can be used indirectly with PulseAudio by
-choosing the appropriate loopback device after enumeration.
-
-To use loopback mode you just need to set the device type to
-ma_device_type_loopback and set the capture device config properties. The output
-buffer in the callback will be null whereas the input buffer will be valid.
-*/
-#define MINIAUDIO_IMPLEMENTATION
-#include "miniaudio.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-
-FILE* fp;
-
-void data_callback(ma_device* pDevice, void* pOutput, const void* pInput,
-                   ma_uint32 frameCount) {
-  // ma_encoder* pEncoder = (ma_encoder*)pDevice->pUserData;
-  // MA_ASSERT(pEncoder != NULL);
-
-  // ma_encoder_write_pcm_frames(pEncoder, pInput, frameCount, NULL);
-
-  fwrite(pInput, frameCount * ma_get_bytes_per_frame(ma_format_s16, 1), 1, fp);
-
-  (void)pOutput;
-}
-
-int main(int argc, char** argv) {
-  ma_result result;
-  ma_encoder_config encoderConfig;
-  ma_encoder encoder;
-  ma_device_config deviceConfig;
-  ma_device device;
-
-  fopen_s(&fp, "miniaudio.pcm", "wb");
-
-  /* Loopback mode is currently only supported on WASAPI. */
-  ma_backend backends[] = {ma_backend_wasapi};
-
-  // if (argc < 2) {
-  //   printf("No output file.\n");
-  //   return -1;
-  // }
-
-  // encoderConfig =
-  //     ma_encoder_config_init(ma_encoding_format_wav, ma_format_s16, 1,
-  //     48000);
-
-  // if (ma_encoder_init_file(argv[1], &encoderConfig, &encoder) != MA_SUCCESS)
-  // {
-  //   printf("Failed to initialize output file.\n");
-  //   return -1;
-  // }
-
-  deviceConfig = ma_device_config_init(ma_device_type_loopback);
-  deviceConfig.capture.pDeviceID =
-      NULL; /* Use default device for this example. Set this to the ID of a
-               _playback_ device if you want to capture from a specific device.
-             */
-  deviceConfig.capture.format = ma_format_s16;
-  deviceConfig.capture.channels = 1;
-  deviceConfig.sampleRate = 48000;
-  deviceConfig.dataCallback = data_callback;
-  deviceConfig.pUserData = nullptr;
-
-  result = ma_device_init_ex(backends, sizeof(backends) / sizeof(backends[0]),
-                             NULL, &deviceConfig, &device);
-  if (result != MA_SUCCESS) {
-    printf("Failed to initialize loopback device.\n");
-    return -2;
-  }
-
-  result = ma_device_start(&device);
-  if (result != MA_SUCCESS) {
-    ma_device_uninit(&device);
-    printf("Failed to start device.\n");
-    return -3;
-  }
-
-  printf("Press Enter to stop recording...\n");
-  getchar();
-
-  fclose(fp);
-
-  ma_device_uninit(&device);
-  // ma_encoder_uninit(&encoder);
-
-  return 0;
-}

test/audio_capture/output_audio.cpp

@@ -1,53 +0,0 @@
-#include <SDL2/SDL.h>
-
-int main(int argc, char *argv[]) {
-  int ret;
-  SDL_AudioSpec wanted_spec, obtained_spec;
-
-  // Initialize SDL
-  if (SDL_Init(SDL_INIT_AUDIO) < 0) {
-    SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to initialize SDL: %s",
-                 SDL_GetError());
-    return -1;
-  }
-
-  // Set audio format
-  wanted_spec.freq = 44100;  // Sample rate
-  wanted_spec.format =
-      AUDIO_F32SYS;          // Sample format (32-bit float, system byte order)
-  wanted_spec.channels = 2;  // Number of channels (stereo)
-  wanted_spec.samples = 1024;   // Buffer size (in samples)
-  wanted_spec.callback = NULL;  // Audio callback function (not used here)
-
-  // Open audio device
-  ret = SDL_OpenAudio(&wanted_spec, &obtained_spec);
-  if (ret < 0) {
-    SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
-                 "Failed to open audio device: %s", SDL_GetError());
-    return -1;
-  }
-
-  // Start playing audio
-  SDL_PauseAudio(0);
-
-  // Write PCM data to audio buffer
-  float *pcm_data = ...;    // PCM data buffer (float, interleaved)
-  int pcm_data_size = ...;  // Size of PCM data buffer (in bytes)
-  int bytes_written = SDL_QueueAudio(0, pcm_data, pcm_data_size);
-
-  // Wait until audio buffer is empty
-  while (SDL_GetQueuedAudioSize(0) > 0) {
-    SDL_Delay(100);
-  }
-
-  // Stop playing audio
-  SDL_PauseAudio(1);
-
-  // Close audio device
-  SDL_CloseAudio();
-
-  // Quit SDL
-  SDL_Quit();
-
-  return 0;
-}

test/audio_capture/play_audio.cpp

@@ -1,89 +0,0 @@
-#include <SDL2/SDL.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-int main(int argc, char* argv[]) {
-  if (SDL_Init(SDL_INIT_AUDIO)) {
-    printf("SDL init error\n");
-    return -1;
-  }
-
-  // SDL_AudioSpec
-  SDL_AudioSpec wanted_spec;
-  SDL_zero(wanted_spec);
-  wanted_spec.freq = 48000;
-  wanted_spec.format = AUDIO_S16LSB;
-  wanted_spec.channels = 2;
-  wanted_spec.silence = 0;
-  wanted_spec.samples = 960;
-  wanted_spec.callback = NULL;
-
-  SDL_AudioDeviceID deviceID = 0;
-  // <20><><EFBFBD><EFBFBD><EFBFBD>豸
-  if ((deviceID = SDL_OpenAudioDevice(NULL, 0, &wanted_spec, NULL,
-                                      SDL_AUDIO_ALLOW_FREQUENCY_CHANGE)) < 2) {
-    printf("could not open audio device: %s\n", SDL_GetError());
-
-    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>е<EFBFBD><D0B5><EFBFBD>ϵͳ
-    SDL_Quit();
-    return 0;
-  }
-
-  SDL_PauseAudioDevice(deviceID, 0);
-
-  FILE* fp = nullptr;
-
-  fopen_s(&fp, "ls.pcm", "rb+");
-  if (fp == NULL) {
-    printf("cannot open this file\n");
-    return -1;
-  }
-
-  if (fp == NULL) {
-    printf("error \n");
-  }
-  Uint32 buffer_size = 4096;
-  char* buffer = (char*)malloc(buffer_size);
-
-  while (true) {
-    if (fread(buffer, 1, buffer_size, fp) != buffer_size) {
-      printf("end of file\n");
-      break;
-    }
-    SDL_QueueAudio(deviceID, buffer, buffer_size);
-  }
-
-  printf("Play...\n");
-
-  SDL_Delay(10000);
-
-  // Uint32 residueAudioLen = 0;
-
-  // while (true) {
-  //   residueAudioLen = SDL_GetQueuedAudioSize(deviceID);
-  //   printf("%10d\n", residueAudioLen);
-  //   if (residueAudioLen <= 0) break;
-  //   SDL_Delay(1);
-  // }
-
-  // while (true) {
-  //   printf("1 <20><>ͣ 2 <20><><EFBFBD><EFBFBD>  3 <20>˳<EFBFBD> \n");
-  //   int flag = 0;
-
-  //   scanf_s("%d", &flag);
-
-  //   if (flag == 1)
-  //     SDL_PauseAudioDevice(deviceID, 1);
-  //   else if (flag == 2)
-  //     SDL_PauseAudioDevice(deviceID, 0);
-  //   else if (flag == 3)
-  //     break;
-  // }
-
-  SDL_CloseAudio();
-  SDL_Quit();
-  fclose(fp);
-
-  return 0;
-}

test/audio_capture/play_loopback.cpp

@@ -1,225 +0,0 @@
-#include <SDL2/SDL.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-extern "C" {
-#include <libavcodec/avcodec.h>
-#include <libavdevice/avdevice.h>
-#include <libavfilter/avfilter.h>
-#include <libavformat/avformat.h>
-#include <libavutil/channel_layout.h>
-#include <libavutil/imgutils.h>
-#include <libavutil/opt.h>
-#include <libavutil/samplefmt.h>
-#include <libswresample/swresample.h>
-#include <libswscale/swscale.h>
-};
-
-static SDL_AudioDeviceID input_dev;
-static SDL_AudioDeviceID output_dev;
-
-static Uint8 *buffer = 0;
-static int in_pos = 0;
-static int out_pos = 0;
-
-int64_t src_ch_layout = AV_CH_LAYOUT_MONO;
-int src_rate = 48000;
-enum AVSampleFormat src_sample_fmt = AV_SAMPLE_FMT_S16;
-int src_nb_channels = 0;
-uint8_t **src_data = NULL;  // <20><><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>
-int src_linesize;
-int src_nb_samples = 480;
-
-// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-int64_t dst_ch_layout = AV_CH_LAYOUT_MONO;
-int dst_rate = 48000;
-enum AVSampleFormat dst_sample_fmt = AV_SAMPLE_FMT_S16;
-int dst_nb_channels = 0;
-uint8_t **dst_data = NULL;  // <20><><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>
-int dst_linesize;
-int dst_nb_samples;
-int max_dst_nb_samples;
-static unsigned char audio_buffer[960 * 3];
-static int audio_len = 0;
-
-// <20><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
-const char *dst_filename = NULL;  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>pcm<63><6D><EFBFBD><EFBFBD><EFBFBD>أ<EFBFBD>Ȼ<EFBFBD>󲥷<EFBFBD><F3B2A5B7><EFBFBD>֤
-FILE *dst_file;
-
-int dst_bufsize;
-const char *fmt;
-
-// <20>ز<EFBFBD><D8B2><EFBFBD>ʵ<EFBFBD><CAB5>
-struct SwrContext *swr_ctx;
-
-double t;
-int ret;
-
-char *out = "audio_old.pcm";
-FILE *outfile = fopen(out, "wb+");
-
-void cb_in(void *userdata, Uint8 *stream, int len) {
-  // If len < 4, the printf below will probably segfault
-  // SDL_QueueAudio(output_dev, stream, len);
-
-  int64_t delay = swr_get_delay(swr_ctx, src_rate);
-  dst_nb_samples =
-      av_rescale_rnd(delay + src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);
-  if (dst_nb_samples > max_dst_nb_samples) {
-    av_freep(&dst_data[0]);
-    ret = av_samples_alloc(dst_data, &dst_linesize, dst_nb_channels,
-                           dst_nb_samples, dst_sample_fmt, 1);
-    if (ret < 0) return;
-    max_dst_nb_samples = dst_nb_samples;
-  }
-
-  ret = swr_convert(swr_ctx, dst_data, dst_nb_samples,
-                    (const uint8_t **)&stream, src_nb_samples);
-  if (ret < 0) {
-    fprintf(stderr, "Error while converting\n");
-    return;
-  }
-  dst_bufsize = av_samples_get_buffer_size(&dst_linesize, dst_nb_channels, ret,
-                                           dst_sample_fmt, 1);
-  if (dst_bufsize < 0) {
-    fprintf(stderr, "Could not get sample buffer size\n");
-    return;
-  }
-  printf("t:%f in:%d out:%d %d\n", t, src_nb_samples, ret, len);
-
-  memcpy(audio_buffer, dst_data[0], len);
-  // SDL_QueueAudio(output_dev, dst_data[0], len);
-  audio_len = len;
-}
-
-void cb_out(void *userdata, Uint8 *stream, int len) {
-  // If len < 4, the printf below will probably segfault
-  printf("cb_out len = %d\n", len);
-  SDL_memset(stream, 0, len);
-  if (audio_len == 0) return;
-  len = (len > audio_len ? audio_len : len);
-  SDL_MixAudioFormat(stream, audio_buffer, AUDIO_S16LSB, len,
-                     SDL_MIX_MAXVOLUME);
-}
-
-int init() {
-  dst_filename = "res.pcm";
-
-  dst_file = fopen(dst_filename, "wb");
-  if (!dst_file) {
-    fprintf(stderr, "Could not open destination file %s\n", dst_filename);
-    exit(1);
-  }
-
-  // <20><><EFBFBD><EFBFBD><EFBFBD>ز<EFBFBD><D8B2><EFBFBD><EFBFBD><EFBFBD>
-  /* create resampler context */
-  swr_ctx = swr_alloc();
-  if (!swr_ctx) {
-    fprintf(stderr, "Could not allocate resampler context\n");
-    ret = AVERROR(ENOMEM);
-    return -1;
-  }
-
-  // <20><><EFBFBD><EFBFBD><EFBFBD>ز<EFBFBD><D8B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  /* set options */
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  av_opt_set_int(swr_ctx, "in_channel_layout", src_ch_layout, 0);
-  av_opt_set_int(swr_ctx, "in_sample_rate", src_rate, 0);
-  av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt", src_sample_fmt, 0);
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  av_opt_set_int(swr_ctx, "out_channel_layout", dst_ch_layout, 0);
-  av_opt_set_int(swr_ctx, "out_sample_rate", dst_rate, 0);
-  av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt", dst_sample_fmt, 0);
-
-  // <20><>ʼ<EFBFBD><CABC><EFBFBD>ز<EFBFBD><D8B2><EFBFBD>
-  /* initialize the resampling context */
-  if ((ret = swr_init(swr_ctx)) < 0) {
-    fprintf(stderr, "Failed to initialize the resampling context\n");
-    return -1;
-  }
-
-  /* allocate source and destination samples buffers */
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դ<EFBFBD><D4B4>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  src_nb_channels = av_get_channel_layout_nb_channels(src_ch_layout);
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դ<EFBFBD><D4B4><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD><DAB4>ռ<EFBFBD>
-  ret = av_samples_alloc_array_and_samples(&src_data, &src_linesize,
-                                           src_nb_channels, src_nb_samples,
-                                           src_sample_fmt, 0);
-  if (ret < 0) {
-    fprintf(stderr, "Could not allocate source samples\n");
-    return -1;
-  }
-
-  /* compute the number of converted samples: buffering is avoided
-   * ensuring that the output buffer will contain at least all the
-   * converted input samples */
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  max_dst_nb_samples = dst_nb_samples =
-      av_rescale_rnd(src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);
-
-  /* buffer is going to be directly written to a rawaudio file, no alignment */
-  dst_nb_channels = av_get_channel_layout_nb_channels(dst_ch_layout);
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD>
-  ret = av_samples_alloc_array_and_samples(&dst_data, &dst_linesize,
-                                           dst_nb_channels, dst_nb_samples,
-                                           dst_sample_fmt, 0);
-  if (ret < 0) {
-    fprintf(stderr, "Could not allocate destination samples\n");
-    return -1;
-  }
-}
-
-int main() {
-  init();
-
-  SDL_Init(SDL_INIT_AUDIO);
-
-  // 16Mb should be enough; the test lasts 5 seconds
-  buffer = (Uint8 *)malloc(16777215);
-
-  SDL_AudioSpec want_in, want_out, have_in, have_out;
-
-  SDL_zero(want_in);
-  want_in.freq = 48000;
-  want_in.format = AUDIO_S16LSB;
-  want_in.channels = 1;
-  want_in.samples = 480;
-  want_in.callback = cb_in;
-
-  input_dev = SDL_OpenAudioDevice(NULL, 1, &want_in, &have_in, 0);
-
-  printf("%d %d %d %d\n", have_in.freq, have_in.format, have_in.channels,
-         have_in.samples);
-  if (input_dev == 0) {
-    SDL_Log("Failed to open input: %s", SDL_GetError());
-    return 1;
-  }
-
-  SDL_zero(want_out);
-  want_out.freq = 48000;
-  want_out.format = AUDIO_S16LSB;
-  want_out.channels = 1;
-  want_out.samples = 480;
-  want_out.callback = cb_out;
-
-  output_dev = SDL_OpenAudioDevice(NULL, 0, &want_out, &have_out, 0);
-
-  printf("%d %d %d %d\n", have_out.freq, have_out.format, have_out.channels,
-         have_out.samples);
-  if (output_dev == 0) {
-    SDL_Log("Failed to open input: %s", SDL_GetError());
-    return 1;
-  }
-
-  SDL_PauseAudioDevice(input_dev, 0);
-  SDL_PauseAudioDevice(output_dev, 0);
-
-  while (1) {
-  }
-
-  SDL_CloseAudioDevice(output_dev);
-  SDL_CloseAudioDevice(input_dev);
-  free(buffer);
-
-  fclose(outfile);
-}

test/audio_capture/resample.cpp

@@ -1,95 +0,0 @@
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
-#include <libswresample/swresample.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-int main(int argc, char *argv[]) {
-  int ret;
-  AVFrame *frame = NULL;
-  AVFrame *resampled_frame = NULL;
-  AVCodecContext *codec_ctx = NULL;
-  SwrContext *swr_ctx = NULL;
-
-  // Initialize FFmpeg
-  av_log_set_level(AV_LOG_INFO);
-  av_register_all();
-
-  // Allocate input frame
-  frame = av_frame_alloc();
-  if (!frame) {
-    av_log(NULL, AV_LOG_ERROR, "Failed to allocate input frame\n");
-    return -1;
-  }
-
-  // Allocate output frame for resampled data
-  resampled_frame = av_frame_alloc();
-  if (!resampled_frame) {
-    av_log(NULL, AV_LOG_ERROR, "Failed to allocate output frame\n");
-    return -1;
-  }
-
-  // Set input frame properties
-  frame->format = AV_SAMPLE_FMT_FLTP;  // Input sample format (float planar)
-  frame->channel_layout = AV_CH_LAYOUT_STEREO;  // Input channel layout (stereo)
-  frame->sample_rate = 44100;                   // Input sample rate (44100 Hz)
-  frame->nb_samples = 1024;                     // Number of input samples
-
-  // Set output frame properties
-  resampled_frame->format =
-      AV_SAMPLE_FMT_S16;  // Output sample format (signed 16-bit)
-  resampled_frame->channel_layout =
-      AV_CH_LAYOUT_STEREO;               // Output channel layout (stereo)
-  resampled_frame->sample_rate = 48000;  // Output sample rate (48000 Hz)
-  resampled_frame->nb_samples = av_rescale_rnd(
-      frame->nb_samples, resampled_frame->sample_rate, frame->sample_rate,
-      AV_ROUND_UP);  // Number of output samples
-
-  // Initialize resampler context
-  swr_ctx = swr_alloc_set_opts(
-      NULL, av_get_default_channel_layout(resampled_frame->channel_layout),
-      av_get_default_sample_fmt(resampled_frame->format),
-      resampled_frame->sample_rate,
-      av_get_default_channel_layout(frame->channel_layout),
-      av_get_default_sample_fmt(frame->format), frame->sample_rate, 0, NULL);
-  if (!swr_ctx) {
-    av_log(NULL, AV_LOG_ERROR, "Failed to allocate resampler context\n");
-    return -1;
-  }
-
-  // Initialize and configure the resampler
-  if ((ret = swr_init(swr_ctx)) < 0) {
-    av_log(NULL, AV_LOG_ERROR, "Failed to initialize resampler context: %s\n",
-           av_err2str(ret));
-    return -1;
-  }
-
-  // Allocate buffer for output samples
-  ret = av_samples_alloc(resampled_frame->data, resampled_frame->linesize,
-                         resampled_frame->channels, resampled_frame->nb_samples,
-                         resampled_frame->format, 0);
-  if (ret < 0) {
-    av_log(NULL, AV_LOG_ERROR, "Failed to allocate output samples buffer: %s\n",
-           av_err2str(ret));
-    return -1;
-  }
-
-  // Resample the input data
-  ret = swr_convert(swr_ctx, resampled_frame->data, resampled_frame->nb_samples,
-                    (const uint8_t **)frame->data, frame->nb_samples);
-  if (ret < 0) {
-    av_log(NULL, AV_LOG_ERROR, "Failed to resample input data: %s\n",
-           av_err2str(ret));
-    return -1;
-  }
-
-  // Cleanup and free resources
-  swr_free(&swr_ctx);
-  av_frame_free(&frame);
-  av_frame_free(&resampled_frame);
-
-  return 0;
-}

test/audio_capture/sdl2_audio_capture.cpp

@@ -1,205 +0,0 @@
-#include <SDL2/SDL.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-extern "C" {
-#include <libavcodec/avcodec.h>
-#include <libavdevice/avdevice.h>
-#include <libavfilter/avfilter.h>
-#include <libavformat/avformat.h>
-#include <libavutil/channel_layout.h>
-#include <libavutil/imgutils.h>
-#include <libavutil/opt.h>
-#include <libavutil/samplefmt.h>
-#include <libswresample/swresample.h>
-#include <libswscale/swscale.h>
-};
-
-static SDL_AudioDeviceID input_dev;
-static SDL_AudioDeviceID output_dev;
-
-static Uint8 *buffer = 0;
-static int in_pos = 0;
-static int out_pos = 0;
-
-int64_t src_ch_layout = AV_CH_LAYOUT_MONO;
-int src_rate = 48000;
-enum AVSampleFormat src_sample_fmt = AV_SAMPLE_FMT_FLT;
-int src_nb_channels = 0;
-uint8_t **src_data = NULL;  // <20><><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>
-int src_linesize;
-int src_nb_samples = 480;
-
-// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-int64_t dst_ch_layout = AV_CH_LAYOUT_STEREO;
-int dst_rate = 48000;
-enum AVSampleFormat dst_sample_fmt = AV_SAMPLE_FMT_S16;
-int dst_nb_channels = 0;
-uint8_t **dst_data = NULL;  // <20><><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>
-int dst_linesize;
-int dst_nb_samples;
-int max_dst_nb_samples;
-
-// <20><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
-const char *dst_filename = NULL;  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>pcm<63><6D><EFBFBD><EFBFBD><EFBFBD>أ<EFBFBD>Ȼ<EFBFBD>󲥷<EFBFBD><F3B2A5B7><EFBFBD>֤
-FILE *dst_file;
-
-int dst_bufsize;
-const char *fmt;
-
-// <20>ز<EFBFBD><D8B2><EFBFBD>ʵ<EFBFBD><CAB5>
-struct SwrContext *swr_ctx;
-
-double t;
-int ret;
-
-char *out = "audio_old.pcm";
-FILE *outfile = fopen(out, "wb+");
-
-void cb_in(void *userdata, Uint8 *stream, int len) {
-  // If len < 4, the printf below will probably segfault
-  {
-    fwrite(stream, 1, len, outfile);
-    fflush(outfile);
-  }
-  {
-    int64_t delay = swr_get_delay(swr_ctx, src_rate);
-    dst_nb_samples =
-        av_rescale_rnd(delay + src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);
-    if (dst_nb_samples > max_dst_nb_samples) {
-      av_freep(&dst_data[0]);
-      ret = av_samples_alloc(dst_data, &dst_linesize, dst_nb_channels,
-                             dst_nb_samples, dst_sample_fmt, 1);
-      if (ret < 0) return;
-      max_dst_nb_samples = dst_nb_samples;
-    }
-
-    ret = swr_convert(swr_ctx, dst_data, dst_nb_samples,
-                      (const uint8_t **)&stream, src_nb_samples);
-    if (ret < 0) {
-      fprintf(stderr, "Error while converting\n");
-      return;
-    }
-    dst_bufsize = av_samples_get_buffer_size(&dst_linesize, dst_nb_channels,
-                                             ret, dst_sample_fmt, 1);
-    if (dst_bufsize < 0) {
-      fprintf(stderr, "Could not get sample buffer size\n");
-      return;
-    }
-    printf("t:%f in:%d out:%d\n", t, src_nb_samples, ret);
-    fwrite(dst_data[0], 1, dst_bufsize, dst_file);
-  }
-}
-
-void cb_out(void *userdata, Uint8 *stream, int len) {
-  // If len < 4, the printf below will probably segfault
-
-  SDL_memcpy(buffer + out_pos, stream, len);
-  out_pos += len;
-}
-
-int init() {
-  dst_filename = "res.pcm";
-
-  dst_file = fopen(dst_filename, "wb");
-  if (!dst_file) {
-    fprintf(stderr, "Could not open destination file %s\n", dst_filename);
-    exit(1);
-  }
-
-  // <20><><EFBFBD><EFBFBD><EFBFBD>ز<EFBFBD><D8B2><EFBFBD><EFBFBD><EFBFBD>
-  /* create resampler context */
-  swr_ctx = swr_alloc();
-  if (!swr_ctx) {
-    fprintf(stderr, "Could not allocate resampler context\n");
-    ret = AVERROR(ENOMEM);
-    return -1;
-  }
-
-  // <20><><EFBFBD><EFBFBD><EFBFBD>ز<EFBFBD><D8B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  /* set options */
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  av_opt_set_int(swr_ctx, "in_channel_layout", src_ch_layout, 0);
-  av_opt_set_int(swr_ctx, "in_sample_rate", src_rate, 0);
-  av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt", src_sample_fmt, 0);
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  av_opt_set_int(swr_ctx, "out_channel_layout", dst_ch_layout, 0);
-  av_opt_set_int(swr_ctx, "out_sample_rate", dst_rate, 0);
-  av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt", dst_sample_fmt, 0);
-
-  // <20><>ʼ<EFBFBD><CABC><EFBFBD>ز<EFBFBD><D8B2><EFBFBD>
-  /* initialize the resampling context */
-  if ((ret = swr_init(swr_ctx)) < 0) {
-    fprintf(stderr, "Failed to initialize the resampling context\n");
-    return -1;
-  }
-
-  /* allocate source and destination samples buffers */
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դ<EFBFBD><D4B4>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  src_nb_channels = av_get_channel_layout_nb_channels(src_ch_layout);
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Դ<EFBFBD><D4B4><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD><DAB4>ռ<EFBFBD>
-  ret = av_samples_alloc_array_and_samples(&src_data, &src_linesize,
-                                           src_nb_channels, src_nb_samples,
-                                           src_sample_fmt, 0);
-  if (ret < 0) {
-    fprintf(stderr, "Could not allocate source samples\n");
-    return -1;
-  }
-
-  /* compute the number of converted samples: buffering is avoided
-   * ensuring that the output buffer will contain at least all the
-   * converted input samples */
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  max_dst_nb_samples = dst_nb_samples =
-      av_rescale_rnd(src_nb_samples, dst_rate, src_rate, AV_ROUND_UP);
-
-  /* buffer is going to be directly written to a rawaudio file, no alignment */
-  dst_nb_channels = av_get_channel_layout_nb_channels(dst_ch_layout);
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD>
-  ret = av_samples_alloc_array_and_samples(&dst_data, &dst_linesize,
-                                           dst_nb_channels, dst_nb_samples,
-                                           dst_sample_fmt, 0);
-  if (ret < 0) {
-    fprintf(stderr, "Could not allocate destination samples\n");
-    return -1;
-  }
-}
-
-int main() {
-  init();
-
-  SDL_Init(SDL_INIT_AUDIO);
-
-  // 16Mb should be enough; the test lasts 5 seconds
-  buffer = (Uint8 *)malloc(16777215);
-
-  SDL_AudioSpec want_in, want_out, have_in, have_out;
-
-  SDL_zero(want_in);
-  want_in.freq = 48000;
-  want_in.format = AUDIO_F32LSB;
-  want_in.channels = 2;
-  want_in.samples = 960;
-  want_in.callback = cb_in;
-
-  input_dev = SDL_OpenAudioDevice(NULL, 1, &want_in, &have_in,
-                                  SDL_AUDIO_ALLOW_ANY_CHANGE);
-
-  printf("%d %d %d %d\n", have_in.freq, have_in.format, have_in.channels,
-         have_in.samples);
-  if (input_dev == 0) {
-    SDL_Log("Failed to open input: %s", SDL_GetError());
-    return 1;
-  }
-
-  SDL_PauseAudioDevice(input_dev, 0);
-  SDL_PauseAudioDevice(output_dev, 0);
-
-  SDL_Delay(5000);
-
-  SDL_CloseAudioDevice(output_dev);
-  SDL_CloseAudioDevice(input_dev);
-  free(buffer);
-
-  fclose(outfile);
-}

test/audio_capture/windows_capture.cpp

@@ -1,123 +0,0 @@
-#define __STDC_CONSTANT_MACROS
-extern "C" {
-#include <libavdevice/avdevice.h>
-#include <libavformat/avformat.h>
-#include <libavutil/log.h>
-#include <libswresample/swresample.h>
-}
-
-#include <windows.h>
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#pragma comment(lib, "avutil.lib")
-#pragma comment(lib, "avdevice.lib")
-#pragma comment(lib, "avformat.lib")
-#pragma comment(lib, "avcodec.lib")
-
-#pragma comment(lib, "Winmm.lib")
-
-using std::shared_ptr;
-using std::string;
-using std::vector;
-
-void capture_audio() {
-  // windows api <20><>ȡ<EFBFBD><C8A1>Ƶ<EFBFBD>豸<EFBFBD>б<EFBFBD><D0B1><EFBFBD>ffmpeg <20><><EFBFBD><EFBFBD>û<EFBFBD><C3BB><EFBFBD>ṩ<EFBFBD><E1B9A9>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>Ƶ<EFBFBD>豸<EFBFBD><E8B1B8>api<70><69>
-  int nDeviceNum = waveInGetNumDevs();
-  vector<string> vecDeviceName;
-  for (int i = 0; i < nDeviceNum; ++i) {
-    WAVEINCAPS wic;
-    waveInGetDevCaps(i, &wic, sizeof(wic));
-
-    // ת<><D7AA>utf-8
-    int nSize = WideCharToMultiByte(CP_UTF8, 0, wic.szPname,
-                                    wcslen(wic.szPname), NULL, 0, NULL, NULL);
-    shared_ptr<char> spDeviceName(new char[nSize + 1]);
-    memset(spDeviceName.get(), 0, nSize + 1);
-    WideCharToMultiByte(CP_UTF8, 0, wic.szPname, wcslen(wic.szPname),
-                        spDeviceName.get(), nSize, NULL, NULL);
-    vecDeviceName.push_back(spDeviceName.get());
-    av_log(NULL, AV_LOG_DEBUG, "audio input device : %s \n",
-           spDeviceName.get());
-  }
-  if (vecDeviceName.size() <= 0) {
-    av_log(NULL, AV_LOG_ERROR, "not find audio input device.\n");
-    return;
-  }
-  string sDeviceName = "audio=" + vecDeviceName[0];  // ʹ<>õ<EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD>Ƶ<EFBFBD>豸
-
-  // ffmpeg
-  avdevice_register_all();  // ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>豸
-  AVInputFormat* ifmt =
-      (AVInputFormat*)av_find_input_format("dshow");  // <20><><EFBFBD>òɼ<C3B2><C9BC><EFBFBD>ʽ dshow
-  if (ifmt == NULL) {
-    av_log(NULL, AV_LOG_ERROR, "av_find_input_format for dshow fail.\n");
-    return;
-  }
-
-  AVFormatContext* fmt_ctx = NULL;  // format <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  int ret = avformat_open_input(&fmt_ctx, sDeviceName.c_str(), ifmt,
-                                NULL);  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƶ<EFBFBD>豸
-  if (ret != 0) {
-    av_log(NULL, AV_LOG_ERROR, "avformat_open_input fail. return %d.\n", ret);
-    return;
-  }
-
-  AVPacket pkt;
-
-  int64_t src_rate = 44100;
-  int64_t dst_rate = 48000;
-  SwrContext* swr_ctx = swr_alloc();
-
-  uint8_t** dst_data = NULL;
-  int dst_linesize = 0;
-
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  av_opt_set_int(swr_ctx, "in_channel_layout", AV_CH_LAYOUT_MONO, 0);
-  av_opt_set_int(swr_ctx, "in_sample_rate", src_rate, 0);
-  av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt", AV_SAMPLE_FMT_S16, 0);
-  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  av_opt_set_int(swr_ctx, "out_channel_layout", AV_CH_LAYOUT_STEREO, 0);
-  av_opt_set_int(swr_ctx, "out_sample_rate", dst_rate, 0);
-  av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt", AV_SAMPLE_FMT_S16, 0);
-  // <20><>ʼ<EFBFBD><CABC>SwrContext
-  swr_init(swr_ctx);
-
-  FILE* fp = fopen("dst.pcm", "wb");
-  int count = 0;
-  while (count++ < 10) {
-    ret = av_read_frame(fmt_ctx, &pkt);
-    if (ret != 0) {
-      av_log(NULL, AV_LOG_ERROR, "av_read_frame fail, return %d .\n", ret);
-      break;
-    }
-
-    int out_samples_per_channel =
-        (int)av_rescale_rnd(1024, dst_rate, src_rate, AV_ROUND_UP);
-    int out_buffer_size = av_samples_get_buffer_size(
-        NULL, 1, out_samples_per_channel, AV_SAMPLE_FMT_S16, 0);
-    // uint8_t* out_buffer = (uint8_t*)av_malloc(out_buffer_size);
-    ret = av_samples_alloc_array_and_samples(
-        &dst_data, &dst_linesize, 2, out_buffer_size, AV_SAMPLE_FMT_S16, 0);
-
-    // <20><><EFBFBD><EFBFBD><EFBFBD>ز<EFBFBD><D8B2><EFBFBD>
-    swr_convert(swr_ctx, dst_data, out_samples_per_channel,
-                (const uint8_t**)&pkt.data, 1024);
-
-    fwrite(dst_data[1], 1, out_buffer_size, fp);
-    av_packet_unref(&pkt);  // <20><><EFBFBD><EFBFBD><EFBFBD>ͷ<EFBFBD>pkt<6B><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ棬<DAB4><E6A3AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD>й¶
-  }
-  fflush(fp);  // ˢ<><CBA2><EFBFBD>ļ<EFBFBD>io<69><6F><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-  fclose(fp);
-
-  avformat_close_input(&fmt_ctx);
-}
-
-int main(int argc, char** argv) {
-  av_log_set_level(AV_LOG_DEBUG);  // <20><><EFBFBD><EFBFBD>ffmpeg<65><67>־<EFBFBD><D6BE><EFBFBD>ȼ<EFBFBD>
-  capture_audio();
-
-  Sleep(1);
-}

test/linux_mouse_control/mouse_control.cpp

@@ -1,150 +0,0 @@
-#include <X11/Xlib.h>
-#include <fcntl.h>
-#include <linux/uinput.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include <cstring>
-#include <iostream>
-#include <sstream>
-
-using namespace std;
-
-int fd;
-Display *dpy;
-
-void initMouse();
-void destroyMouse();
-void mouseLeftClick();
-void mouseRightClick();
-void mouseGetPosition(int &x, int &y);
-void mouseMove(int xdelta, int ydelta);
-
-void initMouse() {
-  fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK);
-  ioctl(fd, UI_SET_EVBIT, EV_KEY);
-  ioctl(fd, UI_SET_KEYBIT, BTN_RIGHT);
-  ioctl(fd, UI_SET_KEYBIT, BTN_LEFT);
-  ioctl(fd, UI_SET_EVBIT, EV_ABS);
-  ioctl(fd, UI_SET_ABSBIT, ABS_X);
-  ioctl(fd, UI_SET_ABSBIT, ABS_Y);
-  ioctl(fd, UI_SET_EVBIT, EV_REL);
-
-  struct uinput_user_dev uidev;
-  memset(&uidev, 0, sizeof(uidev));
-  snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "VirtualMouse");
-  uidev.id.bustype = BUS_USB;
-  uidev.id.version = 1;
-  uidev.id.vendor = 0x1;
-  uidev.id.product = 0x1;
-  uidev.absmin[ABS_X] = 0;
-  uidev.absmax[ABS_X] = 3200;
-  uidev.absmin[ABS_Y] = 0;
-  uidev.absmax[ABS_Y] = 900;
-
-  write(fd, &uidev, sizeof(uidev));
-  ioctl(fd, UI_DEV_CREATE);
-
-  sleep(2);
-}
-
-void mouseLeftClick() {
-  struct input_event ev_click, ev_sync;
-  memset(&ev_click, 0, sizeof(ev_click));
-  memset(&ev_sync, 0, sizeof(ev_sync));
-
-  ev_click.type = EV_KEY;
-  ev_click.code = BTN_LEFT;
-  ev_click.value = 1;
-
-  // write left click event
-  write(fd, &ev_click, sizeof(ev_click));
-
-  // sync left click event
-  ev_sync.type = EV_SYN;
-  write(fd, &ev_sync, sizeof(ev_sync));
-}
-
-void mouseRightClick() {
-  struct input_event ev_click, ev_sync;
-  memset(&ev_click, 0, sizeof(ev_click));
-  memset(&ev_sync, 0, sizeof(ev_sync));
-
-  ev_click.type = EV_KEY;
-  ev_click.code = BTN_RIGHT;
-  ev_click.value = 1;
-
-  // write right click event
-  write(fd, &ev_click, sizeof(ev_click));
-
-  // sync right click event
-  ev_sync.type = EV_SYN;
-  write(fd, &ev_sync, sizeof(ev_sync));
-}
-
-void mouseSetPosition(int x, int y) {
-  struct input_event ev[2], ev_sync;
-  memset(ev, 0, sizeof(ev));
-  memset(&ev_sync, 0, sizeof(ev_sync));
-
-  ev[0].type = EV_ABS;
-  ev[0].code = ABS_X;
-  ev[0].value = x;
-  ev[1].type = EV_ABS;
-  ev[1].code = ABS_Y;
-  ev[1].value = y;
-
-  int res_w = write(fd, ev, sizeof(ev));
-
-  std::cout << "res w : " << res_w << "\n";
-
-  ev_sync.type = EV_SYN;
-  ev_sync.value = 0;
-  ev_sync.code = 0;
-  int res_ev_sync = write(fd, &ev_sync, sizeof(ev_sync));
-
-  std::cout << "res syn : " << res_ev_sync << "\n";
-}
-
-void initDisplay() { dpy = XOpenDisplay(NULL); }
-
-void destroyMouse() { ioctl(fd, UI_DEV_DESTROY); }
-
-void mouseMove(int xdelta, int ydelta) {
-  int xx, yy;
-  mouseGetPosition(xx, yy);
-
-  mouseSetPosition(xx + xdelta, yy + ydelta);
-}
-
-void mouseGetPosition(int &x, int &y) {
-  Window root, child;
-  int rootX, rootY, winX, winY;
-  unsigned int mask;
-
-  XQueryPointer(dpy, DefaultRootWindow(dpy), &root, &child, &rootX, &rootY,
-                &winX, &winY, &mask);
-
-  std::cout << "root x : " << rootX << "\n";
-  std::cout << "root y : " << rootY << "\n";
-
-  x = rootX;
-  y = rootY;
-}
-
-int main() {
-  initMouse();
-  initDisplay();
-
-  int tempx, tempy;
-
-  for (int i = 0; i < 5; ++i) {
-    mouseMove(100, 100);
-    sleep(1);
-    std::cout << "i : " << i << "\n";
-  }
-
-  destroyMouse();
-  return 0;
-}

test/screen_capture/linux_capture.cpp

@@ -1,309 +0,0 @@
-#include <stdio.h>
-
-#define __STDC_CONSTANT_MACROS
-
-#ifdef _WIN32
-// Windows
-extern "C" {
-#include <libavcodec/avcodec.h>
-#include <libavdevice/avdevice.h>
-#include <libavformat/avformat.h>
-#include <libavutil/imgutils.h>
-#include <libswscale/swscale.h>
-
-#include "SDL2/SDL.h"
-};
-#else
-// Linux...
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include <SDL2/SDL.h>
-#include <libavcodec/avcodec.h>
-#include <libavdevice/avdevice.h>
-#include <libavformat/avformat.h>
-#include <libavutil/imgutils.h>
-#include <libswscale/swscale.h>
-#ifdef __cplusplus
-};
-#endif
-#endif
-
-#include <chrono>
-
-// Output YUV420P
-#define OUTPUT_YUV420P 0
-//'1' Use Dshow
-//'0' Use GDIgrab
-#define USE_DSHOW 0
-
-// Refresh Event
-#define SFM_REFRESH_EVENT (SDL_USEREVENT + 1)
-
-#define SFM_BREAK_EVENT (SDL_USEREVENT + 2)
-
-#define NV12_BUFFER_SIZE 1280 * 720 * 3 / 2
-
-int thread_exit = 0;
-SDL_Texture *sdlTexture = nullptr;
-SDL_Renderer *sdlRenderer = nullptr;
-SDL_Rect sdlRect;
-unsigned char nv12_buffer[NV12_BUFFER_SIZE];
-std::chrono::_V2::system_clock::time_point last_frame_time;
-const int pixel_w = 1280, pixel_h = 720;
-int screen_w = 1280, screen_h = 720;
-bool done = false;
-
-int YUV420ToNV12FFmpeg(unsigned char *src_buffer, int width, int height,
-                       unsigned char *des_buffer) {
-  AVFrame *Input_pFrame = av_frame_alloc();
-  AVFrame *Output_pFrame = av_frame_alloc();
-  struct SwsContext *img_convert_ctx = sws_getContext(
-      width, height, AV_PIX_FMT_NV12, width, height, AV_PIX_FMT_YUV420P,
-      SWS_FAST_BILINEAR, nullptr, nullptr, nullptr);
-
-  av_image_fill_arrays(Input_pFrame->data, Input_pFrame->linesize, src_buffer,
-                       AV_PIX_FMT_NV12, width, height, 1);
-  av_image_fill_arrays(Output_pFrame->data, Output_pFrame->linesize, des_buffer,
-                       AV_PIX_FMT_YUV420P, width, height, 1);
-
-  sws_scale(img_convert_ctx, (uint8_t const **)Input_pFrame->data,
-            Input_pFrame->linesize, 0, height, Output_pFrame->data,
-            Output_pFrame->linesize);
-
-  if (Input_pFrame) av_free(Input_pFrame);
-  if (Output_pFrame) av_free(Output_pFrame);
-  if (img_convert_ctx) sws_freeContext(img_convert_ctx);
-
-  return 0;
-}
-
-int sfp_refresh_thread(void *opaque) {
-  thread_exit = 0;
-  while (!thread_exit) {
-    SDL_Event event;
-    event.type = SFM_REFRESH_EVENT;
-    SDL_PushEvent(&event);
-    SDL_Delay(30);
-    printf("sfp_refresh_thread\n");
-  }
-  thread_exit = 0;
-  // Break
-  SDL_Event event;
-  event.type = SFM_BREAK_EVENT;
-  SDL_PushEvent(&event);
-  printf("exit sfp_refresh_thread\n");
-
-  return 0;
-}
-
-int main(int argc, char *argv[]) {
-  AVFormatContext *pFormatCtx;
-  int i, videoindex;
-  AVCodecContext *pCodecCtx;
-  AVCodec *pCodec;
-  AVCodecParameters *pCodecParam;
-
-  // avformat_network_init();
-  pFormatCtx = avformat_alloc_context();
-
-  // Open File
-  char filepath[] = "out.h264";
-  // avformat_open_input(&pFormatCtx, filepath, NULL, NULL);
-
-  // Register Device
-  avdevice_register_all();
-  // Windows
-
-  // Linux
-  AVDictionary *options = NULL;
-  // Set some options
-  // grabbing frame rate
-  av_dict_set(&options, "framerate", "30", 0);
-  // Make the grabbed area follow the mouse
-  // av_dict_set(&options, "follow_mouse", "centered", 0);
-  // Video frame size. The default is to capture the full screen
-  av_dict_set(&options, "video_size", "1280x720", 0);
-  AVInputFormat *ifmt = (AVInputFormat *)av_find_input_format("x11grab");
-  if (!ifmt) {
-    printf("Couldn't find_input_format\n");
-  }
-
-  // Grab at position 10,20
-  if (avformat_open_input(&pFormatCtx, ":0.0", ifmt, &options) != 0) {
-    printf("Couldn't open input stream.\n");
-    return -1;
-  }
-
-  if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
-    printf("Couldn't find stream information.\n");
-    return -1;
-  }
-
-  videoindex = -1;
-  for (i = 0; i < pFormatCtx->nb_streams; i++)
-    if (pFormatCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
-      videoindex = i;
-      break;
-    }
-  if (videoindex == -1) {
-    printf("Didn't find a video stream.\n");
-    return -1;
-  }
-
-  pCodecParam = pFormatCtx->streams[videoindex]->codecpar;
-
-  pCodecCtx = avcodec_alloc_context3(NULL);
-  avcodec_parameters_to_context(pCodecCtx, pCodecParam);
-
-  pCodec = const_cast<AVCodec *>(avcodec_find_decoder(pCodecCtx->codec_id));
-  if (pCodec == NULL) {
-    printf("Codec not found.\n");
-    return -1;
-  }
-  if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0) {
-    printf("Could not open codec.\n");
-    return -1;
-  }
-  AVFrame *pFrame, *pFrameYUV, *pFrameNV12;
-  pFrame = av_frame_alloc();
-  pFrameYUV = av_frame_alloc();
-  pFrameNV12 = av_frame_alloc();
-  // unsigned char *out_buffer=(unsigned char
-  // *)av_malloc(avpicture_get_size(AV_PIX_FMT_YUV420P, pCodecCtx->width,
-  // pCodecCtx->height)); avpicture_fill((AVPicture *)pFrameYUV, out_buffer,
-  // AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height);
-  // SDL----------------------------
-  if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) {
-    printf("Could not initialize SDL - %s\n", SDL_GetError());
-    return -1;
-  }
-
-  // const SDL_VideoInfo *vi = SDL_GetVideoInfo();
-  // Half of the Desktop's width and height.
-  screen_w = 1280;
-  screen_h = 720;
-  // SDL_Surface *screen;
-  // screen = SDL_SetVideoMode(screen_w, screen_h, 0, 0);
-  SDL_Window *screen;
-  screen = SDL_CreateWindow("Linux Capture", SDL_WINDOWPOS_UNDEFINED,
-                            SDL_WINDOWPOS_UNDEFINED, screen_w, screen_h,
-                            SDL_WINDOW_RESIZABLE);
-
-  if (!screen) {
-    printf("SDL: could not set video mode - exiting:%s\n", SDL_GetError());
-    return -1;
-  }
-  // SDL_Overlay *bmp;
-  // bmp = SDL_CreateYUVOverlay(pCodecCtx->width, pCodecCtx->height,
-  //                            SDL_YV12_OVERLAY, screen);
-
-  sdlRenderer = SDL_CreateRenderer(screen, -1, SDL_RENDERER_ACCELERATED);
-
-  Uint32 pixformat = 0;
-  pixformat = SDL_PIXELFORMAT_NV12;
-
-  SDL_Texture *sdlTexture = nullptr;
-  sdlTexture = SDL_CreateTexture(sdlRenderer, pixformat,
-                                 SDL_TEXTUREACCESS_STREAMING, pixel_w, pixel_h);
-
-  SDL_Rect rect;
-  rect.x = 0;
-  rect.y = 0;
-  rect.w = screen_w;
-  rect.h = screen_h;
-  // SDL End------------------------
-  int ret, got_picture;
-
-  AVPacket *packet = (AVPacket *)av_malloc(sizeof(AVPacket));
-
-  struct SwsContext *img_convert_ctx;
-  img_convert_ctx = sws_getContext(
-      pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt, pCodecCtx->width,
-      pCodecCtx->height, AV_PIX_FMT_NV12, SWS_BICUBIC, NULL, NULL, NULL);
-  //------------------------------
-  SDL_Thread *video_tid = SDL_CreateThread(sfp_refresh_thread, NULL, NULL);
-  //
-  // SDL_WM_SetCaption("Simplest FFmpeg Grab Desktop", NULL);
-  // Event Loop
-  SDL_Event event;
-
-  last_frame_time = std::chrono::steady_clock::now();
-
-  for (;;) {
-    // Wait
-    SDL_WaitEvent(&event);
-
-    if (1) {
-      //------------------------------
-      if (av_read_frame(pFormatCtx, packet) >= 0) {
-        if (packet->stream_index == videoindex) {
-          avcodec_send_packet(pCodecCtx, packet);
-          av_packet_unref(packet);
-          got_picture = avcodec_receive_frame(pCodecCtx, pFrame);
-          // ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture,
-          // packet);
-          if (ret < 0) {
-            printf("Decode Error.\n");
-            return -1;
-          }
-          printf("xxxxxxxxxxxxxxxxxxx\n");
-          if (!got_picture) {
-            auto now_time = std::chrono::steady_clock::now();
-            std::chrono::duration<double> duration = now_time - last_frame_time;
-            auto tc = duration.count() * 1000;
-            printf("duration: %f\n", tc);
-            last_frame_time = now_time;
-
-            av_image_fill_arrays(pFrameNV12->data, pFrameNV12->linesize,
-                                 nv12_buffer, AV_PIX_FMT_NV12, pFrame->width,
-                                 pFrame->height, 1);
-
-            sws_scale(img_convert_ctx, pFrame->data, pFrame->linesize, 0,
-                      pFrame->height, pFrameNV12->data, pFrameNV12->linesize);
-
-            SDL_UpdateTexture(sdlTexture, NULL, nv12_buffer, pixel_w);
-
-            // FIX: If window is resize
-            sdlRect.x = 0;
-            sdlRect.y = 0;
-            sdlRect.w = screen_w;
-            sdlRect.h = screen_h;
-
-            SDL_RenderClear(sdlRenderer);
-            SDL_RenderCopy(sdlRenderer, sdlTexture, NULL, &sdlRect);
-            SDL_RenderPresent(sdlRenderer);
-          }
-        }
-        // av_free_packet(packet);
-      } else {
-        // Exit Thread
-        // thread_exit = 1;
-        // printf("No frame read\n");
-      }
-    } else if (event.type == SDL_QUIT) {
-      printf("SDL_QUIT\n");
-      thread_exit = 1;
-    } else if (event.type == SFM_BREAK_EVENT) {
-      break;
-    }
-  }
-
-  sws_freeContext(img_convert_ctx);
-
-#if OUTPUT_YUV420P
-  fclose(fp_yuv);
-#endif
-
-  SDL_Quit();
-
-  // av_free(out_buffer);
-  av_frame_free(&pFrameNV12);
-  av_free(pFrameYUV);
-  avcodec_close(pCodecCtx);
-  avformat_close_input(&pFormatCtx);
-
-  getchar();
-
-  return 0;
-}

test/screen_capture/mac_capture.cpp

@@ -1,286 +0,0 @@
-#include <stdio.h>
-
-#define __STDC_CONSTANT_MACROS
-
-#ifdef _WIN32
-// Windows
-extern "C" {
-#include "SDL/SDL.h"
-#include "libavcodec/avcodec.h"
-#include "libavdevice/avdevice.h"
-#include "libavformat/avformat.h"
-#include "libswscale/swscale.h"
-};
-#else
-// Linux...
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include <SDL2/SDL.h>
-#include <libavcodec/avcodec.h>
-#include <libavdevice/avdevice.h>
-#include <libavformat/avformat.h>
-#include <libswscale/swscale.h>
-#ifdef __cplusplus
-};
-#endif
-#endif
-
-// Output YUV420P
-#define OUTPUT_YUV420P 0
-//'1' Use Dshow
-//'0' Use GDIgrab
-#define USE_DSHOW 0
-
-// Refresh Event
-#define SFM_REFRESH_EVENT (SDL_USEREVENT + 1)
-
-#define SFM_BREAK_EVENT (SDL_USEREVENT + 2)
-
-int thread_exit = 0;
-
-int sfp_refresh_thread(void *opaque) {
-  thread_exit = 0;
-  while (!thread_exit) {
-    SDL_Event event;
-    event.type = SFM_REFRESH_EVENT;
-    SDL_PushEvent(&event);
-    SDL_Delay(40);
-  }
-  thread_exit = 0;
-  // Break
-  SDL_Event event;
-  event.type = SFM_BREAK_EVENT;
-  SDL_PushEvent(&event);
-
-  return 0;
-}
-
-// Show AVFoundation Device
-void show_avfoundation_device() {
-  AVFormatContext *pFormatCtx = avformat_alloc_context();
-  AVDictionary *options = NULL;
-  av_dict_set(&options, "list_devices", "true", 0);
-  AVInputFormat *iformat =
-      (AVInputFormat *)av_find_input_format("avfoundation");
-  printf("==AVFoundation Device Info===\n");
-  avformat_open_input(&pFormatCtx, "", iformat, &options);
-  printf("=============================\n");
-}
-
-int main(int argc, char *argv[]) {
-  AVFormatContext *pFormatCtx;
-  int i, videoindex;
-  AVCodecContext *pCodecCtx;
-  AVCodec *pCodec;
-
-  avformat_network_init();
-  pFormatCtx = avformat_alloc_context();
-
-  // Open File
-  // char filepath[]="src01_480x272_22.h265";
-  // avformat_open_input(&pFormatCtx,filepath,NULL,NULL)
-
-  // Register Device
-  avdevice_register_all();
-  // Windows
-#ifdef _WIN32
-#if USE_DSHOW
-  // Use dshow
-  //
-  // Need to Install screen-capture-recorder
-  // screen-capture-recorder
-  // Website: http://sourceforge.net/projects/screencapturer/
-  //
-  AVInputFormat *ifmt = av_find_input_format("dshow");
-  if (avformat_open_input(&pFormatCtx, "video=screen-capture-recorder", ifmt,
-                          NULL) != 0) {
-    printf("Couldn't open input stream.\n");
-    return -1;
-  }
-#else
-  // Use gdigrab
-  AVDictionary *options = NULL;
-  // Set some options
-  // grabbing frame rate
-  // av_dict_set(&options,"framerate","5",0);
-  // The distance from the left edge of the screen or desktop
-  // av_dict_set(&options,"offset_x","20",0);
-  // The distance from the top edge of the screen or desktop
-  // av_dict_set(&options,"offset_y","40",0);
-  // Video frame size. The default is to capture the full screen
-  // av_dict_set(&options,"video_size","640x480",0);
-  AVInputFormat *ifmt = av_find_input_format("gdigrab");
-  if (avformat_open_input(&pFormatCtx, "desktop", ifmt, &options) != 0) {
-    printf("Couldn't open input stream.\n");
-    return -1;
-  }
-
-#endif
-#elif defined linux
-  // Linux
-  AVDictionary *options = NULL;
-  // Set some options
-  // grabbing frame rate
-  // av_dict_set(&options,"framerate","5",0);
-  // Make the grabbed area follow the mouse
-  // av_dict_set(&options,"follow_mouse","centered",0);
-  // Video frame size. The default is to capture the full screen
-  // av_dict_set(&options,"video_size","640x480",0);
-  AVInputFormat *ifmt = av_find_input_format("x11grab");
-  // Grab at position 10,20
-  if (avformat_open_input(&pFormatCtx, ":0.0+10,20", ifmt, &options) != 0) {
-    printf("Couldn't open input stream.\n");
-    return -1;
-  }
-#else
-  show_avfoundation_device();
-  // Mac
-  AVInputFormat *ifmt = (AVInputFormat *)av_find_input_format("avfoundation");
-  // Avfoundation
-  //[video]:[audio]
-  if (avformat_open_input(&pFormatCtx, "1", ifmt, NULL) != 0) {
-    printf("Couldn't open input stream.\n");
-    return -1;
-  }
-#endif
-
-  if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
-    printf("Couldn't find stream information.\n");
-    return -1;
-  }
-  videoindex = -1;
-  for (i = 0; i < pFormatCtx->nb_streams; i++)
-    if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
-      videoindex = i;
-      break;
-    }
-  if (videoindex == -1) {
-    printf("Didn't find a video stream.\n");
-    return -1;
-  }
-  pCodecCtx = pFormatCtx->streams[videoindex]->codec;
-  pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
-  if (pCodec == NULL) {
-    printf("Codec not found.\n");
-    return -1;
-  }
-  if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0) {
-    printf("Could not open codec.\n");
-    return -1;
-  }
-  AVFrame *pFrame, *pFrameYUV;
-  pFrame = av_frame_alloc();
-  pFrameYUV = av_frame_alloc();
-  // unsigned char *out_buffer=(unsigned char
-  // *)av_malloc(avpicture_get_size(AV_PIX_FMT_YUV420P, pCodecCtx->width,
-  // pCodecCtx->height)); avpicture_fill((AVPicture *)pFrameYUV, out_buffer,
-  // AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height);
-  // SDL----------------------------
-  if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) {
-    printf("Could not initialize SDL - %s\n", SDL_GetError());
-    return -1;
-  }
-  int screen_w = 640, screen_h = 360;
-  const SDL_VideoInfo *vi = SDL_GetVideoInfo();
-  // Half of the Desktop's width and height.
-  screen_w = vi->current_w / 2;
-  screen_h = vi->current_h / 2;
-  SDL_Surface *screen;
-  screen = SDL_SetVideoMode(screen_w, screen_h, 0, 0);
-
-  if (!screen) {
-    printf("SDL: could not set video mode - exiting:%s\n", SDL_GetError());
-    return -1;
-  }
-  SDL_Overlay *bmp;
-  bmp = SDL_CreateYUVOverlay(pCodecCtx->width, pCodecCtx->height,
-                             SDL_YV12_OVERLAY, screen);
-  SDL_Rect rect;
-  rect.x = 0;
-  rect.y = 0;
-  rect.w = screen_w;
-  rect.h = screen_h;
-  // SDL End------------------------
-  int ret, got_picture;
-
-  AVPacket *packet = (AVPacket *)av_malloc(sizeof(AVPacket));
-
-#if OUTPUT_YUV420P
-  FILE *fp_yuv = fopen("output.yuv", "wb+");
-#endif
-
-  struct SwsContext *img_convert_ctx;
-  img_convert_ctx = sws_getContext(
-      pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt, pCodecCtx->width,
-      pCodecCtx->height, AV_PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);
-  //------------------------------
-  SDL_Thread *video_tid = SDL_CreateThread(sfp_refresh_thread, NULL);
-  //
-  SDL_WM_SetCaption("Simplest FFmpeg Grab Desktop", NULL);
-  // Event Loop
-  SDL_Event event;
-
-  for (;;) {
-    // Wait
-    SDL_WaitEvent(&event);
-    if (event.type == SFM_REFRESH_EVENT) {
-      //------------------------------
-      if (av_read_frame(pFormatCtx, packet) >= 0) {
-        if (packet->stream_index == videoindex) {
-          ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, packet);
-          if (ret < 0) {
-            printf("Decode Error.\n");
-            return -1;
-          }
-          if (got_picture) {
-            SDL_LockYUVOverlay(bmp);
-            pFrameYUV->data[0] = bmp->pixels[0];
-            pFrameYUV->data[1] = bmp->pixels[2];
-            pFrameYUV->data[2] = bmp->pixels[1];
-            pFrameYUV->linesize[0] = bmp->pitches[0];
-            pFrameYUV->linesize[1] = bmp->pitches[2];
-            pFrameYUV->linesize[2] = bmp->pitches[1];
-            sws_scale(img_convert_ctx,
-                      (const unsigned char *const *)pFrame->data,
-                      pFrame->linesize, 0, pCodecCtx->height, pFrameYUV->data,
-                      pFrameYUV->linesize);
-
-#if OUTPUT_YUV420P
-            int y_size = pCodecCtx->width * pCodecCtx->height;
-            fwrite(pFrameYUV->data[0], 1, y_size, fp_yuv);      // Y
-            fwrite(pFrameYUV->data[1], 1, y_size / 4, fp_yuv);  // U
-            fwrite(pFrameYUV->data[2], 1, y_size / 4, fp_yuv);  // V
-#endif
-            SDL_UnlockYUVOverlay(bmp);
-
-            SDL_DisplayYUVOverlay(bmp, &rect);
-          }
-        }
-        av_free_packet(packet);
-      } else {
-        // Exit Thread
-        thread_exit = 1;
-      }
-    } else if (event.type == SDL_QUIT) {
-      thread_exit = 1;
-    } else if (event.type == SFM_BREAK_EVENT) {
-      break;
-    }
-  }
-
-  sws_freeContext(img_convert_ctx);
-
-#if OUTPUT_YUV420P
-  fclose(fp_yuv);
-#endif
-
-  SDL_Quit();
-
-  // av_free(out_buffer);
-  av_free(pFrameYUV);
-  avcodec_close(pCodecCtx);
-  avformat_close_input(&pFormatCtx);
-
-  return 0;
-}

thirdparty/ffmpeg/xmake.lua

@@ -1,208 +0,0 @@
-package("ffmpeg")
-
-    set_homepage("https://www.ffmpeg.org")
-    set_description("A collection of libraries to process multimedia content such as audio, video, subtitles and related metadata.")
-    set_license("LGPL-3.0")
-
-    if is_plat("windows", "mingw") then
-        add_urls("https://www.gyan.dev/ffmpeg/builds/packages/ffmpeg-$(version)-full_build-shared.7z")
-        add_versions("5.1.2", "d9eb97b72d7cfdae4d0f7eaea59ccffb8c364d67d88018ea715d5e2e193f00e9")
-        add_versions("5.0.1", "ded28435b6f04b74f5ef5a6a13761233bce9e8e9f8ecb0eabe936fd36a778b0c")
-
-        add_configs("shared", {description = "Download shared binaries.", default = true, type = "boolean", readonly = true})
-        add_configs("vs_runtime", {description = "Set vs compiler runtime.", default = "MD", readonly = true})
-    else
-        add_urls("https://ffmpeg.org/releases/ffmpeg-$(version).tar.bz2", {alias = "home"})
-        add_urls("https://github.com/FFmpeg/FFmpeg/archive/n$(version).zip", {alias = "github"})
-        add_urls("https://git.ffmpeg.org/ffmpeg.git", "https://github.com/FFmpeg/FFmpeg.git", {alias = "git"})
-        add_versions("home:5.1.2", "39a0bcc8d98549f16c570624678246a6ac736c066cebdb409f9502e915b22f2b")
-        add_versions("home:5.1.1", "cd0e16f903421266d5ccddedf7b83b9e5754aef4b9f7a7f06ce9e4c802f0545b")
-        add_versions("home:5.0.1", "28df33d400a1c1c1b20d07a99197809a3b88ef765f5f07dc1ff067fac64c59d6")
-        add_versions("home:4.0.2", "346c51735f42c37e0712e0b3d2f6476c86ac15863e4445d9e823fe396420d056")
-        add_versions("github:5.1.2", "0c99f3609160f40946e2531804175eea16416320c4b6365ad075e390600539db")
-        add_versions("github:5.1.1", "a886fcc94792764c27c88ebe71dffbe5f0d37df8f06f01efac4833ac080c11bf")
-        add_versions("github:5.0.1", "f9c2e06cafa4381df8d5c9c9e14d85d9afcbc10c516c6a206f821997cc7f6440")
-        add_versions("github:4.0.2", "4df1ef0bf73b7148caea1270539ef7bd06607e0ea8aa2fbf1bb34062a097f026")
-        add_versions("git:5.1.2", "n5.1.2")
-        add_versions("git:5.1.1", "n5.1.1")
-        add_versions("git:5.0.1", "n5.0.1")
-        add_versions("git:4.0.2", "n4.0.2")
-
-        add_configs("gpl",              {description = "Enable GPL code", default = false, type = "boolean"})
-        add_configs("ffprobe",          {description = "Enable ffprobe program.", default = false, type = "boolean"})
-        add_configs("ffmpeg",           {description = "Enable ffmpeg program.", default = true, type = "boolean"})
-        add_configs("ffplay",           {description = "Enable ffplay program.", default = false, type = "boolean"})
-        add_configs("zlib",             {description = "Enable zlib compression library.", default = false, type = "boolean"})
-        add_configs("lzma",             {description = "Enable liblzma compression library.", default = false, type = "boolean"})
-        add_configs("bzlib",            {description = "Enable bzlib compression library.", default = false, type = "boolean"})
-        add_configs("libx264",          {description = "Enable libx264 decoder.", default = false, type = "boolean"})
-        add_configs("libx265",          {description = "Enable libx265 decoder.", default = false, type = "boolean"})
-        add_configs("iconv",            {description = "Enable libiconv library.", default = false, type = "boolean"})
-        add_configs("vaapi",            {description = "Enable vaapi library.", default = false, type = "boolean"})
-        add_configs("vdpau",            {description = "Enable vdpau library.", default = false, type = "boolean"})
-        add_configs("hardcoded-tables", {description = "Enable hardcoded tables.", default = true, type = "boolean"})
-        add_configs("asm",              {description = "Enable asm", default = false, type = "boolean"})
-        add_configs("libopenh264",      {description = "Enable libopenh264", default = false, type = "boolean"})
-        add_configs("libxcb",           {description = "Enable libxcb", default = true, type = "boolean"})
-    end
-
-    add_links("avfilter", "avdevice", "avformat", "avcodec", "swscale", "swresample", "avutil", "postproc")
-    if is_plat("macosx") then
-        add_frameworks("CoreFoundation", "Foundation", "CoreVideo", "CoreMedia", "AudioToolbox", "VideoToolbox", "Security")
-    elseif is_plat("linux") then
-        -- add_syslinks("pthread", "openh264")
-        add_syslinks("pthread")
-    end
-
-    if is_plat("linux", "macosx") then
-        add_deps("yasm")
-    end
-
-    if on_fetch then
-        on_fetch("mingw", "linux", "macosx", function (package, opt)
-            import("lib.detect.find_tool")
-            if opt.system then
-                local result
-                for _, name in ipairs({"libavcodec", "libavdevice", "libavfilter", "libavformat", "libavutil", "libpostproc", "libswresample", "libswscale"}) do
-                    local pkginfo = package:find_package("pkgconfig::" .. name, opt)
-                    if pkginfo then
-                        pkginfo.version = nil
-                        if not result then
-                            result = pkginfo
-                        else
-                            result = result .. pkginfo
-                        end
-                    else
-                        return
-                    end
-                end
-                local ffmpeg = find_tool("ffmpeg", {check = "-help", version = true, command = "-version", parse = "%d+%.?%d+%.?%d+", force = true})
-                if ffmpeg then
-                    result.version = ffmpeg.version
-                end
-                return result
-            end
-        end)
-    end
-
-    on_load("linux", "macosx", "android", function (package)
-        local configdeps = {zlib    = "zlib",
-                            bzlib   = "bzip2",
-                            lzma    = "xz",
-                            libx264 = "x264",
-                            libx265 = "x265",
-                            iconv   = "libiconv"}
-        for name, dep in pairs(configdeps) do
-            if package:config(name) then
-                package:add("deps", dep)
-            end
-        end
-        -- https://www.ffmpeg.org/platform.html#toc-Advanced-linking-configuration
-        if package:config("pic") ~= false and not package:is_plat("macosx") then
-            package:add("shflags", "-Wl,-Bsymbolic")
-            package:add("ldflags", "-Wl,-Bsymbolic")
-        end
-        if not package:config("gpl") then
-            package:set("license", "LGPL-3.0")
-        end
-    end)
-
-    on_install("windows|x64", "mingw|x86_64", function (package)
-        os.cp("bin", package:installdir())
-        os.cp("include", package:installdir())
-        os.cp("lib", package:installdir())
-        package:addenv("PATH", "bin")
-    end)
-
-    on_install("linux", "macosx", "android@linux,macosx", function (package)
-        local configs = {"--enable-version3",
-                         "--disable-doc"}
-        if package:config("gpl") then
-            table.insert(configs, "--enable-gpl")
-        end
-        if package:is_plat("macosx") and macos.version():ge("10.8") then
-            table.insert(configs, "--enable-videotoolbox")
-        end
-        for name, enabled in pairs(package:configs()) do
-            if not package:extraconf("configs", name, "builtin") then
-                if enabled then
-                    table.insert(configs, "--enable-" .. name)
-                else
-                    table.insert(configs, "--disable-" .. name)
-                end
-            end
-        end
-        if package:config("shared") then
-            table.insert(configs, "--enable-shared")
-            table.insert(configs, "--disable-static")
-        else
-            table.insert(configs, "--enable-static")
-            table.insert(configs, "--disable-shared")
-        end
-        if package:debug() then
-            table.insert(configs, "--enable-debug")
-        else
-            table.insert(configs, "--disable-debug")
-        end
-        if package:is_plat("android") then
-            import("core.base.option")
-            import("core.tool.toolchain")
-            local ndk = toolchain.load("ndk", {plat = package:plat(), arch = package:arch()})
-            local bin = ndk:bindir()
-            local ndk_sdkver = ndk:config("ndk_sdkver")
-            local arch, cpu, triple, cross_prefix
-            if package:is_arch("arm64-v8a") then
-                arch = "arm64"
-                cpu = "armv8-a"
-                triple = "aarch64-linux-android"
-                cross_prefix = path.join(bin, "aarch64-linux-android-")
-            elseif package:arch():startswith("arm") then
-                arch = "arm"
-                cpu = "armv7-a"
-                triple = "armv7a-linux-androideabi"
-                cross_prefix = path.join(bin, "arm-linux-androideabi-")
-            else
-                raise("unknown arch(%s) for android!", package:arch())
-            end
-            local sysroot  = path.join(path.directory(bin), "sysroot")
-            local cflags   = table.join(table.wrap(package:config("cxflags")), table.wrap(package:config("cflags")), table.wrap(get_config("cxflags")), get_config("cflags"))
-            local cxxflags = table.join(table.wrap(package:config("cxflags")), table.wrap(package:config("cxxflags")), table.wrap(get_config("cxflags")), get_config("cxxflags"))
-            assert(os.isdir(sysroot), "we do not support old version ndk!")
-            if package:is_arch("arm64-v8a") then
-                table.insert(cflags, "-mfpu=neon")
-                table.insert(cflags, "-mfloat-abi=soft")
-            else
-                table.insert(cflags, "-mfpu=neon")
-                table.insert(cflags, "-mfloat-abi=soft")
-            end
-            table.insert(configs, "--enable-neon")
-            table.insert(configs, "--enable-asm")
-            table.insert(configs, "--enable-jni")
-            table.insert(configs, "--target-os=android")
-            table.insert(configs, "--enable-cross-compile")
-            table.insert(configs, "--disable-avdevice")
-            table.insert(configs, "--arch=" .. arch)
-            table.insert(configs, "--cpu=" .. cpu)
-            table.insert(configs, "--cc=" .. path.join(bin, triple .. ndk_sdkver .. "-clang"))
-            table.insert(configs, "--cxx=" .. path.join(bin, triple .. ndk_sdkver .. "-clang++"))
-            table.insert(configs, "--extra-cflags=" .. table.concat(cflags, ' '))
-            table.insert(configs, "--extra-cxxflags=" .. table.concat(cxxflags, ' '))
-            table.insert(configs, "--sysroot=" .. sysroot)
-            table.insert(configs, "--cross-prefix=" .. cross_prefix)
-            table.insert(configs, "--prefix=" .. package:installdir())
-            os.vrunv("./configure", configs)
-            local argv = {"-j4"}
-            if option.get("verbose") then
-                table.insert(argv, "V=1")
-            end
-            os.vrunv("make", argv)
-            os.vrun("make install")
-        else
-            import("package.tools.autoconf").install(package, configs)
-        end
-        package:addenv("PATH", "bin")
-    end)
-
-    on_test(function (package)
-        assert(package:has_cfuncs("avformat_open_input", {includes = "libavformat/avformat.h"}))
-    end)

thirdparty/imgui/port/xmake.lua

@@ -0,0 +1,194 @@
+add_rules("mode.debug", "mode.release")
+add_rules("utils.install.cmake_importfiles")
+set_languages("cxx14")
+
+option("dx9",              {showmenu = true,  default = false})
+option("dx10",             {showmenu = true,  default = false})
+option("dx11",             {showmenu = true,  default = false})
+option("dx12",             {showmenu = true,  default = false})
+option("glfw",             {showmenu = true,  default = false})
+option("opengl2",          {showmenu = true,  default = false})
+option("opengl3",          {showmenu = true,  default = false})
+option("glad",             {showmenu = true,  default = false})
+option("sdl2",             {showmenu = true,  default = false})
+option("sdl2_renderer",    {showmenu = true,  default = false})
+option("sdl3",             {showmenu = true,  default = false})
+option("sdl3_renderer",    {showmenu = true,  default = false})
+option("sdl3_gpu",         {showmenu = true,  default = false})
+option("vulkan",           {showmenu = true,  default = false})
+option("win32",            {showmenu = true,  default = false})
+option("osx",              {showmenu = true,  default = false})
+option("wgpu",             {showmenu = true,  default = false})
+option("freetype",         {showmenu = true,  default = false})
+option("user_config",      {showmenu = true,  default = nil, type = "string"})
+option("wchar32",          {showmenu = true,  default = false})
+
+if has_config("glfw") then
+    add_requires("glfw")
+end
+
+if has_config("glad") then
+    add_requires("glad")
+end
+
+if has_config("sdl2_renderer") then
+    add_requires("libsdl2 >=2.0.17")
+elseif has_config("sdl2") then
+    add_requires("libsdl2")
+end
+if has_config("sdl3") or has_config("sdl3_renderer") or has_config("sdl3_gpu") then
+    add_requires("libsdl3")
+end
+
+if has_config("vulkan") then
+    add_requires("vulkan-headers")
+end
+
+if has_config("wgpu") then
+    add_requires("wgpu-native")
+end
+
+if has_config("freetype") then
+    add_requires("freetype")
+end
+
+target("imgui")
+    set_kind("$(kind)")
+    add_files("*.cpp", "misc/cpp/*.cpp")
+    add_headerfiles("*.h", "(misc/cpp/*.h)")
+    add_includedirs(".", "misc/cpp")
+
+    if is_kind("shared") and is_plat("windows", "mingw") then
+        add_defines("IMGUI_API=__declspec(dllexport)")
+    end
+
+    if has_config("dx9") then
+        add_files("backends/imgui_impl_dx9.cpp")
+        add_headerfiles("(backends/imgui_impl_dx9.h)")
+    end
+
+    if has_config("dx10") then
+        add_files("backends/imgui_impl_dx10.cpp")
+        add_headerfiles("(backends/imgui_impl_dx10.h)")
+    end
+
+    if has_config("dx11") then
+        add_files("backends/imgui_impl_dx11.cpp")
+        add_headerfiles("(backends/imgui_impl_dx11.h)")
+    end
+
+    if has_config("dx12") then
+        add_files("backends/imgui_impl_dx12.cpp")
+        add_headerfiles("(backends/imgui_impl_dx12.h)")
+    end
+
+    if has_config("glfw") then
+        add_files("backends/imgui_impl_glfw.cpp")
+        add_headerfiles("(backends/imgui_impl_glfw.h)")
+        add_packages("glfw")
+    end
+
+    if has_config("opengl2") then
+        add_files("backends/imgui_impl_opengl2.cpp")
+        add_headerfiles("(backends/imgui_impl_opengl2.h)")
+    end
+
+    if has_config("opengl3") then
+        add_files("backends/imgui_impl_opengl3.cpp")
+        add_headerfiles("(backends/imgui_impl_opengl3.h)")
+        if has_config("glad") then
+            add_defines("IMGUI_IMPL_OPENGL_LOADER_GLAD")
+            add_packages("glad")
+        else
+            add_headerfiles("(backends/imgui_impl_opengl3_loader.h)")
+        end
+    end
+
+    if has_config("sdl2") then
+        if os.exists("backends/imgui_impl_sdl2.cpp") then
+            add_files("backends/imgui_impl_sdl2.cpp")
+            add_headerfiles("(backends/imgui_impl_sdl2.h)")
+        else
+            add_files("backends/imgui_impl_sdl.cpp")
+            add_headerfiles("(backends/imgui_impl_sdl.h)")
+        end
+        add_packages("libsdl2")
+    end
+
+    if has_config("sdl2_renderer") then
+        if os.exists("backends/imgui_impl_sdlrenderer2.cpp") then
+            add_files("backends/imgui_impl_sdlrenderer2.cpp")
+            add_headerfiles("(backends/imgui_impl_sdlrenderer2.h)")
+        else
+            add_files("backends/imgui_impl_sdlrenderer.cpp")
+            add_headerfiles("(backends/imgui_impl_sdlrenderer.h)")
+        end
+        add_packages("libsdl2")
+    end
+
+    if has_config("sdl3") then
+        add_files("backends/imgui_impl_sdl3.cpp")
+        add_headerfiles("(backends/imgui_impl_sdl3.h)")
+        add_packages("libsdl3")
+    end
+
+    if has_config("sdl3_renderer") then
+        add_files("backends/imgui_impl_sdlrenderer3.cpp")
+        add_headerfiles("(backends/imgui_impl_sdlrenderer3.h)")
+        add_packages("libsdl3")
+    end
+
+    if has_config("sdl3_gpu") then
+        add_files("backends/imgui_impl_sdlgpu3.cpp")
+        add_headerfiles("backends/imgui_impl_sdlgpu3.h","backends/imgui_impl_sdlgpu3_shaders.h")
+        add_packages("libsdl3")
+    end
+
+    if has_config("vulkan") then
+        add_files("backends/imgui_impl_vulkan.cpp")
+        add_headerfiles("(backends/imgui_impl_vulkan.h)")
+        add_packages("vulkan-headers")
+    end
+
+    if has_config("win32") then
+        add_files("backends/imgui_impl_win32.cpp")
+        add_headerfiles("(backends/imgui_impl_win32.h)")
+    end
+
+    if has_config("osx") then
+        add_frameworks("Cocoa", "Carbon", "GameController")
+        add_files("backends/imgui_impl_osx.mm")
+        add_headerfiles("(backends/imgui_impl_osx.h)")
+    end
+
+    if has_config("wgpu") then
+        add_files("backends/imgui_impl_wgpu.cpp")
+        add_headerfiles("(backends/imgui_impl_wgpu.h)")
+        add_packages("wgpu-native")
+    end
+
+    if has_config("freetype") then
+        add_files("misc/freetype/imgui_freetype.cpp")
+        add_headerfiles("misc/freetype/imgui_freetype.h")
+        add_packages("freetype")
+        add_defines("IMGUI_ENABLE_FREETYPE")
+    end
+
+    if has_config("user_config") then
+        local user_config = get_config("user_config")
+        add_defines("IMGUI_USER_CONFIG=\"".. user_config .."\"")
+    end
+
+    if has_config("wchar32") then
+        add_defines("IMGUI_USE_WCHAR32")
+    end
+
+    after_install(function (target)
+        local config_file = path.join(target:installdir(), "include/imconfig.h")
+        if has_config("wchar32") then
+            io.gsub(config_file, "//#define IMGUI_USE_WCHAR32", "#define IMGUI_USE_WCHAR32")
+        end
+        if has_config("freetype") then
+            io.gsub(config_file, "//#define IMGUI_ENABLE_FREETYPE", "#define IMGUI_ENABLE_FREETYPE")
+        end
+    end)

thirdparty/imgui/xmake.lua

@@ -0,0 +1,227 @@
+package("imgui")
+    set_homepage("https://github.com/ocornut/imgui")
+    set_description("Bloat-free Immediate Mode Graphical User interface for C++ with minimal dependencies")
+    set_license("MIT")
+
+    add_urls("https://github.com/ocornut/imgui/archive/refs/tags/$(version).tar.gz")
+    add_urls("https://github.com/ocornut/imgui.git", {alias = "git"})
+
+    -- don't forget to add the docking versions as well
+    add_versions("v1.92.0", "42250c45df2736bcef867ae4ff404d138e5135cd36466c63143b1ea3b1c81091")
+    add_versions("v1.91.9", "3872a5f90df78fced023c1945f4466b654fd74573370b77b17742149763a7a7c")
+    add_versions("v1.91.8", "db3a2e02bfd6c269adf0968950573053d002f40bdfb9ef2e4a90bce804b0f286")
+    add_versions("v1.91.7", "2001dab4bdd7d178d8277d3b17c40aa1ff1e76e2ccac5e7ab8c6daf9756312c2")
+    add_versions("v1.91.6", "c5fbc5dcab1d46064001c3b84d7a88812985cde7e0e9ced03f5677bec1ba502a")
+    add_versions("v1.91.5", "2aa2d169c569368439e5d5667e0796d09ca5cc6432965ce082e516937d7db254")
+    add_versions("v1.91.4", "a455c28d987c78ddf56aab98ce0ff0fda791a23a2ec88ade46dd106b837f0923")
+    add_versions("v1.91.3", "29949d7b300c30565fbcd66398100235b63aa373acfee0b76853a7aeacd1be28")
+    add_versions("v1.91.2", "a3c4fd857a0a48f6edad3e25de68fa1e96d2437f1665039714d1de9ad579b8d0")
+    add_versions("v1.91.1", "2c13a8909f75222c836abc9b3f60cef31c445f3f41f95d8242118ea789d145ca")
+    add_versions("v1.91.0", "6e62c87252e6b3725ba478a1c04dc604aa0aaeec78fedcf4011f1e52548f4cc9")
+    add_versions("v1.90.9", "04943919721e874ac75a2f45e6eb6c0224395034667bf508923388afda5a50bf")
+    add_versions("v1.90.8", "f606b4fb406aa0f8dad36d4a9dd3d6f0fd39f5f0693e7468abc02d545fb505ae")
+    add_versions("v1.90.7", "872574217643d4ad7e9e6df420bb8d9e0d468fb90641c2bf50fd61745e05de99")
+    add_versions("v1.90.6", "70b4b05ac0938e82b4d5b8d59480d3e2ca63ca570dfb88c55023831f387237ad")
+    add_versions("v1.90.5", "e94b48dba7311c85ba8e3e6fe7c734d76a0eed21b2b42c5180fd5706d1562241")
+    add_versions("v1.90.4", "5d9dc738af74efa357f2a9fc39fe4a28d29ef1dfc725dd2977ccf3f3194e996e")
+    add_versions("v1.90.3", "40b302d01092c9393373b372fe07ea33ac69e9491893ebab3bf952b2c1f5fd23")
+    add_versions("v1.90.2", "452d1c11e5c4b4dfcca272915644a65f1c076498e8318b141ca75cd30470dd68")
+    add_versions("v1.90.1", "21dcc985bb2ae8fe48047c86135dbc438d6980a8f2e08babbda5be820592f282")
+    add_versions("v1.90",   "170986e6a4b83d165bfc1d33c2c5a5bc2d67e5b97176287485c51a2299249296")
+    add_versions("v1.89.9", "1acc27a778b71d859878121a3f7b287cd81c29d720893d2b2bf74455bf9d52d6")
+    add_versions("v1.89.8", "6680ccc32430009a8204291b1268b2367d964bd6d1b08a4e0358a017eb8e8c9e")
+    add_versions("v1.89.7", "115ee9e242af98a884302ac0f6ca3b2b26b1f10c660205f5e7ad9f1d1c96d269")
+    add_versions("v1.89.6", "e95d1cba1481e66386acda3e7da19cd738da86c6c2a140a48fa55046e5f6e208")
+    add_versions("v1.89.5", "eab371005c86dd029523a0c4ba757840787163740d45c1f4e5a110eb21820546")
+    add_versions("v1.89.4", "69f1e83adcab3fdd27b522f5075f407361b0d3875e3522b13d33bc2ae2c7d48c")
+    add_versions("v1.89.3", "3b665fadd5580b7ef494d5d8bb1c12b2ec53ee723034caf43332956381f5d631")
+    add_versions("v1.89",   "4038b05bd44c889cf40be999656d3871a0559916708cb52a6ae2fa6fa35c5c60")
+    add_versions("v1.88",   "9f14c788aee15b777051e48f868c5d4d959bd679fc5050e3d2a29de80d8fd32e")
+    add_versions("v1.87",   "b54ceb35bda38766e36b87c25edf7a1cd8fd2cb8c485b245aedca6fb85645a20")
+    add_versions("v1.86",   "6ba6ae8425a19bc52c5e067702c48b70e4403cd339cba02073a462730a63e825")
+    add_versions("v1.85",   "7ed49d1f4573004fa725a70642aaddd3e06bb57fcfe1c1a49ac6574a3e895a77")
+    add_versions("v1.84.2", "35cb5ca0fb42cb77604d4f908553f6ef3346ceec4fcd0189675bdfb764f62b9b")
+    add_versions("v1.84.1", "292ab54cfc328c80d63a3315a242a4785d7c1cf7689fbb3d70da39b34db071ea")
+    add_versions("v1.83",   "ccf3e54b8d1fa30dd35682fc4f50f5d2fe340b8e29e08de71287d0452d8cc3ff")
+    add_versions("v1.82",   "fefa2804bd55f3d25b134af08c0e1f86d4d059ac94cef3ee7bd21e2f194e5ce5")
+    add_versions("v1.81",   "f7c619e03a06c0f25e8f47262dbc32d61fd033d2c91796812bf0f8c94fca78fb")
+    add_versions("v1.80",   "d7e4e1c7233409018437a646680316040e6977b9a635c02da93d172baad94ce9")
+    add_versions("v1.79",   "f1908501f6dc6db8a4d572c29259847f6f882684b10488d3a8d2da31744cd0a4")
+    add_versions("v1.78",   "f70bbb17581ee2bd42fda526d9c3dc1a5165f3847ff047483d4d7980e166f9a3")
+    add_versions("v1.77",   "c0dae830025d4a1a169df97409709f40d9dfa19f8fc96b550052224cbb238fa8")
+    add_versions("v1.76",   "e482dda81330d38c87bd81597cacaa89f05e20ed2c4c4a93a64322e97565f6dc")
+    add_versions("v1.75",   "1023227fae4cf9c8032f56afcaea8902e9bfaad6d9094d6e48fb8f3903c7b866")
+
+    add_versions("git:v1.92.0-docking", "v1.92.0-docking")
+    add_versions("git:v1.91.9-docking", "v1.91.9-docking")
+    add_versions("git:v1.91.8-docking", "v1.91.8-docking")
+    add_versions("git:v1.91.7-docking", "v1.91.7-docking")
+    add_versions("git:v1.91.6-docking", "v1.91.6-docking")
+    add_versions("git:v1.91.5-docking", "v1.91.5-docking")
+    add_versions("git:v1.91.4-docking", "v1.91.4-docking")
+    add_versions("git:v1.91.3-docking", "v1.91.3-docking")
+    add_versions("git:v1.91.2-docking", "v1.91.2-docking")
+    add_versions("git:v1.91.1-docking", "v1.91.1-docking")
+    add_versions("git:v1.91.0-docking", "v1.91.0-docking")
+    add_versions("git:v1.90.9-docking", "v1.90.9-docking")
+    add_versions("git:v1.90.8-docking", "v1.90.8-docking")
+    add_versions("git:v1.90.7-docking", "v1.90.7-docking")
+    add_versions("git:v1.90.6-docking", "v1.90.6-docking")
+    add_versions("git:v1.90.5-docking", "v1.90.5-docking")
+    add_versions("git:v1.90.4-docking", "v1.90.4-docking")
+    add_versions("git:v1.90.3-docking", "v1.90.3-docking")
+    add_versions("git:v1.90.2-docking", "v1.90.2-docking")
+    add_versions("git:v1.90.1-docking", "v1.90.1-docking")
+    add_versions("git:v1.90-docking",   "v1.90-docking")
+    add_versions("git:v1.89.9-docking", "v1.89.9-docking")
+    add_versions("git:v1.89.8-docking", "v1.89.8-docking")
+    add_versions("git:v1.89.7-docking", "v1.89.7-docking")
+    add_versions("git:v1.89.6-docking", "823a1385a269d923d35b82b2f470f3ae1fa8b5a3")
+    add_versions("git:v1.89.5-docking", "0ea3b87bd63ecbf359585b7c235839146e84dedb")
+    add_versions("git:v1.89.4-docking", "9e30fb0ec1b44dc1b041db6bdd53b130b2a18509")
+    add_versions("git:v1.89.3-docking", "192196711a7d0d7c2d60454d42654cf090498a74")
+    add_versions("git:v1.89-docking",   "94e850fd6ff9eceb98fda3147e3ffd4781ad2dc7")
+    add_versions("git:v1.88-docking",   "9cd9c2eff99877a3f10a7f9c2a3a5b9c15ea36c6")
+    add_versions("git:v1.87-docking",   "1ee252772ae9c0a971d06257bb5c89f628fa696a")
+    add_versions("git:v1.85-docking",   "dc8c3618e8f8e2dada23daa1aa237626af341fd8")
+    add_versions("git:v1.83-docking",   "80b5fb51edba2fd3dea76ec3e88153e2492243d1")
+
+    -- Fix conflicting IMGUI_API definitions in v1.92.0 only (https://github.com/ocornut/imgui/pull/8729)
+    add_patches("v1.92.0", "patches/v1.92.0/fix_imgui_api.patch", "e8ca0502056acf356f83703e7190dda87fde43ed245f65f0fb55b85cd164ed83")
+    add_patches("v1.92.0-docking", "patches/v1.92.0/fix_imgui_api.patch", "e8ca0502056acf356f83703e7190dda87fde43ed245f65f0fb55b85cd164ed83")
+
+    add_configs("dx9",              {description = "Enable the dx9 backend", default = false, type = "boolean"})
+    add_configs("dx10",             {description = "Enable the dx10 backend", default = false, type = "boolean"})
+    add_configs("dx11",             {description = "Enable the dx11 backend", default = false, type = "boolean"})
+    add_configs("dx12",             {description = "Enable the dx12 backend", default = false, type = "boolean"})
+    add_configs("glfw",             {description = "Enable the glfw backend", default = false, type = "boolean"})
+    add_configs("opengl2",          {description = "Enable the opengl2 backend", default = false, type = "boolean"})
+    add_configs("opengl3",          {description = "Enable the opengl3 backend", default = false, type = "boolean"})
+    add_configs("sdl2",             {description = "Enable the sdl2 backend with sdl2_renderer", default = false, type = "boolean"})
+    add_configs("sdl2_no_renderer", {description = "Enable the sdl2 backend without sdl2_renderer", default = false, type = "boolean"})
+    add_configs("sdl2_renderer",    {description = "Enable the sdl2 renderer backend", default = false, type = "boolean"})
+    add_configs("sdl3",             {description = "Enable the sdl3 backend with sdl3_renderer", default = false, type = "boolean"})
+    add_configs("sdl3_renderer",    {description = "Enable the sdl3 renderer backend", default = false, type = "boolean"})
+    add_configs("sdl3_gpu",         {description = "Enable the sdl3 gpu backend", default = false, type = "boolean"})
+    add_configs("vulkan",           {description = "Enable the vulkan backend", default = false, type = "boolean"})
+    add_configs("win32",            {description = "Enable the win32 backend", default = false, type = "boolean"})
+    add_configs("osx",              {description = "Enable the OS X backend", default = false, type = "boolean"})
+    add_configs("wgpu",             {description = "Enable the wgpu backend", default = false, type = "boolean"})
+    add_configs("freetype",         {description = "Use FreeType to build and rasterize the font atlas", default = false, type = "boolean"})
+    add_configs("user_config",      {description = "Use user config (disables test!)", default = nil, type = "string"})
+    add_configs("wchar32",          {description = "Use 32-bit for ImWchar (default is 16-bit)", default = false, type = "boolean"})
+
+    -- deprecated configs (kept for backwards compatibility)
+    add_configs("sdlrenderer",  {description = "(deprecated)", default = false, type = "boolean"})
+    add_configs("glfw_opengl3", {description = "(deprecated)", default = false, type = "boolean"})
+    add_configs("glfw_vulkan",  {description = "(deprecated)", default = false, type = "boolean"})
+    add_configs("sdl2_opengl3", {description = "(deprecated)", default = false, type = "boolean"})
+
+    add_includedirs("include", "include/imgui", "include/backends", "include/misc/cpp")
+
+    if is_plat("windows", "mingw") then
+        add_syslinks("imm32")
+    end
+
+    on_load(function (package)
+        -- begin: backwards compatibility
+        if package:config("sdl2") or package:config("sdlrenderer") then
+            package:config_set("sdl2_renderer", true)
+        end
+        if package:config("glfw_opengl3") then
+            package:config_set("glfw", true)
+            package:config_set("opengl3", true)
+        end
+        if package:config("glfw_vulkan") then
+            package:config_set("glfw", true)
+            package:config_set("vulkan", true)
+        end
+        if package:config("sdl2_opengl3") then
+            package:config_set("sdl2", true)
+            package:config_set("opengl3", true)
+        end
+        -- end: backwards compatibility
+        if package:config("shared") and is_plat("windows", "mingw") then
+            package:add("defines", "IMGUI_API=__declspec(dllimport)")
+        end
+        if package:config("glfw") then
+            package:add("deps", "glfw")
+        end
+        if package:config("opengl3") then
+            if not package:gitref() and package:version():lt("1.84") then
+                package:add("deps", "glad")
+                package:add("defines", "IMGUI_IMPL_OPENGL_LOADER_GLAD")
+            end
+        end
+        if package:config("sdl2_no_renderer") then
+            package:add("deps", "libsdl2")
+        end
+        if package:config("sdl2_renderer") then
+            package:add("deps", "libsdl2 >=2.0.17")
+        end
+        if package:config("sdl3") or package:config("sdl3_renderer") or package:config("sdl3_gpu") then
+            package:add("deps", "libsdl3")
+        end
+        if package:config("vulkan") then
+            package:add("deps", "vulkan-headers")
+        end
+        if package:config("wgpu") then
+            package:add("deps", "wgpu-native")
+        end
+        if package:config("freetype") then
+            package:add("deps", "freetype")
+        end
+        if package:config("osx") then
+            package:add("frameworks", "Cocoa", "Carbon", "GameController")
+        end
+    end)
+
+    on_install(function (package)
+        local configs = {
+            dx9              = package:config("dx9"),
+            dx10             = package:config("dx10"),
+            dx11             = package:config("dx11"),
+            dx12             = package:config("dx12"),
+            glfw             = package:config("glfw"),
+            opengl2          = package:config("opengl2"),
+            opengl3          = package:config("opengl3"),
+            glad             = package:config("opengl3") and (not package:gitref() and package:version():lt("1.84")),
+            sdl2             = package:config("sdl2") or package:config("sdl2_no_renderer"),
+            sdl2_renderer    = package:config("sdl2_renderer"),
+            sdl3             = package:config("sdl3"),
+            sdl3_renderer    = package:config("sdl3_renderer"),
+            sdl3_gpu         = package:config("sdl3_gpu"),
+            vulkan           = package:config("vulkan"),
+            win32            = package:config("win32"),
+            osx              = package:config("osx"),
+            wgpu             = package:config("wgpu"),
+            freetype         = package:config("freetype"),
+            user_config      = package:config("user_config"),
+            wchar32          = package:config("wchar32")
+        }
+
+        os.cp(path.join(package:scriptdir(), "port", "xmake.lua"), "xmake.lua")
+        import("package.tools.xmake").install(package, configs)
+    end)
+
+    on_test(function (package)
+        if package:config("user_config") ~= nil then return end
+        local includes = {"imgui.h"}
+        local defines
+        if package:config("sdl2_renderer") or package:config("sdl2_no_renderer") then
+            table.insert(includes, "SDL.h")
+            defines = "SDL_MAIN_HANDLED"
+        end
+        assert(package:check_cxxsnippets({test = [[
+            void test() {
+                IMGUI_CHECKVERSION();
+                ImGui::CreateContext();
+                ImGuiIO& io = ImGui::GetIO();
+                ImGui::NewFrame();
+                ImGui::Text("Hello, world!");
+                ImGui::ShowDemoWindow(NULL);
+                ImGui::Render();
+                ImGui::DestroyContext();
+            }
+        ]]}, {configs = {languages = "c++14", defines = defines}, includes = includes}))
+    end)

thirdparty/xmake.lua

@@ -1,7 +1 @@
-includes("projectx")
-if is_plat("windows") then
-elseif is_plat("linux") then
-    includes("ffmpeg")
-elseif is_plat("macosx") then
-    includes("ffmpeg")
-end
+includes("minirtc")

xmake.lua

@@ -1,4 +1,4 @@
-set_project("remote_desk")
+set_project("crossdesk")
 set_license("LGPL-3.0")
 
 set_version("0.0.1")
@@ -13,39 +13,34 @@ set_encodings("utf-8")
 
 add_defines("UNICODE")
 if is_mode("debug") then
-    add_defines("REMOTE_DESK_DEBUG")
+    add_defines("DESK_PORT_DEBUG")
 end
 
 add_requires("spdlog 1.14.1", {system = false})
 add_requires("imgui v1.91.5-docking", {configs = {sdl2 = true, sdl2_renderer = true}})
-add_requires("miniaudio 0.11.21")
 add_requires("openssl3 3.3.2", {system = false})
 
+add_requires("libsdl2", {configs = {pulseaudio = true}})
+add_packages("libsdl2")
+
 if is_os("windows") then
-    add_requires("libyuv")
+    add_requires("libyuv", "miniaudio 0.11.21")
     add_links("Shell32", "windowsapp", "dwmapi", "User32", "kernel32",
         "SDL2-static", "SDL2main", "gdi32", "winmm", "setupapi", "version",
         "Imm32", "iphlpapi")
     add_cxflags("/WX")
 elseif is_os("linux") then
-    add_requires("ffmpeg 5.1.2", {system = false})
+    add_links("pulse-simple", "pulse")
+    add_requires("libyuv") 
     add_syslinks("pthread", "dl")
-    add_linkdirs("thirdparty/projectx/thirdparty/nvcodec/Lib/x64")
-    add_links("SDL2", "cuda", "nvidia-encode", "nvcuvid")
-    add_ldflags("-lavformat", "-lavdevice", "-lavfilter", "-lavcodec",
-        "-lswscale", "-lavutil", "-lswresample",
-        "-lasound", "-lxcb-shape", "-lxcb-xfixes", "-lsndio", "-lxcb", 
-        "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-ldl", "-lpthread",
-        {force = true})
+    add_links("SDL2", "asound", "X11", "Xtst", "Xrandr")
     add_cxflags("-Wno-unused-variable")   
 elseif is_os("macosx") then
-    add_requires("ffmpeg 5.1.2", {system = false})
-    add_requires("libxcb", {system = false})
-    add_packages("libxcb")
     add_links("SDL2", "SDL2main")
     add_ldflags("-Wl,-ld_classic")
     add_cxflags("-Wno-unused-variable")
-    add_frameworks("OpenGL", "IOSurface", "ScreenCaptureKit")
+    add_frameworks("OpenGL", "IOSurface", "ScreenCaptureKit", "AVFoundation", 
+        "CoreMedia", "CoreVideo", "CoreAudio", "AudioToolbox")
 end
 
 add_packages("spdlog", "imgui")
@@ -64,23 +59,27 @@ target("common")
     add_files("src/common/*.cpp")
     add_includedirs("src/common", {public = true})
 
-target("screen_capturer")
+target("path_manager")
     set_kind("object")
     add_deps("rd_log")
+    add_includedirs("src/path_manager", {public = true})
+    add_files("src/path_manager/*.cpp")
+    add_includedirs("src/path_manager", {public = true})
+
+target("screen_capturer")
+    set_kind("object")
+    add_deps("rd_log", "common")
     add_includedirs("src/screen_capturer", {public = true})
     if is_os("windows") then
         add_packages("libyuv")
         add_files("src/screen_capturer/windows/*.cpp")
         add_includedirs("src/screen_capturer/windows", {public = true})
     elseif is_os("macosx") then
-        add_packages("ffmpeg")
-        add_files("src/screen_capturer/macosx/avfoundation/*.cpp",
-        "src/screen_capturer/macosx/screen_capturer_kit/*.cpp",
-        "src/screen_capturer/macosx/screen_capturer_kit/*.mm")
-        add_includedirs("src/screen_capturer/macosx/avfoundation",
-        "src/screen_capturer/macosx/screen_capturer_kit", {public = true})
+        add_files("src/screen_capturer/macosx/*.cpp",
+        "src/screen_capturer/macosx/*.mm")
+        add_includedirs("src/screen_capturer/macosx", {public = true})
     elseif is_os("linux") then
-        add_packages("ffmpeg")
+        add_packages("libyuv")
         add_files("src/screen_capturer/linux/*.cpp")
         add_includedirs("src/screen_capturer/linux", {public = true})
     end
@@ -94,7 +93,8 @@ target("speaker_capturer")
         add_files("src/speaker_capturer/windows/*.cpp")
         add_includedirs("src/speaker_capturer/windows", {public = true})
     elseif is_os("macosx") then
-        add_files("src/speaker_capturer/macosx/*.cpp")
+        add_files("src/speaker_capturer/macosx/*.cpp",
+        "src/speaker_capturer/macosx/*.mm")
         add_includedirs("src/speaker_capturer/macosx", {public = true})
     elseif is_os("linux") then
         add_files("src/speaker_capturer/linux/*.cpp")
@@ -103,7 +103,7 @@ target("speaker_capturer")
 
 target("device_controller")
     set_kind("object")
-    add_deps("rd_log")
+    add_deps("rd_log", "common")
     add_includedirs("src/device_controller", {public = true})
     if is_os("windows") then
         add_files("src/device_controller/mouse/windows/*.cpp",
@@ -135,93 +135,20 @@ target("localization")
 target("single_window")
     set_kind("object")
     add_packages("libyuv", "openssl3")
-    add_deps("rd_log", "common", "localization", "config_center", "projectx", "screen_capturer", "speaker_capturer", "device_controller")
-    if is_os("macosx") then
-        add_packages("ffmpeg")
-    elseif is_os("linux") then
-        add_packages("ffmpeg")
-    end
+    add_deps("rd_log", "common", "localization", "config_center", "minirtc", 
+        "path_manager", "screen_capturer", "speaker_capturer", "device_controller")
     add_files("src/single_window/*.cpp")
     add_includedirs("src/single_window", {public = true})
     add_includedirs("fonts", {public = true})
 
-target("remote_desk")
+target("crossdesk")
     set_kind("binary")
     add_deps("rd_log", "common", "single_window")
     if is_os("windows") then
-        add_files("icon/app.rc")
+        add_files("icons/app.rc")
     elseif is_os("macosx") then
-        add_packages("ffmpeg")
         -- add_rules("xcode.application")
         -- add_files("Info.plist")
     elseif is_os("linux") then
-        add_packages("ffmpeg")
     end
-    add_files("src/gui/main.cpp")
-
--- target("miniaudio_capture")
---     set_kind("binary")
---     add_packages("miniaudio")
---     if is_os("windows") then
---         add_files("test/audio_capture/miniaudio.cpp")
---     end
-
--- target("screen_capturer")
---     set_kind("binary")
---     add_packages("sdl2", "imgui",  "ffmpeg", "openh264")
---     add_files("test/screen_capturer/linux_capture.cpp")
---     add_ldflags("-lavformat", "-lavdevice", "-lavfilter", "-lavcodec",
---     "-lswscale", "-lavutil", "-lswresample",
---     "-lasound", "-lxcb-shape", "-lxcb-xfixes", "-lsndio", "-lxcb", 
---     "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-lpthread", "-lSDL2", "-lopenh264",
---     "-ldl", {force = true})
-
--- target("screen_capturer")
---     set_kind("binary")
---     add_packages("sdl2", "imgui",  "ffmpeg", "openh264")
---     add_files("test/screen_capturer/mac_capture.cpp")
---     add_ldflags("-lavformat", "-lavdevice", "-lavfilter", "-lavcodec",
---     "-lswscale", "-lavutil", "-lswresample",
---     "-lasound", "-lxcb-shape", "-lxcb-xfixes", "-lsndio", "-lxcb", 
---     "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-lpthread", "-lSDL2", "-lopenh264",
---     "-ldl", {force = true})
-
--- target("audio_capture")
---     set_kind("binary")
---     add_packages("ffmpeg")
---     add_files("test/audio_capture/sdl2_audio_capture.cpp")
---     add_includedirs("test/audio_capture")
---     add_ldflags("-lavformat", "-lavdevice", "-lavfilter", "-lavcodec",
---     "-lswscale", "-lavutil", "-lswresample",
---     "-lasound", "-lxcb-shape", "-lxcb-xfixes", "-lsndio", "-lxcb", 
---     "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-lpthread", "-lSDL2", "-lopenh264",
---     "-ldl", {force = true})
---     add_links("Shlwapi", "Strmiids", "Vfw32", "Secur32", "Mfuuid")
-
--- target("play_audio")
---     set_kind("binary")
---     add_packages("ffmpeg")
---     add_files("test/audio_capture/play_loopback.cpp")
---     add_includedirs("test/audio_capture")
---     add_ldflags("-lavformat", "-lavdevice", "-lavfilter", "-lavcodec",
---     "-lswscale", "-lavutil", "-lswresample",
---     "-lasound", "-lxcb-shape", "-lxcb-xfixes", "-lsndio", "-lxcb", 
---     "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-lpthread", "-lSDL2", "-lopenh264",
---     "-ldl", {force = true})
---     add_links("Shlwapi", "Strmiids", "Vfw32", "Secur32", "Mfuuid")
-
--- target("audio_capture")
---     set_kind("binary")
---     add_packages("libopus")
---     add_files("test/audio_capture/sdl2_audio_capture.cpp")
---     add_includedirs("test/audio_capture")
---     add_ldflags("-lavformat", "-lavdevice", "-lavfilter", "-lavcodec",
---     "-lswscale", "-lavutil", "-lswresample",
---     "-lasound", "-lxcb-shape", "-lxcb-xfixes", "-lsndio", "-lxcb", 
---     "-lxcb-shm", "-lXext", "-lX11", "-lXv", "-lpthread", "-lSDL2", "-lopenh264",
---     "-ldl", {force = true})
-
--- target("mouse_control")
---     set_kind("binary")
---     add_files("test/linux_mouse_control/mouse_control.cpp")
---     add_includedirs("test/linux_mouse_control")
+    add_files("src/gui/main.cpp")