[ci] use rolling cache keys for xmake dependency caches

.gitattributes

@@ -0,0 +1,3 @@
+*.h   linguist-language=C++
+*.cpp linguist-language=C++
+*.lua linguist-language=Xmake

.github/ISSUE_TEMPLATE/问题反馈.md

@@ -0,0 +1,35 @@
+---
+name: 问题反馈
+about: 请在此提交问题报告，以便持续优化产品。
+title: ''
+labels: bug
+assignees: kunkundi
+
+---
+
+**描述问题**
+清晰简洁地描述遇到的错误。
+
+**复现步骤**
+复现该问题的步骤：
+1. 前往 '...'
+2. 点击 '....'
+3. 出现错误
+
+**预期行为**
+清晰简洁地描述你期望发生的行为。
+
+**截图**
+如果适用，请添加截图以帮助说明问题。
+
+**桌面端信息（请填写以下内容）：**
+ - 操作系统: [例如 Windows 11]
+ - 版本: [例如 v1.1.10]
+
+**移动端信息（请填写以下内容）：**
+ - 设备: [例如 iPhone 17]
+ - 操作系统: [例如 iOS 26.1]
+ - 浏览器: [例如 系统浏览器、Safari]
+
+**补充信息**
+在此添加与问题相关的其他上下文内容。

.github/ISSUE_TEMPLATE/需求建议.md

@@ -0,0 +1,28 @@
+---
+name: 需求建议
+about: 请在此提交功能需求或改进建议，以便后续迭代参考。
+title: ''
+labels: enhancement
+assignees: kunkundi
+
+---
+
+**功能/改进建议描述**
+清晰简洁地描述希望新增的功能或改进的内容。
+
+**使用场景 / 背景**
+说明该功能或改进的使用场景，以及解决后带来的价值。
+
+**预期效果**
+描述你认为最理想的功能表现或改进效果。
+
+**参考示例（可选）**
+提供类似功能截图、参考链接或其他说明，帮助更好理解需求。
+
+**优先级（可选）**
+- [ ] 高
+- [ ] 中
+- [ ] 低
+
+**补充信息（可选）**
+其他相关信息或特殊要求。

.github/workflows/build.yml

@@ -0,0 +1,397 @@
+name: Build and Release
+
+on:
+  push:
+    branches:
+      - "**"
+    tags:
+      - "*"
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+env:
+  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+jobs:
+  build-linux:
+    name: Build Linux (${{ matrix.arch }})
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      matrix:
+        include:
+          - arch: amd64
+            runner: ubuntu-22.04
+            image: crossdesk/ubuntu20.04:latest
+            package_script: ./scripts/linux/pkg_amd64.sh
+
+          - arch: arm64
+            runner: ubuntu-22.04-arm
+            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
+        run: |
+          VERSION="${GITHUB_REF##*/}"
+          VERSION_NUM="${VERSION#v}"
+          echo "VERSION_NUM=${VERSION_NUM}" >> $GITHUB_ENV
+
+      - name: Set legal Debian version
+        shell: bash
+        run: |
+          SHORT_SHA=$(echo "${GITHUB_SHA}" | cut -c1-7)
+          BUILD_DATE=$(TZ=Asia/Shanghai date +%Y%m%d)
+
+          if [[ ! "${VERSION_NUM}" =~ ^[0-9] ]]; then
+            LEGAL_VERSION="v0.0.0-${VERSION_NUM}-${BUILD_DATE}-${SHORT_SHA}"
+          else
+            LEGAL_VERSION="v${VERSION_NUM}-${BUILD_DATE}-${SHORT_SHA}"
+          fi
+
+          echo "LEGAL_VERSION=${LEGAL_VERSION}" >> $GITHUB_ENV
+          echo "BUILD_DATE=${BUILD_DATE}" >> $GITHUB_ENV
+
+      - name: Checkout code
+        uses: actions/checkout@v5
+        with:
+          submodules: recursive
+
+      - name: Build CrossDesk
+        env:
+          CUDA_PATH: /usr/local/cuda
+          XMAKE_GLOBALDIR: /data
+        run: |
+          xmake f --CROSSDESK_VERSION=${LEGAL_VERSION} --USE_CUDA=true --root -y
+          xmake b -vy --root crossdesk
+
+      - name: Package
+        run: |
+          chmod +x ${{ matrix.package_script }}
+          ${{ matrix.package_script }} ${LEGAL_VERSION}
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v6
+        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: x64
+            runner: macos-15-intel
+            cache-key: intel
+            out-dir: ./build/macosx/x86_64/release/crossdesk
+            package_script: ./scripts/macosx/pkg_x64.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##*/}"
+          SHORT_SHA=$(echo "${GITHUB_SHA}" | cut -c1-7)
+          BUILD_DATE=$(TZ=Asia/Shanghai date +%Y%m%d)
+          VERSION_NUM="v${VERSION#v}-${BUILD_DATE}-${SHORT_SHA}"
+          echo "VERSION_NUM=${VERSION_NUM}" >> $GITHUB_ENV
+          echo "VERSION_NUM=${VERSION_NUM}"
+          echo "BUILD_DATE=${BUILD_DATE}" >> $GITHUB_ENV
+
+      - name: Cache xmake dependencies
+        uses: actions/cache@v5
+        with:
+          path: ~/.xmake/packages
+          key: "${{ runner.os }}-xmake-deps-${{ matrix.cache-key }}-${{ github.run_id }}"
+          restore-keys: |
+            ${{ runner.os }}-xmake-deps-${{ matrix.cache-key }}-
+
+      - name: Install xmake
+        run: brew install xmake
+
+      - name: Checkout code
+        uses: actions/checkout@v5
+
+      - name: Initialize submodules
+        run: git submodule update --init --recursive
+
+      - name: Build CrossDesk
+        run: |
+          xmake f --CROSSDESK_VERSION=${VERSION_NUM} --USE_CUDA=true -y
+          xmake b -vy crossdesk
+
+      - name: Package CrossDesk app
+        run: |
+          chmod +x ${{ matrix.package_script }}
+          ${{ matrix.package_script }} ${VERSION_NUM}
+
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v6
+        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-x64:
+    name: Build on Windows x64
+    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 '/', '-'
+          $SHORT_SHA = $env:GITHUB_SHA.Substring(0,7)
+          $BUILD_DATE = ([System.TimeZoneInfo]::ConvertTimeBySystemTimeZoneId((Get-Date), "China Standard Time")).ToString("yyyyMMdd")
+          echo "VERSION_NUM=v$version-$BUILD_DATE-$SHORT_SHA" >> $env:GITHUB_ENV
+          echo "BUILD_DATE=$BUILD_DATE" >> $env:GITHUB_ENV
+
+      - name: Cache xmake dependencies
+        uses: actions/cache@v5
+        with:
+          path: D:\xmake_global\.xmake\packages
+          key: "${{ runner.os }}-xmake-deps-intel-${{ github.run_id }}"
+          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: Download INetC plugin
+        shell: powershell
+        run: |
+          $url = "https://github.com/DigitalMediaServer/NSIS-INetC-plugin/releases/download/v1.0.5.7/InetC.zip"
+          $out = "$env:RUNNER_TEMP\InetC.zip"
+          Invoke-WebRequest -Uri $url -OutFile $out
+          Expand-Archive $out -DestinationPath "$env:RUNNER_TEMP\InetC" -Force
+
+          $source = "$env:RUNNER_TEMP\InetC\x86-unicode\INetC.dll"
+          $target = "C:\Program Files (x86)\NSIS\Plugins\x86-unicode\INetC.dll"
+
+          Write-Host "Copying $source to $target"
+          Copy-Item $source $target -Force
+
+      - name: Checkout code
+        uses: actions/checkout@v5
+
+      - name: Initialize submodules
+        run: git submodule update --init --recursive
+
+      - name: Copy nsProcess plugin to NSIS folder
+        run: |
+          $nsisPluginDir = "C:\Program Files (x86)\NSIS\Plugins\x86-unicode"
+          copy "${{ github.workspace }}\scripts\windows\nsProcess.dll" $nsisPluginDir
+
+      - name: Build CrossDesk
+        run: |
+          xmake f --CROSSDESK_VERSION=${{ env.VERSION_NUM }} --USE_CUDA=true -y
+          xmake b -vy crossdesk
+
+      - name: Package
+        shell: pwsh
+        run: |
+          cd "${{ github.workspace }}\scripts\windows"
+          makensis /DVERSION=$env:VERSION_NUM nsis_script.nsi
+
+      - name: Package Portable
+        shell: pwsh
+        run: |
+          $portableDir = "${{ github.workspace }}\portable"
+          New-Item -ItemType Directory -Force -Path $portableDir
+          Copy-Item "${{ github.workspace }}\build\windows\x64\release\crossdesk.exe" "$portableDir\CrossDesk.exe"
+          Copy-Item "${{ github.workspace }}\build\windows\x64\release\*.dll" $portableDir -Force
+          Compress-Archive -Path "$portableDir\*" -DestinationPath "${{ github.workspace }}\crossdesk-win-x64-portable-${{ env.VERSION_NUM }}.zip"
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v6
+        with:
+          name: crossdesk-win-x64-${{ env.VERSION_NUM }}
+          path: ${{ github.workspace }}/scripts/windows/crossdesk-win-x64-${{ env.VERSION_NUM }}.exe
+
+      - name: Upload portable artifact
+        uses: actions/upload-artifact@v6
+        with:
+          name: crossdesk-win-x64-portable-${{ env.VERSION_NUM }}
+          path: ${{ github.workspace }}/crossdesk-win-x64-portable-${{ env.VERSION_NUM }}.zip
+
+  release:
+    name: Publish Release
+    if: startsWith(github.ref, 'refs/tags/v')
+    needs:
+      [build-linux, build-macos, build-windows-x64]
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v5
+
+      - name: Download all artifacts
+        uses: actions/download-artifact@v8
+        with:
+          path: artifacts
+
+      - name: Extract version number
+        id: version
+        run: |
+          VERSION="${GITHUB_REF##*/}"
+          SHORT_SHA=$(echo "${GITHUB_SHA}" | cut -c1-7)
+          BUILD_DATE=$(TZ=Asia/Shanghai date +%Y%m%d)
+          BUILD_DATE_ISO=$(TZ=Asia/Shanghai date +%Y-%m-%d)
+          VERSION_NUM="${VERSION#v}-${BUILD_DATE}-${SHORT_SHA}"
+          VERSION_WITH_V="v${VERSION_NUM}"
+          VERSION_ONLY="${VERSION#v}"
+          echo "VERSION_NUM=${VERSION_NUM}" >> $GITHUB_OUTPUT
+          echo "VERSION_WITH_V=${VERSION_WITH_V}" >> $GITHUB_OUTPUT
+          echo "VERSION_ONLY=${VERSION_ONLY}" >> $GITHUB_OUTPUT
+          echo "BUILD_DATE=${BUILD_DATE}" >> $GITHUB_OUTPUT
+          echo "BUILD_DATE_ISO=${BUILD_DATE_ISO}" >> $GITHUB_OUTPUT
+
+      - name: Rename artifacts
+        run: |
+          mkdir -p release
+          cp artifacts/crossdesk-macos-x64-${{ steps.version.outputs.VERSION_WITH_V }}/* release/crossdesk-macos-x64-${{ steps.version.outputs.VERSION_WITH_V }}.pkg
+          cp artifacts/crossdesk-macos-arm64-${{ steps.version.outputs.VERSION_WITH_V }}/* release/crossdesk-macos-arm64-${{ steps.version.outputs.VERSION_WITH_V }}.pkg
+          cp artifacts/crossdesk-linux-amd64-${{ steps.version.outputs.VERSION_WITH_V }}/* release/crossdesk-linux-amd64-${{ steps.version.outputs.VERSION_WITH_V }}.deb
+          cp artifacts/crossdesk-linux-arm64-${{ steps.version.outputs.VERSION_WITH_V }}/* release/crossdesk-linux-arm64-${{ steps.version.outputs.VERSION_WITH_V }}.deb
+          cp artifacts/crossdesk-win-x64-${{ steps.version.outputs.VERSION_WITH_V }}/* release/crossdesk-win-x64-${{ steps.version.outputs.VERSION_WITH_V }}.exe
+          cp artifacts/crossdesk-win-x64-portable-${{ steps.version.outputs.VERSION_WITH_V }}/* release/crossdesk-win-x64-portable-${{ steps.version.outputs.VERSION_WITH_V }}.zip
+
+      - name: List release files
+        run: ls -lh release/
+
+      - name: Upload to Versioned GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ steps.version.outputs.VERSION_WITH_V }}
+          name: Release ${{ steps.version.outputs.VERSION_WITH_V }}
+          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
+
+      - name: Upload artifacts to server
+        uses: burnett01/rsync-deployments@5.2
+        with:
+          switches: -avzr --progress --delete
+          path: release/*
+          remote_path: /var/www/html/downloads/
+          remote_host: ${{ secrets.SERVER_HOST }}
+          remote_user: ${{ secrets.SERVER_USER }}
+          remote_key: ${{ secrets.SERVER_KEY }}
+
+      - name: Generate version.json
+        run: |
+          cat > version.json << EOF
+          {
+            "version": "${{ steps.version.outputs.VERSION_ONLY }}",
+            "releaseDate": "${{ steps.version.outputs.BUILD_DATE_ISO }}",
+            "releaseName": "",
+            "releaseNotes": "",
+            "tagName": "${{ steps.version.outputs.VERSION_WITH_V }}",
+            "downloads": {
+              "windows-x64": {
+                "url": "https://downloads.crossdesk.cn/crossdesk-win-x64-${{ steps.version.outputs.VERSION_WITH_V }}.exe",
+                "filename": "crossdesk-win-x64-${{ steps.version.outputs.VERSION_WITH_V }}.exe"
+              },
+              "windows-x64-portable": {
+                "url": "https://downloads.crossdesk.cn/crossdesk-win-x64-portable-${{ steps.version.outputs.VERSION_WITH_V }}.zip",
+                "filename": "crossdesk-win-x64-portable-${{ steps.version.outputs.VERSION_WITH_V }}.zip"
+              },
+              "macos-x64": {
+                "url": "https://downloads.crossdesk.cn/crossdesk-macos-x64-${{ steps.version.outputs.VERSION_WITH_V }}.pkg",
+                "filename": "crossdesk-macos-x64-${{ steps.version.outputs.VERSION_WITH_V }}.pkg"
+              },
+              "macos-arm64": {
+                "url": "https://downloads.crossdesk.cn/crossdesk-macos-arm64-${{ steps.version.outputs.VERSION_WITH_V }}.pkg",
+                "filename": "crossdesk-macos-arm64-${{ steps.version.outputs.VERSION_WITH_V }}.pkg"
+              },
+              "linux-amd64": {
+                "url": "https://downloads.crossdesk.cn/crossdesk-linux-amd64-${{ steps.version.outputs.VERSION_WITH_V }}.deb",
+                "filename": "crossdesk-linux-amd64-${{ steps.version.outputs.VERSION_WITH_V }}.deb"
+              },
+              "linux-arm64": {
+                "url": "https://downloads.crossdesk.cn/crossdesk-linux-arm64-${{ steps.version.outputs.VERSION_WITH_V }}.deb",
+                "filename": "crossdesk-linux-arm64-${{ steps.version.outputs.VERSION_WITH_V }}.deb"
+              }
+            }
+          }
+          EOF
+          cat version.json
+
+      - name: Upload version.json to server
+        uses: burnett01/rsync-deployments@5.2
+        with:
+          switches: -avzr --delete
+          path: version.json
+          remote_path: /var/www/html/version/
+          remote_host: ${{ secrets.SERVER_HOST }}
+          remote_user: ${{ secrets.SERVER_USER }}
+          remote_key: ${{ secrets.SERVER_KEY }}

.github/workflows/close-issue.yml

@@ -0,0 +1,80 @@
+name: Close Inactive Issues
+
+on:
+  schedule:
+    # run every day at midnight
+    - cron: "0 0 * * *"
+
+permissions:
+  issues: write
+  pull-requests: write
+  contents: read
+
+jobs:
+  close_inactive_issues:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check inactive issues and close them
+        uses: actions/github-script@v6
+        with:
+          script: |
+            const { data: issues } = await github.rest.issues.listForRepo({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              state: 'open',
+              per_page: 100,
+            });
+
+            const now = new Date().getTime();
+            const inactivePeriod = 7 * 24 * 60 * 60 * 1000; // 7 days
+
+            for (const issue of issues) {
+              // skip pull requests (they are also returned by listForRepo)
+              if (issue.pull_request) continue;
+
+              // skip labeled issues
+              if (issue.labels.length > 0) {
+                console.log(`Skipping issue #${issue.number} (Has labels).`);
+                continue;
+              }
+
+              // fetch comments for this issue
+              const { data: comments } = await github.rest.issues.listComments({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issue.number,
+                per_page: 100,
+              });
+
+              // determine the "last activity" time
+              let lastActivityTime;
+              if (comments.length > 0) {
+                const lastComment = comments[comments.length - 1];
+                lastActivityTime = new Date(lastComment.updated_at).getTime();
+              } else {
+                lastActivityTime = new Date(issue.created_at).getTime();
+              }
+
+              // check inactivity
+              if (now - lastActivityTime > inactivePeriod) {
+                console.log(`Closing inactive issue: #${issue.number} (No recent replies for 7 days)`);
+
+                await github.rest.issues.createComment({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: issue.number,
+                  body: "This issue has been automatically closed due to inactivity for 7 days."
+                });
+
+                await github.rest.issues.update({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: issue.number,
+                  state: 'closed',
+                });
+              } else {
+                console.log(`Skipping issue #${issue.number} (Active within 7 days).`);
+              }
+            }
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/update-version-json.yml

@@ -0,0 +1,144 @@
+name: Update version.json from Release
+
+on:
+  release:
+    types: [published, edited]
+
+permissions:
+  contents: write
+
+jobs:
+  update-version-json:
+    name: Update version.json with release information
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract version from tag
+        id: version
+        run: |
+          TAG_NAME="${{ github.event.release.tag_name }}"
+          VERSION_ONLY="${TAG_NAME#v}"
+          echo "TAG_NAME=${TAG_NAME}" >> $GITHUB_OUTPUT
+          echo "VERSION_ONLY=${VERSION_ONLY}" >> $GITHUB_OUTPUT
+
+          # Extract date from tag if available (format: v1.2.3-20251113-abc)
+          if [[ "${TAG_NAME}" =~ -([0-9]{8})- ]]; then
+            DATE_STR="${BASH_REMATCH[1]}"
+            BUILD_DATE_ISO="${DATE_STR:0:4}-${DATE_STR:4:2}-${DATE_STR:6:2}"
+          else
+            # Use release published date
+            BUILD_DATE_ISO=$(echo "${{ github.event.release.published_at }}" | cut -d'T' -f1)
+          fi
+          echo "BUILD_DATE_ISO=${BUILD_DATE_ISO}" >> $GITHUB_OUTPUT
+
+      - name: Install jq
+        run: sudo apt-get update && sudo apt-get install -y jq
+
+      - name: Get release information
+        id: release_info
+        run: |
+          # Use jq to properly escape JSON
+          RELEASE_BODY="${{ github.event.release.body }}"
+          RELEASE_NAME="${{ github.event.release.name }}"
+
+          # Handle empty values
+          if [ -z "$RELEASE_BODY" ]; then
+            RELEASE_BODY=""
+          fi
+          if [ -z "$RELEASE_NAME" ]; then
+            RELEASE_NAME=""
+          fi
+
+          # Save to temporary files for proper handling
+          echo -n "$RELEASE_BODY" > /tmp/release_body.txt
+          echo -n "$RELEASE_NAME" > /tmp/release_name.txt
+
+          # Use jq to escape JSON strings
+          RELEASE_BODY_JSON=$(jq -Rs . < /tmp/release_body.txt)
+          RELEASE_NAME_JSON=$(jq -Rs . < /tmp/release_name.txt)
+
+          echo "RELEASE_BODY=${RELEASE_BODY_JSON}" >> $GITHUB_OUTPUT
+          echo "RELEASE_NAME=${RELEASE_NAME_JSON}" >> $GITHUB_OUTPUT
+
+      - name: Download current version.json from server
+        id: download_version
+        continue-on-error: true
+        run: |
+          # Try to download current version.json from server
+          curl -f -s "https://version.crossdesk.cn/version.json" -o version.json || echo "Failed to download, will create new one"
+
+      - name: Generate or update version.json
+        run: |
+          # If version.json exists, try to preserve downloads section
+          if [ -f version.json ] && jq -e '.downloads' version.json > /dev/null 2>&1; then
+            EXISTING_DOWNLOADS=$(jq -c '.downloads' version.json)
+            if [ "$EXISTING_DOWNLOADS" != "null" ] && [ "$EXISTING_DOWNLOADS" != "{}" ]; then
+              DOWNLOADS_JSON="$EXISTING_DOWNLOADS"
+            else
+              DOWNLOADS_JSON=""
+            fi
+          else
+            DOWNLOADS_JSON=""
+          fi
+
+          # If downloads is empty, use default structure
+          if [ -z "$DOWNLOADS_JSON" ]; then
+            DOWNLOADS_JSON=$(cat << DOWNLOADS_EOF
+            {
+              "windows-x64": {
+                "url": "https://downloads.crossdesk.cn/crossdesk-win-x64-${{ steps.version.outputs.TAG_NAME }}.exe",
+                "filename": "crossdesk-win-x64-${{ steps.version.outputs.TAG_NAME }}.exe"
+              },
+              "windows-x64-portable": {
+                "url": "https://downloads.crossdesk.cn/crossdesk-win-x64-portable-${{ steps.version.outputs.TAG_NAME }}.zip",
+                "filename": "crossdesk-win-x64-portable-${{ steps.version.outputs.TAG_NAME }}.zip"
+              },
+              "macos-x64": {
+                "url": "https://downloads.crossdesk.cn/crossdesk-macos-x64-${{ steps.version.outputs.TAG_NAME }}.pkg",
+                "filename": "crossdesk-macos-x64-${{ steps.version.outputs.TAG_NAME }}.pkg"
+              },
+              "macos-arm64": {
+                "url": "https://downloads.crossdesk.cn/crossdesk-macos-arm64-${{ steps.version.outputs.TAG_NAME }}.pkg",
+                "filename": "crossdesk-macos-arm64-${{ steps.version.outputs.TAG_NAME }}.pkg"
+              },
+              "linux-amd64": {
+                "url": "https://downloads.crossdesk.cn/crossdesk-linux-amd64-${{ steps.version.outputs.TAG_NAME }}.deb",
+                "filename": "crossdesk-linux-amd64-${{ steps.version.outputs.TAG_NAME }}.deb"
+              },
+              "linux-arm64": {
+                "url": "https://downloads.crossdesk.cn/crossdesk-linux-arm64-${{ steps.version.outputs.TAG_NAME }}.deb",
+                "filename": "crossdesk-linux-arm64-${{ steps.version.outputs.TAG_NAME }}.deb"
+              }
+            }
+          DOWNLOADS_EOF
+                      )
+                    fi
+
+          # Generate version.json using cat and heredoc
+          cat > version.json << EOF
+          {
+            "version": "${{ steps.version.outputs.VERSION_ONLY }}",
+            "releaseDate": "${{ steps.version.outputs.BUILD_DATE_ISO }}",
+            "releaseName": ${{ steps.release_info.outputs.RELEASE_NAME }},
+            "releaseNotes": ${{ steps.release_info.outputs.RELEASE_BODY }},
+            "tagName": "${{ steps.version.outputs.TAG_NAME }}",
+            "downloads": ${DOWNLOADS_JSON}
+          }
+          EOF
+
+          cat version.json
+
+      - name: Upload version.json to server
+        uses: burnett01/rsync-deployments@5.2
+        with:
+          switches: -avzr --delete
+          path: version.json
+          remote_path: /var/www/html/version/
+          remote_host: ${{ secrets.SERVER_HOST }}
+          remote_user: ${{ secrets.SERVER_USER }}
+          remote_key: ${{ secrets.SERVER_KEY }}

.gitignore

@@ -1,12 +1,9 @@
 # Xmake cache
 .xmake/
 build/
-thirdparty/ffmpeg/lib/*
-.VSCodeCounter/
 
 # MacOS Cache
 .DS_Store
 
 # VSCode cache
-.vscode
-projectx.code-workspace
+.vscode

.gitmodules

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

LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

README.md

@@ -1,34 +1,264 @@
-# projectx
+# CrossDesk
 
-vcpkg/buildtrees/versioning_/versions/pcre/69e232f12c4e3eab4115f0672466a6661978bea2$ vim portfile.cmake
+<a href="https://hellogithub.com/repository/kunkundi/crossdesk" target="_blank"><img src="https://api.hellogithub.com/v1/widgets/recommend.svg?rid=55d41367570345f1838e02fd12be7961&claim_uid=cb0OpZRrBuGVAfL&theme=small" alt="Featured｜HelloGitHub" /></a>
+[![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux%20%7C%20macOS-brightgreen.svg)]()
+[![License: LGPL v3](https://img.shields.io/badge/License-LGPL%20v3-blue.svg)](https://www.gnu.org/licenses/lgpl-3.0)
+[![GitHub last commit](https://img.shields.io/github/last-commit/kunkundi/crossdesk)](https://github.com/kunkundi/crossdesk/commits/web-client)
+[![Build Status](https://github.com/kunkundi/crossdesk/actions/workflows/build.yml/badge.svg)](https://github.com/kunkundi/crossdesk/actions)  
+[![Docker Pulls](https://img.shields.io/docker/pulls/crossdesk/crossdesk-server)](https://hub.docker.com/r/crossdesk/crossdesk-server/tags)
+[![GitHub issues](https://img.shields.io/github/issues/kunkundi/crossdesk.svg)]()
+[![GitHub stars](https://img.shields.io/github/stars/kunkundi/crossdesk.svg?style=social)]()
+[![GitHub forks](https://img.shields.io/github/forks/kunkundi/crossdesk.svg?style=social)]()
 
--    URLS "https://ftp.pcre.org/pub/pcre/pcre-${PCRE_VERSION}.zip"
-+    URLS "https://sourceforge.net/projects/pcre/files/pcre/${PCRE_VERSION}/pcre-${PCRE_VERSION}.zip"
+[ [English](README_EN.md) / 中文 ]
 
-linux
+PC 客户端
+![sup_example](https://github.com/user-attachments/assets/eeb64fbe-1f07-4626-be1c-b77396beb905)
 
-sudo apt-get install nvidia-cuda-toolkit
-solve <cuda.h>
+Web 客户端
+<p align="center">
+  <img width="850" height="550" alt="6bddcbed47ffd4b9988a4037c7f4f524" src="https://github.com/user-attachments/assets/e44f73f9-24ac-46a3-a189-b7f8b6669881" />
+</p>
 
-sudo apt-get install libxcb-randr0-dev libxcb-xtest0-dev libxcb-xinerama0-dev libxcb-shape0-dev libxcb-xkb-dev libxcb-xfixes0-dev libxv-dev
-solve x11
+## 简介
 
-sudo apt-get -y install libasound2-dev libsndio-dev libxcb-shm0-dev
-solve asound sndio xcb-shm
+CrossDesk 是一个轻量级的跨平台远程桌面软件，支持 Web 端控制远程设备。
 
-sudo apt-get -y install libasound2-dev libpulse-dev && rebuild
-solve error dsp no such audio device
+CrossDesk 是 [MiniRTC](https://github.com/kunkundi/minirtc.git) 实时音视频传输库的实验性应用。MiniRTC 是一个轻量级的跨平台实时音视频传输库。它具有网络透传（[RFC5245](https://datatracker.ietf.org/doc/html/rfc5245)），视频软硬编解码（H264/AV1），音频编解码（[Opus](https://github.com/xiph/opus)），信令交互，网络拥塞控制，传输加密（[SRTP](https://tools.ietf.org/html/rfc3711)）等基础能力。
 
-sudo apt-get install libavcodec-dev libavformat-dev libavutil-dev libavfilter-dev libavdevice-dev
+## 系统要求
 
-sudo apt remove libssl-dev libglib2.0-dev
+| 平台 | 最低版本 |
+|----------------|---------------------------|
+| **Windows** | Windows 10 及以上 (64 位) |
+| **macOS** | macOS Intel 15.0 及以上 ( 大于 14.0 小于 15.0 的版本可自行编译实现兼容 )<br> macOS Apple Silicon 14.0 及以上 |
+| **Linux** | Ubuntu 22.04 及以上 ( 低版本可自行编译实现兼容 ) |
 
-install:
-	@echo hello world
-	install -D build/linux/x86_64/release/remote_desk -t /usr/bin
-	install -D config/config.ini -t /usr/bin
-	install -D build/linux/x86_64/release/libprojectx.so -t /usr/lib
-	install -D thirdparty/nvcodec/Lib/x64/libnvidia-encode.so.1 -t /usr/lib
-	install -D thirdparty/nvcodec/Lib/x64/libnvidia-encode.so -t /usr/lib
-	install -D thirdparty/nvcodec/Lib/x64/libnvcuvid.so.1 -t /usr/lib
-	install -D thirdparty/nvcodec/Lib/x64/libnvcuvid.so -t /usr/lib
+## 使用
+
+在菜单栏“对端ID”处输入远端桌面的ID，点击“→”即可发起远程连接。
+
+![usage1](https://github.com/user-attachments/assets/3a4bb59f-c84c-44d2-9a20-11790aac510e)
+
+如果远端桌面设置了连接密码，则本端需填写正确的连接密码才能成功发起远程连接。
+
+![password](https://github.com/user-attachments/assets/1beadcce-640d-4f5c-8e77-51917b5294d5)
+
+发起连接前，可在设置中自定义配置项，如语言、视频编码格式等。
+![settings](https://github.com/user-attachments/assets/8bc5468d-7bbb-4e30-95bd-da1f352ac08c)
+
+### Web 客户端
+浏览器访问 [CrossDesk Web Client](https://web.crossdesk.cn/)。
+输入 **远程设备 ID** 与 **密码**，点击连接即可接入远程设备。如图，**iOS Safari 远程控制 Win11**：
+
+<img width="645" height="300" alt="_cgi-bin_mmwebwx-bin_webwxgetmsgimg__ MsgID=932911462648581698 skey=@crypt_1f5153b1_b550ca7462b5009ce03c991cca2a92a7 mmweb_appid=wx_webfilehelper" src="https://github.com/user-attachments/assets/a5109e6f-752c-4654-9f4e-7e161bddf43e" />
+
+## 如何编译
+
+依赖：
+- [xmake](https://xmake.io/#/guide/installation)
+- [cmake](https://cmake.org/download/)
+
+Linux环境下需安装以下包：
+
+```
+sudo apt-get install -y software-properties-common git curl unzip build-essential libx11-dev libxrandr-dev libxinerama-dev libxcursor-dev libxi-dev libxcb-randr0-dev libxcb-xtest0-dev libxcb-xinerama0-dev libxcb-shape0-dev libxcb-xkb-dev libxcb-xfixes0-dev libxfixes-dev libxv-dev libxtst-dev libasound2-dev libsndio-dev libxcb-shm0-dev libasound2-dev libpulse-dev
+```
+
+编译
+```
+git clone https://github.com/kunkundi/crossdesk.git
+
+cd crossdesk
+
+git submodule init 
+
+git submodule update
+
+xmake b -vy crossdesk
+```
+编译选项
+```
+--USE_CUDA=true/false: 启用 CUDA 硬件编解码，默认不启用
+--CROSSDESK_VERSION=xxx: 指定 CrossDesk 的版本
+
+# 示例
+xmake f --CROSSDESK_VERSION=1.0.0 --USE_CUDA=true
+```
+运行
+```
+xmake r crossdesk
+```
+
+### 无 CUDA 环境下的开发支持
+
+对于**未安装 CUDA 环境的 Linux 开发者，如果希望编译后的成果物拥有硬件编解码能力**，这里提供了预配置的 [Ubuntu 22.04 Docker 镜像](https://hub.docker.com/r/crossdesk/ubuntu22.04)。该镜像内置必要的构建依赖，可在容器中开箱即用，无需额外配置即可直接编译项目。
+
+进入容器，下载工程后执行：
+```
+export CUDA_PATH=/usr/local/cuda
+export XMAKE_GLOBALDIR=/data
+
+xmake f --USE_CUDA=true
+xmake b --root -vy crossdesk
+```
+
+对于**未安装 CUDA 环境的 Windows 开发者**，执行下面的命令安装 CUDA 编译环境：
+```
+xmake require -vy "cuda 12.6.3"
+```
+安装完成后执行:
+```
+xmake require --info "cuda 12.6.3"
+```
+输出如下:
+
+<img width="860" height="226" alt="Image" src="https://github.com/user-attachments/assets/999ac365-581a-4b9a-806e-05eb3e4cf44d" />
+
+根据上述输出获取到 CUDA 的安装目录，即 installdir 指向的位置。将 CUDA_PATH 加入系统环境变量，或在终端中输入：
+```
+set CUDA_PATH=path_to_cuda_installdir
+```
+重新执行：
+```
+xmake f --USE_CUDA=true
+xmake b -vy crossdesk
+```
+
+#### 注意
+运行时如果客户端状态栏显示 **未连接服务器**，请先在 [CrossDesk 官方网站](https://www.crossdesk.cn/) 安装客户端，以便在环境中安装所需的证书文件。
+
+<img width="256" height="120" alt="image" src="https://github.com/user-attachments/assets/1812f7d6-516b-4b4f-8a3d-98bee505cc5a" />
+
+## 关于 Xmake
+
+#### 安装 Xmake
+使用 curl：
+```
+curl -fsSL https://xmake.io/shget.text | bash
+```
+使用 wget：
+```
+wget https://xmake.io/shget.text -O - | bash
+```
+使用 powershell：
+```
+irm https://xmake.io/psget.text | iex
+```
+
+#### 编译选项
+```
+# 切换编译模式
+xmake f -m debug/release
+
+# 可选编译参数
+-r ：重新构建目标
+-v ：显示详细的构建日志
+-y ：自动确认提示
+
+# 示例
+xmake b -vy crossdesk
+```
+
+#### 运行选项
+```
+# 使用调试模式运行
+xmake r -d crossdesk
+```
+更多使用方法可参考 [Xmake官方文档](https://xmake.io/guide/quick-start.html) 。
+
+## 自托管服务器
+推荐使用Docker部署CrossDesk Server。
+```bash
+sudo docker run -d \
+  --name crossdesk_server \
+  --network host \
+  -e EXTERNAL_IP=xxx.xxx.xxx.xxx \
+  -e INTERNAL_IP=xxx.xxx.xxx.xxx \
+  -e CROSSDESK_SERVER_PORT=xxxx \
+  -e COTURN_PORT=xxxx \
+  -e MIN_PORT=xxxxx \
+  -e MAX_PORT=xxxxx \
+  -v /var/lib/crossdesk:/var/lib/crossdesk \
+  -v /var/log/crossdesk:/var/log/crossdesk \
+  crossdesk/crossdesk-server:v1.1.6
+```
+
+上述命令中，用户需注意的参数如下：
+
+**参数**
+- EXTERNAL_IP：服务器公网 IP , 对应 CrossDesk 客户端**自托管服务器配置**中填写的**服务器地址**
+- INTERNAL_IP：服务器内网 IP
+- CROSSDESK_SERVER_PORT：自托管服务使用的端口，对应 CrossDesk 客户端**自托管服务器配置**中填写的**服务器端口**
+- COTURN_PORT: COTURN 服务使用的端口, 对应 CrossDesk 客户端**自托管服务器配置**中填写的**中继服务端口**
+- MIN_PORT/MAX_PORT：COTURN 服务使用的端口范围，例如：MIN_PORT=50000, MAX_PORT=60000，范围可根据客户端数量调整。
+- `-v /var/lib/crossdesk:/var/lib/crossdesk`：持久化数据库和证书文件到宿主机
+- `-v /var/log/crossdesk:/var/log/crossdesk`：持久化日志文件到宿主机
+
+**示例**：
+```bash
+sudo docker run -d \
+  --name crossdesk_server \
+  --network host \
+  -e EXTERNAL_IP=114.114.114.114 \
+  -e INTERNAL_IP=10.0.0.1 \
+  -e CROSSDESK_SERVER_PORT=9099 \
+  -e COTURN_PORT=3478 \
+  -e MIN_PORT=50000 \
+  -e MAX_PORT=60000 \
+  -v /var/lib/crossdesk:/var/lib/crossdesk \
+  -v /var/log/crossdesk:/var/log/crossdesk \
+  crossdesk/crossdesk-server:v1.1.6
+```
+
+**注意**：
+- **服务器需开放端口：COTURN_PORT/udp，COTURN_PORT/tcp，MIN_PORT-MAX_PORT/udp，CROSSDESK_SERVER_PORT/tcp。**
+- 如果不挂载 volume，容器删除后数据会丢失
+- 证书文件会在首次启动时自动生成并持久化到宿主机的 `/var/lib/crossdesk/certs` 路径下。由于默认使用的是自签证书，无法保障安全性，建议在云服务商申请正式证书放到该目录下并重启服务。
+- 数据库文件会自动创建并持久化到宿主机的 `/var/lib/crossdesk/db/crossdesk-server.db` 路径下
+- 日志文件会自动创建并持久化到宿主机的 `/var/log/crossdesk/` 路径下
+
+**权限注意**：如果 Docker 自动创建的目录权限不足（属于 root），容器内用户无法写入，会导致：
+  - 证书生成失败，容器启动脚本会报错退出
+  - 数据库目录创建失败，程序会抛出异常并崩溃
+  - 日志目录创建失败，日志文件无法写入（但程序可能继续运行）
+  
+**解决方案**：在启动容器前手动设置权限：
+```bash
+sudo mkdir -p /var/lib/crossdesk /var/log/crossdesk
+sudo chown -R $(id -u):$(id -g) /var/lib/crossdesk /var/log/crossdesk
+```
+
+
+### 客户端
+1. 点击右上角设置进入设置页面。<br><br>
+<img width="600" height="210" alt="image" src="https://github.com/user-attachments/assets/6431131d-b32a-4726-8783-6788f47baa3b" /><br>
+
+2. 点击`自托管服务器配置`按钮。<br><br>
+<img width="600" height="160" alt="image" src="https://github.com/user-attachments/assets/24c761a3-1985-4d7e-84be-787383c2afb8" /><br>
+
+3. 输入`服务器地址`(**EXTERNAL_IP**)、`信令服务端口`(**CROSSDESK_SERVER_PORT**)、`中继服务端口`(**COTURN_PORT**)，点击确认按钮。
+   
+4. 勾选`自托管服务器配置`选项，点击确认按钮保存设置。如果服务端使用的是正式证书，则到此步骤为止，客户端即可显示已连接服务器。
+
+5. 如果使用默认证书（正式证书忽略此步骤），则需要将服务端`/var/lib/crossdesk/certs/`目录下的`api.crossdesk.cn_root.crt`自签根证书下载到运行客户端的机器，并执行下述命令安装证书：
+
+Windows 平台使用**管理员权限**打开 PowerShell 执行
+```
+certutil -addstore "Root" "C:\path\to\api.crossdesk.cn_root.crt"
+```
+Linux
+```
+sudo cp /path/to/api.crossdesk.cn_root.crt /usr/local/share/ca-certificates/api.crossdesk.cn_root.crt
+sudo update-ca-certificates
+```
+macOS
+```
+sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain path/to/api.crossdesk.cn_root.crt
+```
+
+### Web 客户端
+详情见项目 [CrossDesk Web Client](https://github.com/kunkundi/crossdesk-web-client)。
+
+# 常见问题
+见 [常见问题](https://github.com/kunkundi/crossdesk/blob/self-hosted-server/docs/FAQ.md) 。

README_EN.md

@@ -0,0 +1,276 @@
+# CrossDesk
+
+<a href="https://hellogithub.com/repository/kunkundi/crossdesk" target="_blank"><img src="https://api.hellogithub.com/v1/widgets/recommend.svg?rid=55d41367570345f1838e02fd12be7961&claim_uid=cb0OpZRrBuGVAfL&theme=small" alt="Featured｜HelloGitHub" /></a>
+[![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux%20%7C%20macOS-brightgreen.svg)]()
+[![License: LGPL v3](https://img.shields.io/badge/License-LGPL%20v3-blue.svg)](https://www.gnu.org/licenses/lgpl-3.0)
+[![GitHub last commit](https://img.shields.io/github/last-commit/kunkundi/crossdesk)](https://github.com/kunkundi/crossdesk/commits/web-client)
+[![Build Status](https://github.com/kunkundi/crossdesk/actions/workflows/build.yml/badge.svg)](https://github.com/kunkundi/crossdesk/actions)  
+[![Docker Pulls](https://img.shields.io/docker/pulls/crossdesk/crossdesk-server)](https://hub.docker.com/r/crossdesk/crossdesk-server/tags)
+[![GitHub issues](https://img.shields.io/github/issues/kunkundi/crossdesk.svg)]()
+[![GitHub stars](https://img.shields.io/github/stars/kunkundi/crossdesk.svg?style=social)]()
+[![GitHub forks](https://img.shields.io/github/forks/kunkundi/crossdesk.svg?style=social)]()
+
+[ [中文](README.md) / English ]
+
+PC Client
+![sup_example](https://github.com/user-attachments/assets/3f17d8f3-7c4a-4b63-bae4-903363628687)
+
+Web Client
+<p align="center">
+  <img width="850" height="550" alt="6bddcbed47ffd4b9988a4037c7f4f524" src="https://github.com/user-attachments/assets/e44f73f9-24ac-46a3-a189-b7f8b6669881" />
+</p>
+
+# Intro
+
+CrossDesk is a lightweight cross-platform remote desktop software.
+
+CrossDesk is an experimental application of [MiniRTC](https://github.com/kunkundi/minirtc.git), a lightweight cross-platform real-time audio and video transmission library. MiniRTC provides fundamental capabilities including network traversal ([RFC5245](https://datatracker.ietf.org/doc/html/rfc5245)), video software/hardware encoding and decoding (H264/AV1), audio encoding/decoding ([Opus](https://github.com/xiph/opus)), signaling interaction, network congestion control, and transmission encryption ([SRTP](https://tools.ietf.org/html/rfc3711)).
+
+## System Requirements
+
+| Platform | Minimum Version |
+|-----------|-----------------|
+| **Windows** | Windows 10 or later (64-bit) |
+| **macOS** | macOS Intel 15.0 or later *(versions between 14.0 and 15.0 can be built manually for compatibility)*<br>macOS Apple Silicon 14.0 or later |
+| **Linux** | Ubuntu 22.04 or later *(older versions can be built manually for compatibility)* |
+
+
+## Usage
+
+Enter the remote desktop ID in the menu bar’s “Remote ID” field and click “→” to initiate a remote connection.
+
+![usage1](https://github.com/user-attachments/assets/3a4bb59f-c84c-44d2-9a20-11790aac510e)
+
+If the remote desktop requires a connection password, you must enter the correct password on your side to successfully establish the connection.
+
+![password](https://github.com/user-attachments/assets/1beadcce-640d-4f5c-8e77-51917b5294d5)
+
+Before connecting, you can customize configuration options in the settings, such as language and video encoding format.
+
+![settings](https://github.com/user-attachments/assets/8bc5468d-7bbb-4e30-95bd-da1f352ac08c)
+
+### Web Client
+
+Visit  [CrossDesk Web Client](https://web.crossdesk.cn/).
+Enter the **Remote Device ID** and **Password**, then click Connect to access the remote device. As shown, **iOS Safari remotely controlling Windows 11**:
+
+<img width="645" height="300" alt="_cgi-bin_mmwebwx-bin_webwxgetmsgimg__ MsgID=932911462648581698 skey=@crypt_1f5153b1_b550ca7462b5009ce03c991cca2a92a7 mmweb_appid=wx_webfilehelper" src="https://github.com/user-attachments/assets/a5109e6f-752c-4654-9f4e-7e161bddf43e" />
+
+## How to build
+
+Requirements:
+- [xmake](https://xmake.io/#/guide/installation)
+- [cmake](https://cmake.org/download/)
+
+Following packages need to be installed on Linux:
+
+```
+sudo apt-get install -y software-properties-common git curl unzip build-essential libx11-dev libxrandr-dev libxinerama-dev libxcursor-dev libxi-dev libxcb-randr0-dev libxcb-xtest0-dev libxcb-xinerama0-dev libxcb-shape0-dev libxcb-xkb-dev libxcb-xfixes0-dev libxfixes-dev libxv-dev libxtst-dev libasound2-dev libsndio-dev libxcb-shm0-dev libasound2-dev libpulse-dev
+```
+
+Build:
+```
+git clone https://github.com/kunkundi/crossdesk.git
+
+cd crossdesk
+
+git submodule init 
+
+git submodule update
+
+xmake b -vy crossdesk
+```
+Build options:
+```
+--USE_CUDA=true/false: enable CUDA acceleration codec, default: false
+--CROSSDESK_VERSION=xxx: set the version number
+
+# example:
+xmake f --CROSSDESK_VERSION=1.0.0 --USE_CUDA=true
+```
+Run:
+```
+xmake r crossdesk
+```
+
+#### Development Without CUDA Environment
+
+For **Linux developers who do not have a CUDA environment installed and want to enable hardware codec feature**, a preconfigured [Ubuntu 22.04 Docker image](https://hub.docker.com/r/crossdesk/ubuntu22.04) is provided.  
+This image comes with all required build dependencies and allows you to build the project directly inside the container without any additional setup.
+
+After entering the container, download the project and run:
+```
+export CUDA_PATH=/usr/local/cuda
+export XMAKE_GLOBALDIR=/data
+
+xmake f --USE_CUDA=true
+xmake b --root -vy crossdesk
+```
+
+For **Windows developers without a CUDA environment** installed, run the following command to install the CUDA build environment:
+```
+xmake require -vy "cuda 12.6.3"
+```
+After the installation is complete, execute:
+```
+xmake require --info "cuda 12.6.3"
+```
+The output will look like this:
+
+<img width="860" height="226" alt="Image" src="https://github.com/user-attachments/assets/999ac365-581a-4b9a-806e-05eb3e4cf44d" />
+
+From the output above, locate the CUDA installation directory — this is the path pointed to by installdir.
+Add this path to your system environment variable CUDA_PATH, or set it in the terminal using:
+```
+set CUDA_PATH=path_to_cuda_installdir:
+```
+Then re-run:
+```
+xmake f --USE_CUDA=true
+xmake b -vy crossdesk
+```
+
+#### Notice
+If the client status bar shows **Disconnected** during runtime, please first install the client from the [CrossDesk official website](https://www.crossdesk.cn/) to ensure the required certificate files are available in the environment.
+
+<img width="256" height="120" alt="image" src="https://github.com/user-attachments/assets/1812f7d6-516b-4b4f-8a3d-98bee505cc5a" />
+
+## About Xmake
+#### Installing Xmake
+
+You can install Xmake using one of the following methods:
+
+Using curl:
+```
+curl -fsSL https://xmake.io/shget.text | bash
+```
+Using wget:
+```
+wget https://xmake.io/shget.text -O - | bash
+```
+Using powershell:
+```
+irm https://xmake.io/psget.text | iex
+```
+
+#### Build Options
+```
+# Switch build mode
+xmake f -m debug/release
+
+# Optional build parameters
+-r : Rebuild the target
+-v : Show detailed build logs
+-y : Automatically confirm prompts
+
+# Example
+xmake b -vy crossdesk
+```
+
+#### Run Options
+```
+# Run in debug mode
+xmake r -d crossdesk
+```
+
+For more information, please refer to the [official Xmake documentation](https://xmake.io/guide/quick-start.html) .
+
+## Self-Hosted Server
+It is recommended to deploy CrossDesk Server using Docker.
+```
+sudo docker run -d \
+  --name crossdesk_server \
+  --network host \
+  -e EXTERNAL_IP=xxx.xxx.xxx.xxx \
+  -e INTERNAL_IP=xxx.xxx.xxx.xxx \
+  -e CROSSDESK_SERVER_PORT=xxxx \
+  -e COTURN_PORT=xxxx \
+  -e MIN_PORT=xxxxx \
+  -e MAX_PORT=xxxxx \
+  -v /var/lib/crossdesk:/var/lib/crossdesk \
+  -v /var/log/crossdesk:/var/log/crossdesk \
+  crossdesk/crossdesk-server:v1.1.6
+```
+
+The parameters you need to pay attention to are as follows:
+
+**Parameters**
+- **EXTERNAL_IP**: The server’s public IP. This corresponds to **Server Address** in the CrossDesk client’s **Self-Hosted Server Configuration**.
+- **INTERNAL_IP**: The server’s internal IP.
+- **CROSSDESK_SERVER_PORT**: The port used by the self-hosted service. This corresponds to **Server Port** in the CrossDesk client’s **Self-Hosted Server Configuration**.
+- **COTURN_PORT**: The port used by the COTURN service. This corresponds to **Relay Service Port** in the CrossDesk client’s **Self-Hosted Server Configuration**.
+- **MIN_PORT / MAX_PORT**: The port range used by the COTURN service. Example: `MIN_PORT=50000`, `MAX_PORT=60000`. Adjust the range depending on the number of clients.
+- `-v /var/lib/crossdesk:/var/lib/crossdesk`: Persists database and certificate files on the host machine.
+- `-v /var/log/crossdesk:/var/log/crossdesk`: Persists log files on the host machine.
+
+**Example**:
+```bash
+sudo docker run -d \
+  --name crossdesk_server \
+  --network host \
+  -e EXTERNAL_IP=114.114.114.114 \
+  -e INTERNAL_IP=10.0.0.1 \
+  -e CROSSDESK_SERVER_PORT=9099 \
+  -e COTURN_PORT=3478 \
+  -e MIN_PORT=50000 \
+  -e MAX_PORT=60000 \
+  -v /var/lib/crossdesk:/var/lib/crossdesk \
+  -v /var/log/crossdesk:/var/log/crossdesk \
+  crossdesk/crossdesk-server:v1.1.6
+```
+
+**Notes**
+- **The server must open the following ports: COTURN_PORT/udp, COTURN_PORT/tcp, MIN_PORT–MAX_PORT/udp, and CROSSDESK_SERVER_PORT/tcp.**
+- If you don’t mount volumes, all data will be lost when the container is removed.
+- Certificate files will be automatically generated on first startup and persisted to the host at `/var/lib/crossdesk/certs`.As the default certificates are self-signed and cannot guarantee security, it is strongly recommended to apply for a trusted certificate from a cloud provider, deploy it to this directory, and restart the service.
+- The database file will be automatically created and stored at `/var/lib/crossdesk/db/crossdesk-server.db`.
+- Log files will be created and stored at `/var/log/crossdesk/`.
+
+**Permission Notice**
+If the directories automatically created by Docker belong to root and have insufficient write permissions, the container user may not be able to write to them. This can cause:
+  - Certificate generation failure, leading to startup script errors and container exit.
+  - Database directory creation failure, causing the program to throw exceptions and crash.
+  - Log directory creation failure, preventing logs from being written (though the program may continue running).
+
+**Solution:** Manually set permissions before starting the container:
+```bash
+sudo mkdir -p /var/lib/crossdesk /var/log/crossdesk
+sudo chown -R $(id -u):$(id -g) /var/lib/crossdesk /var/log/crossdesk
+```
+
+### Server Side
+Place **crossdesk.cn.key** and **crossdesk.cn_bundle.crt** into the **/path/to/your/certs** directory.
+
+### Client Side
+1. Click the settings icon in the top-right corner to enter the settings page.<br><br>
+<img width="600" height="210" alt="image" src="https://github.com/user-attachments/assets/6431131d-b32a-4726-8783-6788f47baa3b" /><br>
+
+2. Click `Self-Hosted Server Configuration` button.<br><br>
+<img width="600" height="160" alt="image" src="https://github.com/user-attachments/assets/24c761a3-1985-4d7e-84be-787383c2afb8" /><br>
+
+3. Enter the `Server Address` (**EXTERNAL_IP**), `Signaling Service Port` (**CROSSDESK_SERVER_PORT**), and `Relay Service Port` (**COTURN_PORT**) and click OK button.
+
+4. Check the `Self-hosted server configuration` option and click the OK button to save the settings. If the server is using a valid (official) certificate, the process ends here and the client will show that it is connected to the server.
+
+5. If the default certificate is used (skip this step if an official certificate is used), download the self-signed root certificate `api.crossdesk.cn_root.crt` from the server directory /var/lib/crossdesk/certs/ to the machine running the client, and install the certificate by executing the following command:
+
+On Windows, open PowerShell with **administrator privileges** and execute:
+```
+certutil -addstore "Root" "C:\path\to\api.crossdesk.cn_root.crt"
+```
+Linux
+```
+sudo cp /path/to/api.crossdesk.cn_root.crt /usr/local/share/ca-certificates/api.crossdesk.cn_root.crt
+sudo update-ca-certificates
+```
+macOS
+```
+sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain path/to/api.crossdesk.cn_root.crt
+```
+
+
+### Web Client
+See [CrossDesk Web Client](https://github.com/kunkundi/crossdesk-web-client)。
+
+# FAQ
+See [FAQ](https://github.com/kunkundi/crosssesk/blob/self-hosted-server/docs/FAQ.md) .

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

docs/FAQ.md

@@ -0,0 +1,33 @@
+# 常见问题（FAQ）
+
+欢迎来到 **CrossDesk 常见问题** 页面！  
+这里整理了用户和开发者最常见的一些疑问。如果你没有找到答案，欢迎在 [Issues](https://github.com/kunkundi/crossdesk/issues) 中反馈。
+
+---
+
+### Q1. 对等连接失败
+**A:**  
+打开设置，勾选 **启用中继服务** 选项，尝试重新发起连接。
+
+<img width="396" height="306" alt="Image" src="https://github.com/user-attachments/assets/fd8db148-c782-4f4d-b874-8f1b2a7ec7d6" />
+
+由于公共中继服务器带宽较小，连接的清晰度流畅度可能会下降，建议自建服务器。 [Issue #8](https://github.com/kunkundi/crossdesk/issues/8)
+
+### Q2. Windows 无 CUDA 环境下编译
+**A:**  
+运行下面的命令安装 CUDA 编译环境。
+```
+xmake require -vy "cuda 12.6.3"
+```
+安装完成后执行
+```
+xmake require --info "cuda 12.6.3"
+```
+输出如下
+
+<img width="860" height="226" alt="Image" src="https://github.com/user-attachments/assets/999ac365-581a-4b9a-806e-05eb3e4cf44d" />
+
+根据上述输出获取到 CUDA 的安装目录，即 installdir 指向的位置。将 CUDA_PATH 加入系统环境变量，或在终端中输入 set CUDA_PATH=path_to_cuda_installdir，重新执行 xmake b -vy crossdesk 即可。
+[Issue #6](https://github.com/kunkundi/crossdesk/issues/6)
+
+---

scripts/linux/pkg_amd64.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+set -e
+
+PKG_NAME="crossdesk"
+APP_NAME="CrossDesk"
+
+APP_VERSION="$1"
+ARCHITECTURE="amd64"
+MAINTAINER="Junkun Di <junkun.di@hotmail.com>"
+DESCRIPTION="A simple cross-platform remote desktop client."
+
+# Remove 'v' prefix from version for Debian package (Debian version must start with digit)
+DEB_VERSION="${APP_VERSION#v}"
+
+DEB_DIR="${PKG_NAME}-${DEB_VERSION}"
+DEBIAN_DIR="$DEB_DIR/DEBIAN"
+BIN_DIR="$DEB_DIR/usr/bin"
+ICON_BASE_DIR="$DEB_DIR/usr/share/icons/hicolor"
+DESKTOP_DIR="$DEB_DIR/usr/share/applications"
+
+rm -rf "$DEB_DIR"
+
+mkdir -p "$DEBIAN_DIR" "$BIN_DIR" "$DESKTOP_DIR"
+
+cp build/linux/x86_64/release/crossdesk "$BIN_DIR/$PKG_NAME"
+chmod +x "$BIN_DIR/$PKG_NAME"
+
+ln -s "$PKG_NAME" "$BIN_DIR/$APP_NAME"
+
+for size in 16 24 32 48 64 96 128 256; do
+    mkdir -p "$ICON_BASE_DIR/${size}x${size}/apps"
+    cp "icons/linux/crossdesk_${size}x${size}.png" \
+       "$ICON_BASE_DIR/${size}x${size}/apps/${PKG_NAME}.png"
+done
+
+cat > "$DEBIAN_DIR/control" << EOF
+Package: $PKG_NAME
+Version: $DEB_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, libdrm2, libdbus-1-3,
+ libpipewire-0.3-0, xdg-desktop-portal,
+ xdg-desktop-portal-gtk | xdg-desktop-portal-kde | xdg-desktop-portal-wlr
+Recommends: nvidia-cuda-toolkit
+Priority: optional
+Section: utils
+EOF
+
+cat > "$DESKTOP_DIR/$PKG_NAME.desktop" << EOF
+[Desktop Entry]
+Version=$DEB_VERSION
+Name=$APP_NAME
+Comment=$DESCRIPTION
+Exec=/usr/bin/$PKG_NAME
+Icon=$PKG_NAME
+Terminal=false
+Type=Application
+Categories=Utility;
+EOF
+
+cat > "$DEBIAN_DIR/postrm" << EOF
+#!/bin/bash
+set -e
+
+if [ "\$1" = "remove" ] || [ "\$1" = "purge" ]; then
+    rm -f /usr/bin/$PKG_NAME || true
+    rm -f /usr/bin/$APP_NAME || true
+    rm -f /usr/share/applications/$PKG_NAME.desktop || true
+    for size in 16 24 32 48 64 96 128 256; do
+        rm -f /usr/share/icons/hicolor/\${size}x\${size}/apps/$PKG_NAME.png || true
+    done
+fi
+
+exit 0
+EOF
+chmod +x "$DEBIAN_DIR/postrm"
+
+cat > "$DEBIAN_DIR/postinst" << 'EOF'
+#!/bin/bash
+set -e
+
+exit 0
+EOF
+
+chmod +x "$DEBIAN_DIR/postinst"
+
+dpkg-deb --build "$DEB_DIR"
+
+OUTPUT_FILE="${PKG_NAME}-linux-${ARCHITECTURE}-${APP_VERSION}.deb"
+mv "$DEB_DIR.deb" "$OUTPUT_FILE"
+
+rm -rf "$DEB_DIR"
+
+echo "✅ Deb package created: $OUTPUT_FILE"

scripts/linux/pkg_arm64.sh

@@ -0,0 +1,97 @@
+#!/bin/bash
+set -e
+
+PKG_NAME="crossdesk"
+APP_NAME="CrossDesk"
+
+APP_VERSION="$1"
+ARCHITECTURE="arm64"
+MAINTAINER="Junkun Di <junkun.di@hotmail.com>"
+DESCRIPTION="A simple cross-platform remote desktop client."
+
+# Remove 'v' prefix from version for Debian package (Debian version must start with digit)
+DEB_VERSION="${APP_VERSION#v}"
+
+DEB_DIR="${PKG_NAME}-${DEB_VERSION}"
+DEBIAN_DIR="$DEB_DIR/DEBIAN"
+BIN_DIR="$DEB_DIR/usr/bin"
+ICON_BASE_DIR="$DEB_DIR/usr/share/icons/hicolor"
+DESKTOP_DIR="$DEB_DIR/usr/share/applications"
+
+rm -rf "$DEB_DIR"
+
+mkdir -p "$DEBIAN_DIR" "$BIN_DIR" "$DESKTOP_DIR"
+
+cp build/linux/arm64/release/crossdesk "$BIN_DIR"
+chmod +x "$BIN_DIR/$PKG_NAME"
+
+ln -s "$PKG_NAME" "$BIN_DIR/$APP_NAME"
+
+for size in 16 24 32 48 64 96 128 256; do
+    mkdir -p "$ICON_BASE_DIR/${size}x${size}/apps"
+    cp "icons/linux/crossdesk_${size}x${size}.png" \
+       "$ICON_BASE_DIR/${size}x${size}/apps/${PKG_NAME}.png"
+done
+
+cat > "$DEBIAN_DIR/control" << EOF
+Package: $PKG_NAME
+Version: $DEB_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, libdrm2, libdbus-1-3,
+ libpipewire-0.3-0, xdg-desktop-portal,
+ xdg-desktop-portal-gtk | xdg-desktop-portal-kde | xdg-desktop-portal-wlr
+Priority: optional
+Section: utils
+EOF
+
+cat > "$DESKTOP_DIR/$PKG_NAME.desktop" << EOF
+[Desktop Entry]
+Version=$DEB_VERSION
+Name=$APP_NAME
+Comment=$DESCRIPTION
+Exec=/usr/bin/$PKG_NAME
+Icon=$PKG_NAME
+Terminal=false
+Type=Application
+Categories=Utility;
+EOF
+
+cat > "$DEBIAN_DIR/postrm" << EOF
+#!/bin/bash
+set -e
+
+if [ "\$1" = "remove" ] || [ "\$1" = "purge" ]; then
+    rm -f /usr/bin/$PKG_NAME || true
+    rm -f /usr/bin/$APP_NAME || true
+    rm -f /usr/share/applications/$PKG_NAME.desktop || true
+    for size in 16 24 32 48 64 96 128 256; do
+        rm -f /usr/share/icons/hicolor/\${size}x\${size}/apps/$PKG_NAME.png || true
+    done
+fi
+
+exit 0
+EOF
+chmod +x "$DEBIAN_DIR/postrm"
+
+cat > "$DEBIAN_DIR/postinst" << 'EOF'
+#!/bin/bash
+set -e
+
+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 created: $OUTPUT_FILE"

scripts/macosx/pkg_arm64.sh

@@ -0,0 +1,178 @@
+#!/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/macos/crossdesk.icns"
+MACOS_MIN_VERSION="10.12"
+
+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 "delete old files"
+rm -rf "${APP_BUNDLE}" "${PKG_NAME}" "${DMG_NAME}" build_pkg_temp CrossDesk_dmg_temp
+
+mkdir -p build_pkg_temp
+mkdir -p "${MACOS_DIR}" "${RESOURCES_DIR}"
+
+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>"
+else
+    ICON_KEY=""
+fi
+
+echo "generate 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 created successfully."
+
+echo "building pkg..."
+pkgbuild \
+  --identifier "${IDENTIFIER}" \
+  --version "${APP_VERSION}" \
+  --install-location "/Applications" \
+  --component "${APP_BUNDLE}" \
+  build_pkg_temp/${APP_NAME}-component.pkg
+
+mkdir -p build_pkg_scripts
+
+cat > build_pkg_scripts/postinstall <<'EOF'
+#!/bin/bash
+set -e
+
+IDENTIFIER="cn.crossdesk.app"
+
+# 获取当前登录用户
+USER_HOME=$( /usr/bin/stat -f "%Su" /dev/console )
+HOME_DIR=$( /usr/bin/dscl . -read /Users/$USER_HOME NFSHomeDirectory | awk '{print $2}' )
+
+# 清除应用的权限授权，以便重新授权
+# 使用 tccutil 重置录屏权限和辅助功能权限
+if command -v tccutil >/dev/null 2>&1; then
+    # 重置录屏权限
+    tccutil reset ScreenCapture "$IDENTIFIER" 2>/dev/null || true
+    # 重置辅助功能权限
+    tccutil reset Accessibility "$IDENTIFIER" 2>/dev/null || true
+    # 重置摄像头权限（如果需要）
+    tccutil reset Camera "$IDENTIFIER" 2>/dev/null || true
+    # 重置麦克风权限（如果需要）
+    tccutil reset Microphone "$IDENTIFIER" 2>/dev/null || true
+fi
+
+# 为所有用户清除权限（可选，如果需要）
+# 遍历所有用户目录并清除权限
+for USER_DIR in /Users/*; do
+    if [ -d "$USER_DIR" ] && [ "$USER_DIR" != "/Users/Shared" ]; then
+        USER_NAME=$(basename "$USER_DIR")
+        # 跳过系统用户
+        if [ "$USER_NAME" != "Shared" ] && [ -d "$USER_DIR/Library" ]; then
+            # 删除 TCC 数据库中的相关条目（需要管理员权限）
+            TCC_DB="$USER_DIR/Library/Application Support/com.apple.TCC/TCC.db"
+            if [ -f "$TCC_DB" ]; then
+                # 使用 sqlite3 删除相关权限记录（如果可用）
+                if command -v sqlite3 >/dev/null 2>&1; then
+                    sqlite3 "$TCC_DB" "DELETE FROM access WHERE client='$IDENTIFIER' AND service IN ('kTCCServiceScreenCapture', 'kTCCServiceAccessibility');" 2>/dev/null || true
+                fi
+            fi
+        fi
+    fi
+done
+
+exit 0
+EOF
+
+chmod +x build_pkg_scripts/postinstall
+
+productbuild \
+  --package build_pkg_temp/${APP_NAME}-component.pkg \
+  "${PKG_NAME}"
+
+echo "PKG package created: ${PKG_NAME}"
+
+# Set custom icon for PKG file
+if [ -f "${ICON_PATH}" ]; then
+    echo "Setting custom icon for PKG file..."
+    # Create a temporary iconset from icns
+    TEMP_ICON_DIR=$(mktemp -d)
+    cp "${ICON_PATH}" "${TEMP_ICON_DIR}/icon.icns"
+    
+    # Use sips to create a png from icns for the icon
+    sips -s format png "${TEMP_ICON_DIR}/icon.icns" --out "${TEMP_ICON_DIR}/icon.png" 2>/dev/null || true
+    
+    # Method: Use osascript to set file icon (works on macOS)
+    osascript <<APPLESCRIPT
+use framework "Foundation"
+use framework "AppKit"
+
+set iconPath to POSIX file "${TEMP_ICON_DIR}/icon.icns"
+set targetPath to POSIX file "$(pwd)/${PKG_NAME}"
+
+set iconImage to current application's NSImage's alloc()'s initWithContentsOfFile:(POSIX path of iconPath)
+set workspace to current application's NSWorkspace's sharedWorkspace()
+workspace's setIcon:iconImage forFile:(POSIX path of targetPath) options:0
+APPLESCRIPT
+
+    if [ $? -eq 0 ]; then
+        echo "Custom icon set successfully for ${PKG_NAME}"
+    else
+        echo "Warning: Failed to set custom icon (this is optional)"
+    fi
+    
+    rm -rf "${TEMP_ICON_DIR}"
+fi
+echo "Set icon finished"
+
+rm -rf build_pkg_temp build_pkg_scripts ${APP_BUNDLE}
+
+echo "PKG package created successfully."
+echo "package ${APP_BUNDLE}"
+echo "installer ${PKG_NAME}"

scripts/macosx/pkg_x64.sh

@@ -0,0 +1,178 @@
+#!/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="x64"
+IDENTIFIER="cn.crossdesk.app"
+ICON_PATH="icons/macos/crossdesk.icns"
+MACOS_MIN_VERSION="10.12"
+
+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 "delete old files"
+rm -rf "${APP_BUNDLE}" "${PKG_NAME}" "${DMG_NAME}" build_pkg_temp CrossDesk_dmg_temp
+
+mkdir -p build_pkg_temp
+mkdir -p "${MACOS_DIR}" "${RESOURCES_DIR}"
+
+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>"
+else
+    ICON_KEY=""
+fi
+
+echo "generate 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 created successfully."
+
+echo "building pkg..."
+pkgbuild \
+  --identifier "${IDENTIFIER}" \
+  --version "${APP_VERSION}" \
+  --install-location "/Applications" \
+  --component "${APP_BUNDLE}" \
+  build_pkg_temp/${APP_NAME}-component.pkg
+
+mkdir -p build_pkg_scripts
+
+cat > build_pkg_scripts/postinstall <<'EOF'
+#!/bin/bash
+set -e
+
+IDENTIFIER="cn.crossdesk.app"
+
+# 获取当前登录用户
+USER_HOME=$( /usr/bin/stat -f "%Su" /dev/console )
+HOME_DIR=$( /usr/bin/dscl . -read /Users/$USER_HOME NFSHomeDirectory | awk '{print $2}' )
+
+# 清除应用的权限授权，以便重新授权
+# 使用 tccutil 重置录屏权限和辅助功能权限
+if command -v tccutil >/dev/null 2>&1; then
+    # 重置录屏权限
+    tccutil reset ScreenCapture "$IDENTIFIER" 2>/dev/null || true
+    # 重置辅助功能权限
+    tccutil reset Accessibility "$IDENTIFIER" 2>/dev/null || true
+    # 重置摄像头权限（如果需要）
+    tccutil reset Camera "$IDENTIFIER" 2>/dev/null || true
+    # 重置麦克风权限（如果需要）
+    tccutil reset Microphone "$IDENTIFIER" 2>/dev/null || true
+fi
+
+# 为所有用户清除权限（可选，如果需要）
+# 遍历所有用户目录并清除权限
+for USER_DIR in /Users/*; do
+    if [ -d "$USER_DIR" ] && [ "$USER_DIR" != "/Users/Shared" ]; then
+        USER_NAME=$(basename "$USER_DIR")
+        # 跳过系统用户
+        if [ "$USER_NAME" != "Shared" ] && [ -d "$USER_DIR/Library" ]; then
+            # 删除 TCC 数据库中的相关条目（需要管理员权限）
+            TCC_DB="$USER_DIR/Library/Application Support/com.apple.TCC/TCC.db"
+            if [ -f "$TCC_DB" ]; then
+                # 使用 sqlite3 删除相关权限记录（如果可用）
+                if command -v sqlite3 >/dev/null 2>&1; then
+                    sqlite3 "$TCC_DB" "DELETE FROM access WHERE client='$IDENTIFIER' AND service IN ('kTCCServiceScreenCapture', 'kTCCServiceAccessibility');" 2>/dev/null || true
+                fi
+            fi
+        fi
+    fi
+done
+
+exit 0
+EOF
+
+chmod +x build_pkg_scripts/postinstall
+
+productbuild \
+  --package build_pkg_temp/${APP_NAME}-component.pkg \
+  "${PKG_NAME}"
+
+echo "PKG package created: ${PKG_NAME}"
+
+# Set custom icon for PKG file
+if [ -f "${ICON_PATH}" ]; then
+    echo "Setting custom icon for PKG file..."
+    # Create a temporary iconset from icns
+    TEMP_ICON_DIR=$(mktemp -d)
+    cp "${ICON_PATH}" "${TEMP_ICON_DIR}/icon.icns"
+    
+    # Use sips to create a png from icns for the icon
+    sips -s format png "${TEMP_ICON_DIR}/icon.icns" --out "${TEMP_ICON_DIR}/icon.png" 2>/dev/null || true
+    
+    # Method: Use osascript to set file icon (works on macOS)
+    osascript <<APPLESCRIPT
+use framework "Foundation"
+use framework "AppKit"
+
+set iconPath to POSIX file "${TEMP_ICON_DIR}/icon.icns"
+set targetPath to POSIX file "$(pwd)/${PKG_NAME}"
+
+set iconImage to current application's NSImage's alloc()'s initWithContentsOfFile:(POSIX path of iconPath)
+set workspace to current application's NSWorkspace's sharedWorkspace()
+workspace's setIcon:iconImage forFile:(POSIX path of targetPath) options:0
+APPLESCRIPT
+
+    if [ $? -eq 0 ]; then
+        echo "Custom icon set successfully for ${PKG_NAME}"
+    else
+        echo "Warning: Failed to set custom icon (this is optional)"
+    fi
+    
+    rm -rf "${TEMP_ICON_DIR}"
+fi
+echo "Set icon finished"
+
+rm -rf build_pkg_temp build_pkg_scripts ${APP_BUNDLE}
+
+echo "PKG package created successfully."
+echo "package ${APP_BUNDLE}"
+echo "installer ${PKG_NAME}"

scripts/windows/crossdesk.manifest

@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+
+  <!-- 应用程序标识 -->
+  <assemblyIdentity
+      version="1.0.0.0"
+      processorArchitecture="*"
+      name="CrossDesk"
+      type="win32" />
+
+  <!-- 描述信息 -->
+  <description>CrossDesk Application</description>
+
+  <!-- 权限：要求管理员运行 -->
+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+    <security>
+      <requestedPrivileges>
+        <requestedExecutionLevel level="requireAdministrator" uiAccess="false"/>
+      </requestedPrivileges>
+    </security>
+  </trustInfo>
+
+  <!-- DPI 感知设置：支持高分屏 -->
+  <application xmlns="urn:schemas-microsoft-com:asm.v3">
+    <windowsSettings>
+      <!-- Windows Vista/7 风格 DPI 感知 -->
+      <dpiAware>true/pm</dpiAware>
+      <!-- Windows 10/11 高级 DPI 感知 -->
+      <dpiAwareness>PerMonitorV2</dpiAwareness>
+    </windowsSettings>
+  </application>
+
+  <!-- Windows 兼容性声明 -->
+  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+      <!-- 支持 Windows 10 -->
+      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
+      <!-- 支持 Windows 11（向下兼容 Win10 GUID） -->
+      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
+    </application>
+  </compatibility>
+
+</assembly>

scripts/windows/crossdesk.rc

@@ -0,0 +1,2 @@
+// Application icon resource; load by the resource name IDI_ICON1.
+IDI_ICON1 ICON "..\\..\\icons\\windows\\crossdesk.ico"

scripts/windows/nsis_script.nsi

@@ -0,0 +1,150 @@
+; Set search path
+!addincludedir "${__FILEDIR__}"
+
+; Installer initial constants
+!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"
+
+; Installer icon path
+!define MUI_ICON "${__FILEDIR__}\..\..\icons\windows\crossdesk.ico"
+
+; Compression settings
+SetCompressor /FINAL lzma
+
+; Request admin privileges (needed to write HKLM)
+RequestExecutionLevel admin
+
+; ------ MUI Modern UI Definition ------
+!include "MUI.nsh"
+!define MUI_ABORTWARNING
+!insertmacro MUI_PAGE_WELCOME
+!insertmacro MUI_PAGE_DIRECTORY
+!insertmacro MUI_PAGE_INSTFILES
+
+; Add run-after-install option
+!define MUI_FINISHPAGE_RUN
+!define MUI_FINISHPAGE_RUN_TEXT "Run ${PRODUCT_NAME}"
+!define MUI_FINISHPAGE_RUN_FUNCTION LaunchApp
+
+!insertmacro MUI_PAGE_FINISH
+!insertmacro MUI_LANGUAGE "SimpChinese"
+!insertmacro MUI_RESERVEFILE_INSTALLOPTIONS
+; ------ End of MUI Definition ------
+
+; Include LogicLib for process handling
+!include "LogicLib.nsh"
+
+Name "${PRODUCT_NAME} ${PRODUCT_VERSION}"
+OutFile "crossdesk-win-x64-${PRODUCT_VERSION}.exe"
+InstallDir "$PROGRAMFILES\CrossDesk"
+InstallDirRegKey HKCU "Software\${PRODUCT_NAME}" "InstallDir"
+ShowInstDetails show
+
+Section "MainSection"
+    ; Check if CrossDesk is running
+    StrCpy $1 "CrossDesk.exe"
+    
+    nsProcess::_FindProcess "$1"
+    Pop $R0
+    ${If} $R0 = 0  ;
+        MessageBox MB_ICONQUESTION|MB_YESNO "CrossDesk is running. Do you want to close it and continue the installation?" IDYES closeApp IDNO cancelInstall
+    ${Else}
+        Goto installApp
+    ${EndIf}
+
+closeApp:
+    nsProcess::_KillProcess "$1"
+    Pop $R0
+    Sleep 500
+    Goto installApp
+
+cancelInstall:
+    SetDetailsPrint both
+    MessageBox MB_ICONEXCLAMATION|MB_OK "Installation has been aborted."
+    Abort
+
+installApp:
+    SetOutPath "$INSTDIR"
+    SetOverwrite ifnewer
+
+    ; Main application executable path
+    File /oname=CrossDesk.exe "..\..\build\windows\x64\release\crossdesk.exe"
+    ; Bundle runtime DLLs from the release output directory
+    File "..\..\build\windows\x64\release\*.dll"
+
+    ; Write uninstall information
+    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.exe"
+    WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${UNINSTALL_REG_KEY}" "NoModify" 1
+    WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${UNINSTALL_REG_KEY}" "NoRepair" 1
+    WriteRegStr HKCU "Software\${PRODUCT_NAME}" "InstallDir" "$INSTDIR"
+SectionEnd
+
+Section -AdditionalIcons
+    ; Desktop shortcut
+    CreateShortCut "$DESKTOP\${PRODUCT_NAME}.lnk" "$INSTDIR\CrossDesk.exe" "" "$INSTDIR\CrossDesk.exe"
+
+    ; Start menu shortcut
+    CreateShortCut "$SMPROGRAMS\${PRODUCT_NAME}.lnk" "$INSTDIR\CrossDesk.exe" "" "$INSTDIR\CrossDesk.exe"
+SectionEnd
+
+Section "Uninstall"
+    ; Check if CrossDesk is running
+    StrCpy $1 "CrossDesk.exe"
+    
+    nsProcess::_FindProcess "$1"
+    Pop $R0
+    ${If} $R0 = 0
+        MessageBox MB_ICONQUESTION|MB_YESNO "CrossDesk is running. Do you want to close it and uninstall?" IDYES closeApp IDNO cancelUninstall
+    ${Else}
+        Goto uninstallApp
+    ${EndIf}
+
+closeApp:
+    nsProcess::_KillProcess "$1"
+    Pop $R0
+    Sleep 500
+    Goto uninstallApp
+
+cancelUninstall:
+    SetDetailsPrint both
+    MessageBox MB_ICONEXCLAMATION|MB_OK "Uninstallation has been aborted."
+    Abort
+
+uninstallApp:
+    ; Delete main executable and uninstaller
+    Delete "$INSTDIR\CrossDesk.exe"
+    Delete "$INSTDIR\uninstall.exe"
+
+    ; Recursively delete installation directory
+    RMDir /r "$INSTDIR"
+
+    ; Delete desktop and start menu shortcuts
+    Delete "$DESKTOP\${PRODUCT_NAME}.lnk"
+    Delete "$SMPROGRAMS\${PRODUCT_NAME}.lnk"
+
+    ; Delete registry uninstall entry
+    DeleteRegKey HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${UNINSTALL_REG_KEY}"
+
+    ; Delete remembered install dir
+    DeleteRegKey HKCU "Software\${PRODUCT_NAME}"
+
+    ; Recursively delete CrossDesk folder in user AppData
+    RMDir /r "$APPDATA\CrossDesk"
+    RMDir /r "$LOCALAPPDATA\CrossDesk"
+SectionEnd
+
+; ------ Functions ------
+Function LaunchApp
+    Exec "$INSTDIR\CrossDesk.exe"
+FunctionEnd

src/app/daemon.cpp

@@ -0,0 +1,338 @@
+#include "daemon.h"
+
+#include <atomic>
+#include <chrono>
+#include <cstring>
+#include <iostream>
+#include <thread>
+#include <vector>
+
+#ifdef _WIN32
+#include <process.h>
+#include <tchar.h>
+#include <windows.h>
+#elif __APPLE__
+#include <fcntl.h>
+#include <limits.h>
+#include <mach-o/dyld.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#else
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <signal.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include <cstring>
+#endif
+
+#ifndef _WIN32
+volatile std::sig_atomic_t Daemon::stop_requested_ = 0;
+#endif
+
+namespace {
+constexpr int kRestartDelayMs = 1000;
+#ifndef _WIN32
+constexpr int kWaitPollIntervalMs = 200;
+#endif
+}  // namespace
+
+// get executable file path
+static std::string GetExecutablePath() {
+#ifdef _WIN32
+  char path[32768];
+  DWORD length = GetModuleFileNameA(nullptr, path, sizeof(path));
+  if (length > 0 && length < sizeof(path)) {
+    return std::string(path);
+  }
+#elif __APPLE__
+  char path[PATH_MAX];
+  uint32_t size = sizeof(path);
+  if (_NSGetExecutablePath(path, &size) == 0) {
+    char resolved_path[PATH_MAX];
+    if (realpath(path, resolved_path) != nullptr) {
+      return std::string(resolved_path);
+    }
+    return std::string(path);
+  }
+#else
+  char path[PATH_MAX];
+  ssize_t count = readlink("/proc/self/exe", path, sizeof(path) - 1);
+  if (count != -1) {
+    path[count] = '\0';
+    return std::string(path);
+  }
+#endif
+  return "";
+}
+
+Daemon::Daemon(const std::string& name) : name_(name), running_(false) {}
+
+void Daemon::stop() {
+  running_.store(false);
+#ifndef _WIN32
+  stop_requested_ = 1;
+#endif
+}
+
+bool Daemon::isRunning() const {
+#ifndef _WIN32
+  return running_.load() && (stop_requested_ == 0);
+#else
+  return running_.load();
+#endif
+}
+
+bool Daemon::start(MainLoopFunc loop) {
+#ifdef _WIN32
+  running_.store(true);
+  return runWithRestart(loop);
+#elif __APPLE__
+  // macOS: Use child process monitoring (like Windows) to preserve GUI
+  stop_requested_ = 0;
+  running_.store(true);
+  return runWithRestart(loop);
+#else
+  // linux: Daemonize first, then run with restart monitoring
+  stop_requested_ = 0;
+
+  // check if running from terminal before fork
+  bool from_terminal =
+      (isatty(STDIN_FILENO) != 0) || (isatty(STDOUT_FILENO) != 0);
+
+  // first fork: detach from terminal
+  pid_t pid = fork();
+  if (pid < 0) {
+    std::cerr << "Failed to fork daemon process" << std::endl;
+    return false;
+  }
+  if (pid > 0) _exit(0);
+
+  if (setsid() < 0) {
+    std::cerr << "Failed to create new session" << std::endl;
+    return false;
+  }
+
+  pid = fork();
+  if (pid < 0) {
+    std::cerr << "Failed to fork daemon process (second fork)" << std::endl;
+    return false;
+  }
+  if (pid > 0) _exit(0);
+
+  umask(0);
+  chdir("/");
+
+  // redirect file descriptors: keep stdout/stderr if from terminal, else
+  // redirect to /dev/null
+  int fd = open("/dev/null", O_RDWR);
+  if (fd >= 0) {
+    dup2(fd, STDIN_FILENO);
+    if (!from_terminal) {
+      dup2(fd, STDOUT_FILENO);
+      dup2(fd, STDERR_FILENO);
+    }
+    if (fd > 2) close(fd);
+  }
+
+  // set up signal handlers
+  signal(SIGTERM, [](int) { stop_requested_ = 1; });
+  signal(SIGINT, [](int) { stop_requested_ = 1; });
+
+  // ignore SIGPIPE
+  signal(SIGPIPE, SIG_IGN);
+
+  running_.store(true);
+  return runWithRestart(loop);
+#endif
+}
+
+#ifdef _WIN32
+static int RunLoopCatchCpp(Daemon::MainLoopFunc& loop) {
+  try {
+    loop();
+    return 0;  // normal exit
+  } catch (const std::exception& e) {
+    std::cerr << "Exception caught: " << e.what() << std::endl;
+    return 1;  // c++ exception
+  } catch (...) {
+    std::cerr << "Unknown exception caught" << std::endl;
+    return 1;  // other exception
+  }
+}
+
+static int RunLoopWithSEH(Daemon::MainLoopFunc& loop) {
+  __try {
+    return RunLoopCatchCpp(loop);
+  } __except (EXCEPTION_EXECUTE_HANDLER) {
+    // catch system-level crashes (access violation, divide by zero, etc.)
+    DWORD code = GetExceptionCode();
+    std::cerr << "System crash detected (SEH exception code: 0x" << std::hex
+              << code << std::dec << ")" << std::endl;
+    return 2;  // System crash
+  }
+}
+#endif
+
+// run with restart logic: parent monitors child process and restarts on crash
+bool Daemon::runWithRestart(MainLoopFunc loop) {
+  int restart_count = 0;
+  std::string exe_path = GetExecutablePath();
+  if (exe_path.empty()) {
+    std::cerr
+        << "Failed to get executable path, falling back to direct execution"
+        << std::endl;
+    while (isRunning()) {
+      try {
+        loop();
+        break;
+      } catch (...) {
+        restart_count++;
+        std::cerr << "Exception caught, restarting... (attempt "
+                  << restart_count << ")" << std::endl;
+        std::this_thread::sleep_for(std::chrono::milliseconds(kRestartDelayMs));
+      }
+    }
+    return true;
+  }
+
+  while (isRunning()) {
+#ifdef _WIN32
+    // windows: use CreateProcess to create child process
+    STARTUPINFOA si = {sizeof(si)};
+    PROCESS_INFORMATION pi = {0};
+
+    std::string cmd_line = "\"" + exe_path + "\" --child";
+    std::vector<char> cmd_line_buf(cmd_line.begin(), cmd_line.end());
+    cmd_line_buf.push_back('\0');
+
+    BOOL success = CreateProcessA(
+        nullptr,  // executable file path (specified in command line)
+        cmd_line_buf.data(),  // command line arguments
+        nullptr,              // process security attributes
+        nullptr,              // thread security attributes
+        FALSE,                // don't inherit handles
+        0,                    // creation flags
+        nullptr,              // environment variables (inherit from parent)
+        nullptr,              // current directory
+        &si,                  // startup info
+        &pi                   // process information
+    );
+
+    if (!success) {
+      std::cerr << "Failed to create child process, error: " << GetLastError()
+                << std::endl;
+      std::this_thread::sleep_for(std::chrono::milliseconds(kRestartDelayMs));
+      restart_count++;
+      continue;
+    }
+
+    while (isRunning()) {
+      DWORD wait_result = WaitForSingleObject(pi.hProcess, 200);
+      if (wait_result == WAIT_OBJECT_0) {
+        break;
+      }
+      if (wait_result == WAIT_FAILED) {
+        std::cerr << "Failed waiting child process, error: " << GetLastError()
+                  << std::endl;
+        break;
+      }
+    }
+
+    if (!isRunning()) {
+      TerminateProcess(pi.hProcess, 1);
+      WaitForSingleObject(pi.hProcess, 3000);
+    }
+
+    DWORD exit_code = 0;
+    GetExitCodeProcess(pi.hProcess, &exit_code);
+    CloseHandle(pi.hProcess);
+    CloseHandle(pi.hThread);
+
+    if (!isRunning() || exit_code == 0) {
+      break;  // normal exit
+    }
+    restart_count++;
+    std::cerr << "Child process exited with code " << exit_code
+              << ", restarting... (attempt " << restart_count << ")"
+              << std::endl;
+    std::this_thread::sleep_for(std::chrono::milliseconds(kRestartDelayMs));
+#else
+    // linux: use fork + exec to create child process
+    pid_t pid = fork();
+    if (pid == 0) {
+      execl(exe_path.c_str(), exe_path.c_str(), "--child", nullptr);
+      _exit(1);  // exec failed
+    } else if (pid > 0) {
+      int status = 0;
+      pid_t waited_pid = -1;
+      while (isRunning()) {
+        waited_pid = waitpid(pid, &status, WNOHANG);
+        if (waited_pid == pid) {
+          break;
+        }
+        if (waited_pid < 0 && errno != EINTR) {
+          break;
+        }
+        std::this_thread::sleep_for(
+            std::chrono::milliseconds(kWaitPollIntervalMs));
+      }
+
+      if (!isRunning() && waited_pid != pid) {
+        kill(pid, SIGTERM);
+        waited_pid = waitpid(pid, &status, 0);
+      }
+
+      if (waited_pid < 0) {
+        if (!isRunning()) {
+          break;
+        }
+        restart_count++;
+        std::cerr << "waitpid failed, errno: " << errno
+                  << ", restarting... (attempt " << restart_count << ")"
+                  << std::endl;
+        std::this_thread::sleep_for(std::chrono::milliseconds(kRestartDelayMs));
+        continue;
+      }
+
+      if (WIFEXITED(status)) {
+        int exit_code = WEXITSTATUS(status);
+        if (!isRunning() || exit_code == 0) {
+          break;  // normal exit
+        }
+        restart_count++;
+        std::cerr << "Child process exited with code " << exit_code
+                  << ", restarting... (attempt " << restart_count << ")"
+                  << std::endl;
+      } else if (WIFSIGNALED(status)) {
+        if (!isRunning()) {
+          break;
+        }
+        restart_count++;
+        std::cerr << "Child process crashed with signal " << WTERMSIG(status)
+                  << ", restarting... (attempt " << restart_count << ")"
+                  << std::endl;
+      } else {
+        restart_count++;
+        std::cerr << "Child process exited with unknown status, restarting... "
+                     "(attempt "
+                  << restart_count << ")" << std::endl;
+      }
+      std::this_thread::sleep_for(std::chrono::milliseconds(kRestartDelayMs));
+    } else {
+      std::cerr << "Failed to fork child process" << std::endl;
+      std::this_thread::sleep_for(std::chrono::milliseconds(kRestartDelayMs));
+      restart_count++;
+    }
+#endif
+  }
+
+  return true;
+}

src/app/daemon.h

@@ -0,0 +1,37 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2025-11-19
+ * Copyright (c) 2025 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _DAEMON_H_
+#define _DAEMON_H_
+
+#include <atomic>
+#include <csignal>
+#include <functional>
+#include <string>
+
+class Daemon {
+ public:
+  using MainLoopFunc = std::function<void()>;
+
+  Daemon(const std::string& name);
+
+  bool start(MainLoopFunc loop);
+
+  void stop();
+
+  bool isRunning() const;
+
+ private:
+  std::string name_;
+  bool runWithRestart(MainLoopFunc loop);
+
+#ifndef _WIN32
+  static volatile std::sig_atomic_t stop_requested_;
+#endif
+  std::atomic<bool> running_;
+};
+
+#endif

src/app/main.cpp

@@ -0,0 +1,63 @@
+#ifdef _WIN32
+#ifdef CROSSDESK_DEBUG
+#pragma comment(linker, "/subsystem:\"console\"")
+#else
+#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")
+#endif
+#endif
+
+#include <cstring>
+#include <memory>
+#include <string>
+
+#include "config_center.h"
+#include "daemon.h"
+#include "path_manager.h"
+#include "render.h"
+
+int main(int argc, char* argv[]) {
+  // check if running as child process
+  bool is_child = false;
+  for (int i = 1; i < argc; i++) {
+    if (strcmp(argv[i], "--child") == 0) {
+      is_child = true;
+      break;
+    }
+  }
+
+  if (is_child) {
+    // child process: run render directly
+    crossdesk::Render render;
+    render.Run();
+    return 0;
+  }
+
+  bool enable_daemon = false;
+  auto path_manager = std::make_unique<crossdesk::PathManager>("CrossDesk");
+  if (path_manager) {
+    std::string cache_path = path_manager->GetCachePath().string();
+    crossdesk::ConfigCenter config_center(cache_path + "/config.ini");
+    enable_daemon = config_center.IsEnableDaemon();
+  }
+
+  if (enable_daemon) {
+    // start daemon with restart monitoring
+    Daemon daemon("CrossDesk");
+
+    // define main loop function: run render and stop daemon on normal exit
+    Daemon::MainLoopFunc main_loop = [&daemon]() {
+      crossdesk::Render render;
+      render.Run();
+      daemon.stop();
+    };
+
+    // start daemon and return result
+    bool success = daemon.start(main_loop);
+    return success ? 0 : 1;
+  }
+
+  // run without daemon: direct execution
+  crossdesk::Render render;
+  render.Run();
+  return 0;
+}

src/autostart/autostart.cpp

@@ -0,0 +1,302 @@
+#include "autostart.h"
+
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+
+#ifdef _WIN32
+#include <windows.h>
+#elif defined(__APPLE__)
+#include <limits.h>
+#include <mach-o/dyld.h>
+#include <unistd.h>
+#elif defined(__linux__)
+#include <linux/limits.h>
+#include <unistd.h>
+#endif
+
+namespace crossdesk {
+
+static std::string get_home_dir() {
+  const char* home = std::getenv("HOME");
+  if (!home) {
+    return "";
+  }
+  return std::string(home);
+}
+
+static bool file_exists(const std::string& path) {
+  return std::filesystem::exists(path) &&
+         std::filesystem::is_regular_file(path);
+}
+
+static std::string GetExecutablePath() {
+#ifdef _WIN32
+  char path[32768];
+  DWORD length = GetModuleFileNameA(nullptr, path, sizeof(path));
+  if (length > 0 && length < sizeof(path)) {
+    return std::string(path);
+  }
+#elif defined(__APPLE__)
+  char path[1024];
+  uint32_t size = sizeof(path);
+  if (_NSGetExecutablePath(path, &size) == 0) {
+    char resolved_path[PATH_MAX];
+    if (realpath(path, resolved_path) != nullptr) {
+      return std::string(resolved_path);
+    }
+    return std::string(path);
+  }
+#elif defined(__linux__)
+  char path[PATH_MAX];
+  ssize_t count = readlink("/proc/self/exe", path, sizeof(path) - 1);
+  if (count != -1) {
+    path[count] = '\0';
+    return std::string(path);
+  }
+#endif
+  return "";
+}
+
+// Windows
+#ifdef _WIN32
+static constexpr const char* WINDOWS_RUN_KEY =
+    "Software\\Microsoft\\Windows\\CurrentVersion\\Run";
+
+static bool windows_enable(const std::string& appName,
+                           const std::string& exePath) {
+  if (exePath.empty() || !std::filesystem::exists(exePath)) {
+    return false;
+  }
+
+  HKEY hKey = nullptr;
+  // Use KEY_WRITE to ensure we have write permission
+  LONG result =
+      RegOpenKeyExA(HKEY_CURRENT_USER, WINDOWS_RUN_KEY, 0, KEY_WRITE, &hKey);
+  if (result != ERROR_SUCCESS) {
+    return false;
+  }
+
+  std::string regValue = exePath;
+  if (!exePath.empty() && exePath.find(' ') != std::string::npos) {
+    if (exePath.front() != '"' || exePath.back() != '"') {
+      regValue = "\"" + exePath + "\"";
+    }
+  }
+
+  // Ensure we close the key even if RegSetValueExA fails
+  result = RegSetValueExA(hKey, appName.c_str(), 0, REG_SZ,
+                          reinterpret_cast<const BYTE*>(regValue.c_str()),
+                          static_cast<DWORD>(regValue.size() + 1));
+  RegCloseKey(hKey);
+
+  return result == ERROR_SUCCESS;
+}
+
+static bool windows_disable(const std::string& appName) {
+  HKEY hKey = nullptr;
+  LONG result =
+      RegOpenKeyExA(HKEY_CURRENT_USER, WINDOWS_RUN_KEY, 0, KEY_WRITE, &hKey);
+  if (result != ERROR_SUCCESS) {
+    return false;
+  }
+
+  result = RegDeleteValueA(hKey, appName.c_str());
+  RegCloseKey(hKey);
+
+  // Return true even if the value doesn't exist (already disabled)
+  return result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND;
+}
+
+static bool windows_exists(const std::string& appName) {
+  HKEY hKey = nullptr;
+  LONG result =
+      RegOpenKeyExA(HKEY_CURRENT_USER, WINDOWS_RUN_KEY, 0, KEY_READ, &hKey);
+  if (result != ERROR_SUCCESS) {
+    return false;
+  }
+
+  result = RegQueryValueExA(hKey, appName.c_str(), nullptr, nullptr, nullptr,
+                            nullptr);
+  RegCloseKey(hKey);
+
+  return result == ERROR_SUCCESS;
+}
+#endif
+
+// Linux
+#if defined(__linux__)
+static std::string linux_desktop_path(const std::string& appName) {
+  std::string home = get_home_dir();
+  if (home.empty()) {
+    return "";
+  }
+  return home + "/.config/autostart/" + appName + ".desktop";
+}
+
+static bool linux_enable(const std::string& appName,
+                         const std::string& exePath) {
+  std::string home = get_home_dir();
+  if (home.empty()) {
+    return false;
+  }
+
+  std::filesystem::path dir =
+      std::filesystem::path(home) / ".config" / "autostart";
+
+  // Create directory if it doesn't exist
+  std::error_code ec;
+  std::filesystem::create_directories(dir, ec);
+  if (ec) {
+    return false;
+  }
+
+  std::string path = linux_desktop_path(appName);
+  if (path.empty()) {
+    return false;
+  }
+
+  std::ofstream file(path);
+  if (!file.is_open()) {
+    return false;
+  }
+
+  file << "[Desktop Entry]\n";
+  file << "Type=Application\n";
+  file << "Exec=" << exePath << "\n";
+  file << "Hidden=false\n";
+  file << "NoDisplay=false\n";
+  file << "X-GNOME-Autostart-enabled=true\n";
+  file << "Terminal=false\n";
+  file << "StartupNotify=false\n";
+  file << "Name=" << appName << "\n";
+  file.close();
+
+  return file.good();
+}
+
+static bool linux_disable(const std::string& appName) {
+  std::string path = linux_desktop_path(appName);
+  if (path.empty()) {
+    return false;
+  }
+
+  std::error_code ec;
+  return std::filesystem::remove(path, ec) && !ec;
+}
+
+static bool linux_exists(const std::string& appName) {
+  std::string path = linux_desktop_path(appName);
+  if (path.empty()) {
+    return false;
+  }
+  return file_exists(path);
+}
+#endif
+
+// macOS
+#ifdef __APPLE__
+static std::string mac_plist_path(const std::string& appName) {
+  std::string home = get_home_dir();
+  if (home.empty()) {
+    return "";
+  }
+  return home + "/Library/LaunchAgents/" + appName + ".plist";
+}
+
+static bool mac_enable(const std::string& appName, const std::string& exePath) {
+  std::string path = mac_plist_path(appName);
+  if (path.empty()) {
+    return false;
+  }
+
+  // Ensure LaunchAgents directory exists
+  std::filesystem::path dir =
+      std::filesystem::path(get_home_dir()) / "Library" / "LaunchAgents";
+  std::error_code ec;
+  std::filesystem::create_directories(dir, ec);
+  if (ec) {
+    return false;
+  }
+
+  std::ofstream file(path);
+  if (!file.is_open()) {
+    return false;
+  }
+
+  file << R"(<?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>Label</key>
+    <string>)"
+       << appName << R"(</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>)"
+       << exePath << R"(</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+</dict>
+</plist>)";
+  file.close();
+
+  return file.good();
+}
+
+static bool mac_disable(const std::string& appName) {
+  std::string path = mac_plist_path(appName);
+  if (path.empty()) {
+    return false;
+  }
+
+  std::error_code ec;
+  return std::filesystem::remove(path, ec) && !ec;
+}
+
+static bool mac_exists(const std::string& appName) {
+  std::string path = mac_plist_path(appName);
+  if (path.empty()) {
+    return false;
+  }
+  return file_exists(path);
+}
+#endif
+
+bool EnableAutostart(const std::string& appName) {
+  std::string exePath = GetExecutablePath();
+  if (exePath.empty()) {
+    return false;
+  }
+#ifdef _WIN32
+  return windows_enable(appName, exePath);
+#elif __APPLE__
+  return mac_enable(appName, exePath);
+#else
+  return linux_enable(appName, exePath);
+#endif
+}
+
+bool DisableAutostart(const std::string& appName) {
+#ifdef _WIN32
+  return windows_disable(appName);
+#elif __APPLE__
+  return mac_disable(appName);
+#else
+  return linux_disable(appName);
+#endif
+}
+
+bool IsAutostartEnabled(const std::string& appName) {
+#ifdef _WIN32
+  return windows_exists(appName);
+#elif __APPLE__
+  return mac_exists(appName);
+#else
+  return linux_exists(appName);
+#endif
+}
+
+}  // namespace crossdesk

src/autostart/autostart.h

@@ -0,0 +1,21 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2025-11-18
+ * Copyright (c) 2025 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _AUTOSTART_H_
+#define _AUTOSTART_H_
+
+#include <string>
+
+namespace crossdesk {
+
+bool EnableAutostart(const std::string& appName);
+
+bool DisableAutostart(const std::string& appName);
+
+bool IsAutostartEnabled(const std::string& appName);
+
+}  // namespace crossdesk
+#endif

src/common/any_invocable.h

@@ -1,87 +0,0 @@
-/*
- * @Author: DI JUNKUN
- * @Date: 2025-03-14
- * Copyright (c) 2025 by DI JUNKUN, All Rights Reserved.
- */
-
-#ifndef _ANY_INVOCABLE_H_
-#define _ANY_INVOCABLE_H_
-
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <type_traits>
-
-// 简化版的 AnyInvocable
-template <typename Signature>
-class AnyInvocable;
-
-template <typename R, typename... Args>
-class AnyInvocable<R(Args...)> {
- public:
-  // 默认构造函数
-  AnyInvocable() = default;
-
-  AnyInvocable(std::nullptr_t) noexcept : callable_(nullptr) {}
-
-  // 构造函数：接受一个可以调用的对象（排除 nullptr）
-  template <typename Callable, typename = std::enable_if_t<!std::is_same_v<
-                                   std::decay_t<Callable>, std::nullptr_t>>>
-  AnyInvocable(Callable&& callable)
-      : callable_(std::make_unique<CallableWrapper<Callable>>(
-            std::forward<Callable>(callable))) {}
-
-  // 调用运算符（支持 void 和非 void 返回类型）
-  R operator()(Args... args) {
-    if (!callable_) {
-      throw std::bad_function_call();
-    }
-    if constexpr (std::is_void_v<R>) {
-      callable_->Invoke(std::forward<Args>(args)...);
-    } else {
-      return callable_->Invoke(std::forward<Args>(args)...);
-    }
-  }
-
-  // 移动构造函数
-  AnyInvocable(AnyInvocable&&) = default;
-  // 移动赋值运算符
-  AnyInvocable& operator=(AnyInvocable&&) = default;
-
-  // 判断是否有效
-  explicit operator bool() const { return static_cast<bool>(callable_); }
-
- private:
-  // 抽象基类，允许不同类型的可调用对象
-  struct CallableBase {
-    virtual ~CallableBase() = default;
-    virtual R Invoke(Args&&... args) = 0;
-  };
-
-  // 模板派生类：实际存储 callable 对象
-  template <typename Callable>
-  struct CallableWrapper : public CallableBase {
-    CallableWrapper(Callable&& callable)
-        : callable_(std::forward<Callable>(callable)) {}
-
-    R Invoke(Args&&... args) override {
-      if constexpr (std::is_void_v<R>) {
-        callable_(std::forward<Args>(args)...);
-      } else {
-        return callable_(std::forward<Args>(args)...);
-      }
-    }
-
-    Callable callable_;
-  };
-
-  std::unique_ptr<CallableBase> callable_;
-};
-
-// 简单的包装函数
-template <typename R, typename... Args>
-AnyInvocable<R(Args...)> MakeMoveOnlyFunction(std::function<R(Args...)>&& f) {
-  return AnyInvocable<R(Args...)>(std::move(f));
-}
-
-#endif  // _ANY_INVOCABLE_H_

src/common/api/array_view.h

@@ -1,319 +0,0 @@
-/*
- *  Copyright 2015 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.
- */
-
-#ifndef API_ARRAY_VIEW_H_
-#define API_ARRAY_VIEW_H_
-
-#include <algorithm>
-#include <array>
-#include <cstddef>
-#include <iterator>
-#include <type_traits>
-
-#include "rtc_base/type_traits.h"
-
-namespace rtc {
-
-// tl;dr: rtc::ArrayView is the same thing as gsl::span from the Guideline
-//        Support Library.
-//
-// Many functions read from or write to arrays. The obvious way to do this is
-// to use two arguments, a pointer to the first element and an element count:
-//
-//   bool Contains17(const int* arr, size_t size) {
-//     for (size_t i = 0; i < size; ++i) {
-//       if (arr[i] == 17)
-//         return true;
-//     }
-//     return false;
-//   }
-//
-// This is flexible, since it doesn't matter how the array is stored (C array,
-// std::vector, rtc::Buffer, ...), but it's error-prone because the caller has
-// to correctly specify the array length:
-//
-//   Contains17(arr, arraysize(arr));     // C array
-//   Contains17(arr.data(), arr.size());  // std::vector
-//   Contains17(arr, size);               // pointer + size
-//   ...
-//
-// It's also kind of messy to have two separate arguments for what is
-// conceptually a single thing.
-//
-// Enter rtc::ArrayView<T>. It contains a T pointer (to an array it doesn't
-// own) and a count, and supports the basic things you'd expect, such as
-// indexing and iteration. It allows us to write our function like this:
-//
-//   bool Contains17(rtc::ArrayView<const int> arr) {
-//     for (auto e : arr) {
-//       if (e == 17)
-//         return true;
-//     }
-//     return false;
-//   }
-//
-// And even better, because a bunch of things will implicitly convert to
-// ArrayView, we can call it like this:
-//
-//   Contains17(arr);                             // C array
-//   Contains17(arr);                             // std::vector
-//   Contains17(rtc::ArrayView<int>(arr, size));  // pointer + size
-//   Contains17(nullptr);                         // nullptr -> empty ArrayView
-//   ...
-//
-// ArrayView<T> stores both a pointer and a size, but you may also use
-// ArrayView<T, N>, which has a size that's fixed at compile time (which means
-// it only has to store the pointer).
-//
-// One important point is that ArrayView<T> and ArrayView<const T> are
-// different types, which allow and don't allow mutation of the array elements,
-// respectively. The implicit conversions work just like you'd hope, so that
-// e.g. vector<int> will convert to either ArrayView<int> or ArrayView<const
-// int>, but const vector<int> will convert only to ArrayView<const int>.
-// (ArrayView itself can be the source type in such conversions, so
-// ArrayView<int> will convert to ArrayView<const int>.)
-//
-// Note: ArrayView is tiny (just a pointer and a count if variable-sized, just
-// a pointer if fix-sized) and trivially copyable, so it's probably cheaper to
-// pass it by value than by const reference.
-
-namespace array_view_internal {
-
-// Magic constant for indicating that the size of an ArrayView is variable
-// instead of fixed.
-enum : std::ptrdiff_t { kArrayViewVarSize = -4711 };
-
-// Base class for ArrayViews of fixed nonzero size.
-template <typename T, std::ptrdiff_t Size>
-class ArrayViewBase {
-  static_assert(Size > 0, "ArrayView size must be variable or non-negative");
-
- public:
-  ArrayViewBase(T* data, size_t /* size */) : data_(data) {}
-
-  static constexpr size_t size() { return Size; }
-  static constexpr bool empty() { return false; }
-  T* data() const { return data_; }
-
- protected:
-  static constexpr bool fixed_size() { return true; }
-
- private:
-  T* data_;
-};
-
-// Specialized base class for ArrayViews of fixed zero size.
-template <typename T>
-class ArrayViewBase<T, 0> {
- public:
-  explicit ArrayViewBase(T* /* data */, size_t /* size */) {}
-
-  static constexpr size_t size() { return 0; }
-  static constexpr bool empty() { return true; }
-  T* data() const { return nullptr; }
-
- protected:
-  static constexpr bool fixed_size() { return true; }
-};
-
-// Specialized base class for ArrayViews of variable size.
-template <typename T>
-class ArrayViewBase<T, array_view_internal::kArrayViewVarSize> {
- public:
-  ArrayViewBase(T* data, size_t size)
-      : data_(size == 0 ? nullptr : data), size_(size) {}
-
-  size_t size() const { return size_; }
-  bool empty() const { return size_ == 0; }
-  T* data() const { return data_; }
-
- protected:
-  static constexpr bool fixed_size() { return false; }
-
- private:
-  T* data_;
-  size_t size_;
-};
-
-}  // namespace array_view_internal
-
-template <typename T,
-          std::ptrdiff_t Size = array_view_internal::kArrayViewVarSize>
-class ArrayView final : public array_view_internal::ArrayViewBase<T, Size> {
- public:
-  using value_type = T;
-  using reference = value_type&;
-  using const_reference = const value_type&;
-  using pointer = value_type*;
-  using const_pointer = const value_type*;
-  using const_iterator = const T*;
-
-  // Construct an ArrayView from a pointer and a length.
-  template <typename U>
-  ArrayView(U* data, size_t size)
-      : array_view_internal::ArrayViewBase<T, Size>::ArrayViewBase(data, size) {
-  }
-
-  // Construct an empty ArrayView. Note that fixed-size ArrayViews of size > 0
-  // cannot be empty.
-  ArrayView() : ArrayView(nullptr, 0) {}
-  ArrayView(std::nullptr_t)  // NOLINT
-      : ArrayView() {}
-  ArrayView(std::nullptr_t, size_t size)
-      : ArrayView(static_cast<T*>(nullptr), size) {
-    static_assert(Size == 0 || Size == array_view_internal::kArrayViewVarSize,
-                  "");
-  }
-
-  // Construct an ArrayView from a C-style array.
-  template <typename U, size_t N>
-  ArrayView(U (&array)[N])  // NOLINT
-      : ArrayView(array, N) {
-    static_assert(Size == N || Size == array_view_internal::kArrayViewVarSize,
-                  "Array size must match ArrayView size");
-  }
-
-  // (Only if size is fixed.) Construct a fixed size ArrayView<T, N> from a
-  // non-const std::array instance. For an ArrayView with variable size, the
-  // used ctor is ArrayView(U& u) instead.
-  template <typename U, size_t N,
-            typename std::enable_if<
-                Size == static_cast<std::ptrdiff_t>(N)>::type* = nullptr>
-  ArrayView(std::array<U, N>& u)  // NOLINT
-      : ArrayView(u.data(), u.size()) {}
-
-  // (Only if size is fixed.) Construct a fixed size ArrayView<T, N> where T is
-  // const from a const(expr) std::array instance. For an ArrayView with
-  // variable size, the used ctor is ArrayView(U& u) instead.
-  template <typename U, size_t N,
-            typename std::enable_if<
-                Size == static_cast<std::ptrdiff_t>(N)>::type* = nullptr>
-  ArrayView(const std::array<U, N>& u)  // NOLINT
-      : ArrayView(u.data(), u.size()) {}
-
-  // (Only if size is fixed.) Construct an ArrayView from any type U that has a
-  // static constexpr size() method whose return value is equal to Size, and a
-  // data() method whose return value converts implicitly to T*. In particular,
-  // this means we allow conversion from ArrayView<T, N> to ArrayView<const T,
-  // N>, but not the other way around. We also don't allow conversion from
-  // ArrayView<T> to ArrayView<T, N>, or from ArrayView<T, M> to ArrayView<T,
-  // N> when M != N.
-  template <typename U, typename std::enable_if<
-                            Size != array_view_internal::kArrayViewVarSize &&
-                            HasDataAndSize<U, T>::value>::type* = nullptr>
-  ArrayView(U& u)  // NOLINT
-      : ArrayView(u.data(), u.size()) {
-    static_assert(U::size() == Size, "Sizes must match exactly");
-  }
-  template <typename U, typename std::enable_if<
-                            Size != array_view_internal::kArrayViewVarSize &&
-                            HasDataAndSize<U, T>::value>::type* = nullptr>
-  ArrayView(const U& u)  // NOLINT(runtime/explicit)
-      : ArrayView(u.data(), u.size()) {
-    static_assert(U::size() == Size, "Sizes must match exactly");
-  }
-
-  // (Only if size is variable.) Construct an ArrayView from any type U that
-  // has a size() method whose return value converts implicitly to size_t, and
-  // a data() method whose return value converts implicitly to T*. In
-  // particular, this means we allow conversion from ArrayView<T> to
-  // ArrayView<const T>, but not the other way around. Other allowed
-  // conversions include
-  // ArrayView<T, N> to ArrayView<T> or ArrayView<const T>,
-  // std::vector<T> to ArrayView<T> or ArrayView<const T>,
-  // const std::vector<T> to ArrayView<const T>,
-  // rtc::Buffer to ArrayView<uint8_t> or ArrayView<const uint8_t>, and
-  // const rtc::Buffer to ArrayView<const uint8_t>.
-  template <typename U, typename std::enable_if<
-                            Size == array_view_internal::kArrayViewVarSize &&
-                            HasDataAndSize<U, T>::value>::type* = nullptr>
-  ArrayView(U& u)  // NOLINT
-      : ArrayView(u.data(), u.size()) {}
-  template <typename U, typename std::enable_if<
-                            Size == array_view_internal::kArrayViewVarSize &&
-                            HasDataAndSize<U, T>::value>::type* = nullptr>
-  ArrayView(const U& u)  // NOLINT(runtime/explicit)
-      : ArrayView(u.data(), u.size()) {}
-
-  // Indexing and iteration. These allow mutation even if the ArrayView is
-  // const, because the ArrayView doesn't own the array. (To prevent mutation,
-  // use a const element type.)
-  T& operator[](size_t idx) const { return this->data()[idx]; }
-  T* begin() const { return this->data(); }
-  T* end() const { return this->data() + this->size(); }
-  const T* cbegin() const { return this->data(); }
-  const T* cend() const { return this->data() + this->size(); }
-  std::reverse_iterator<T*> rbegin() const {
-    return std::make_reverse_iterator(end());
-  }
-  std::reverse_iterator<T*> rend() const {
-    return std::make_reverse_iterator(begin());
-  }
-  std::reverse_iterator<const T*> crbegin() const {
-    return std::make_reverse_iterator(cend());
-  }
-  std::reverse_iterator<const T*> crend() const {
-    return std::make_reverse_iterator(cbegin());
-  }
-
-  ArrayView<T> subview(size_t offset, size_t size) const {
-    return offset < this->size()
-               ? ArrayView<T>(this->data() + offset,
-                              std::min(size, this->size() - offset))
-               : ArrayView<T>();
-  }
-  ArrayView<T> subview(size_t offset) const {
-    return subview(offset, this->size());
-  }
-};
-
-// Comparing two ArrayViews compares their (pointer,size) pairs; it does *not*
-// dereference the pointers.
-template <typename T, std::ptrdiff_t Size1, std::ptrdiff_t Size2>
-bool operator==(const ArrayView<T, Size1>& a, const ArrayView<T, Size2>& b) {
-  return a.data() == b.data() && a.size() == b.size();
-}
-template <typename T, std::ptrdiff_t Size1, std::ptrdiff_t Size2>
-bool operator!=(const ArrayView<T, Size1>& a, const ArrayView<T, Size2>& b) {
-  return !(a == b);
-}
-
-// Variable-size ArrayViews are the size of two pointers; fixed-size ArrayViews
-// are the size of one pointer. (And as a special case, fixed-size ArrayViews
-// of size 0 require no storage.)
-static_assert(sizeof(ArrayView<int>) == 2 * sizeof(int*), "");
-static_assert(sizeof(ArrayView<int, 17>) == sizeof(int*), "");
-static_assert(std::is_empty<ArrayView<int, 0>>::value, "");
-
-template <typename T>
-inline ArrayView<T> MakeArrayView(T* data, size_t size) {
-  return ArrayView<T>(data, size);
-}
-
-// Only for primitive types that have the same size and aligment.
-// Allow reinterpret cast of the array view to another primitive type of the
-// same size.
-// Template arguments order is (U, T, Size) to allow deduction of the template
-// arguments in client calls: reinterpret_array_view<target_type>(array_view).
-template <typename U, typename T, std::ptrdiff_t Size>
-inline ArrayView<U, Size> reinterpret_array_view(ArrayView<T, Size> view) {
-  static_assert(sizeof(U) == sizeof(T) && alignof(U) == alignof(T),
-                "ArrayView reinterpret_cast is only supported for casting "
-                "between views that represent the same chunk of memory.");
-  static_assert(
-      std::is_fundamental<T>::value && std::is_fundamental<U>::value,
-      "ArrayView reinterpret_cast is only supported for casting between "
-      "fundamental types.");
-  return ArrayView<U, Size>(reinterpret_cast<U*>(view.data()), view.size());
-}
-
-}  // namespace rtc
-
-#endif  // API_ARRAY_VIEW_H_

src/common/api/clock/clock.cc

@@ -1,93 +0,0 @@
-/*
- *  Copyright (c) 2013 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 "api/clock/clock.h"
-
-#include "rtc_base/time_utils.h"
-
-namespace webrtc {
-namespace {
-
-int64_t NtpOffsetUsCalledOnce() {
-  constexpr int64_t kNtpJan1970Sec = 2208988800;
-  int64_t clock_time = rtc::TimeMicros();
-  int64_t utc_time = rtc::TimeUTCMicros();
-  return utc_time - clock_time + kNtpJan1970Sec * rtc::kNumMicrosecsPerSec;
-}
-
-NtpTime TimeMicrosToNtp(int64_t time_us) {
-  static int64_t ntp_offset_us = NtpOffsetUsCalledOnce();
-
-  int64_t time_ntp_us = time_us + ntp_offset_us;
-
-  // Convert seconds to uint32 through uint64 for a well-defined cast.
-  // A wrap around, which will happen in 2036, is expected for NTP time.
-  uint32_t ntp_seconds =
-      static_cast<uint64_t>(time_ntp_us / rtc::kNumMicrosecsPerSec);
-
-  // Scale fractions of the second to NTP resolution.
-  constexpr int64_t kNtpFractionsInSecond = 1LL << 32;
-  int64_t us_fractions = time_ntp_us % rtc::kNumMicrosecsPerSec;
-  uint32_t ntp_fractions =
-      us_fractions * kNtpFractionsInSecond / rtc::kNumMicrosecsPerSec;
-
-  return NtpTime(ntp_seconds, ntp_fractions);
-}
-
-}  // namespace
-
-class WebrtcClock : public Clock {
- public:
-  WebrtcClock(std::shared_ptr<SystemClock> system_clock)
-      : system_clock_(system_clock) {}
-  WebrtcClock() = delete;
-
-  Timestamp CurrentTime() override {
-    return Timestamp::Micros(system_clock_->CurrentTimeUs());
-  }
-
-  NtpTime ConvertTimestampToNtpTime(Timestamp timestamp) override {
-    int64_t time_us = timestamp.us();
-    constexpr int64_t kNtpJan1970Sec = 2208988800;
-    int64_t clock_time = system_clock_->CurrentTimeUs();
-    int64_t utc_time = system_clock_->CurrentUtcTimeUs();
-    static int64_t ntp_offset_us =
-        utc_time - clock_time + kNtpJan1970Sec * rtc::kNumMicrosecsPerSec;
-
-    int64_t time_ntp_us = time_us + ntp_offset_us;
-
-    // Convert seconds to uint32 through uint64 for a well-defined cast.
-    // A wrap around, which will happen in 2036, is expected for NTP time.
-    uint32_t ntp_seconds =
-        static_cast<uint64_t>(time_ntp_us / rtc::kNumMicrosecsPerSec);
-
-    // Scale fractions of the second to NTP resolution.
-    constexpr int64_t kNtpFractionsInSecond = 1LL << 32;
-    int64_t us_fractions = time_ntp_us % rtc::kNumMicrosecsPerSec;
-    uint32_t ntp_fractions =
-        us_fractions * kNtpFractionsInSecond / rtc::kNumMicrosecsPerSec;
-
-    return NtpTime(ntp_seconds, ntp_fractions);
-  }
-
- private:
-  std::shared_ptr<SystemClock> system_clock_;
-};
-
-Clock* Clock::GetWebrtcClock(std::shared_ptr<SystemClock> system_clock) {
-  static Clock* const clock = new WebrtcClock(system_clock);
-  return clock;
-}
-
-std::shared_ptr<Clock> Clock::GetWebrtcClockShared(
-    std::shared_ptr<SystemClock> system_clock) {
-  return std::make_shared<WebrtcClock>(system_clock);
-}
-}  // namespace webrtc

src/common/api/clock/clock.h

@@ -1,76 +0,0 @@
-/*
- *  Copyright (c) 2013 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.
- */
-
-#ifndef SYSTEM_WRAPPERS_INCLUDE_CLOCK_H_
-#define SYSTEM_WRAPPERS_INCLUDE_CLOCK_H_
-
-#include <stdint.h>
-
-#include <atomic>
-#include <memory>
-
-#include "api/ntp/ntp_time.h"
-#include "api/units/timestamp.h"
-#include "clock/system_clock.h"
-
-namespace webrtc {
-
-// January 1970, in NTP seconds.
-const uint32_t kNtpJan1970 = 2208988800UL;
-
-// Magic NTP fractional unit.
-const double kMagicNtpFractionalUnit = 4.294967296E+9;
-
-// A clock interface that allows reading of absolute and relative timestamps.
-class Clock {
- public:
-  virtual ~Clock() {}
-
-  // Return a timestamp relative to an unspecified epoch.
-  virtual Timestamp CurrentTime() = 0;
-  int64_t TimeInMilliseconds() { return CurrentTime().ms(); }
-  int64_t TimeInMicroseconds() { return CurrentTime().us(); }
-
-  // Retrieve an NTP absolute timestamp (with an epoch of Jan 1, 1900).
-  NtpTime CurrentNtpTime() { return ConvertTimestampToNtpTime(CurrentTime()); }
-  int64_t CurrentNtpInMilliseconds() { return CurrentNtpTime().ToMs(); }
-
-  // Converts between a relative timestamp returned by this clock, to NTP time.
-  virtual NtpTime ConvertTimestampToNtpTime(Timestamp timestamp) = 0;
-  int64_t ConvertTimestampToNtpTimeInMilliseconds(int64_t timestamp_ms) {
-    return ConvertTimestampToNtpTime(Timestamp::Millis(timestamp_ms)).ToMs();
-  }
-
-  // Converts NtpTime to a Timestamp with UTC epoch.
-  // A `Minus Infinity` Timestamp is returned if the NtpTime is invalid.
-  static Timestamp NtpToUtc(NtpTime ntp_time) {
-    if (!ntp_time.Valid()) {
-      return Timestamp::MinusInfinity();
-    }
-    // Seconds since UTC epoch.
-    int64_t time = ntp_time.seconds() - kNtpJan1970;
-    // Microseconds since UTC epoch (not including NTP fraction)
-    time = time * 1'000'000;
-    // Fractions part of the NTP time, in microseconds.
-    int64_t time_fraction =
-        DivideRoundToNearest(int64_t{ntp_time.fractions()} * 1'000'000,
-                             NtpTime::kFractionsPerSecond);
-    return Timestamp::Micros(time + time_fraction);
-  }
-
-  // Returns an instance of the real-time system clock implementation.
-  static Clock* GetWebrtcClock(std::shared_ptr<SystemClock> system_clock);
-  static std::shared_ptr<Clock> GetWebrtcClockShared(
-      std::shared_ptr<SystemClock> system_clock);
-};
-
-}  // namespace webrtc
-
-#endif  // SYSTEM_WRAPPERS_INCLUDE_CLOCK_H_

src/common/api/function_view.h

@@ -1,127 +0,0 @@
-/*
- *  Copyright 2016 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.
- */
-
-#ifndef API_FUNCTION_VIEW_H_
-#define API_FUNCTION_VIEW_H_
-
-#include <cstddef>
-#include <type_traits>
-#include <utility>
-
-// Just like std::function, FunctionView will wrap any callable and hide its
-// actual type, exposing only its signature. But unlike std::function,
-// FunctionView doesn't own its callable---it just points to it. Thus, it's a
-// good choice mainly as a function argument when the callable argument will
-// not be called again once the function has returned.
-//
-// Its constructors are implicit, so that callers won't have to convert lambdas
-// and other callables to FunctionView<Blah(Blah, Blah)> explicitly. This is
-// safe because FunctionView is only a reference to the real callable.
-//
-// Example use:
-//
-//   void SomeFunction(rtc::FunctionView<int(int)> index_transform);
-//   ...
-//   SomeFunction([](int i) { return 2 * i + 1; });
-//
-// Note: FunctionView is tiny (essentially just two pointers) and trivially
-// copyable, so it's probably cheaper to pass it by value than by const
-// reference.
-
-namespace rtc {
-
-template <typename T>
-class FunctionView;  // Undefined.
-
-template <typename RetT, typename... ArgT>
-class FunctionView<RetT(ArgT...)> final {
- public:
-  // Constructor for lambdas and other callables; it accepts every type of
-  // argument except those noted in its enable_if call.
-  template <
-      typename F,
-      typename std::enable_if<
-          // Not for function pointers; we have another constructor for that
-          // below.
-          !std::is_function<typename std::remove_pointer<
-              typename std::remove_reference<F>::type>::type>::value &&
-
-          // Not for nullptr; we have another constructor for that below.
-          !std::is_same<std::nullptr_t,
-                        typename std::remove_cv<F>::type>::value &&
-
-          // Not for FunctionView objects; we have another constructor for that
-          // (the implicitly declared copy constructor).
-          !std::is_same<FunctionView,
-                        typename std::remove_cv<typename std::remove_reference<
-                            F>::type>::type>::value>::type* = nullptr>
-  FunctionView(F&& f)
-      : call_(CallVoidPtr<typename std::remove_reference<F>::type>) {
-    f_.void_ptr = &f;
-  }
-
-  // Constructor that accepts function pointers. If the argument is null, the
-  // result is an empty FunctionView.
-  template <
-      typename F,
-      typename std::enable_if<std::is_function<typename std::remove_pointer<
-          typename std::remove_reference<F>::type>::type>::value>::type* =
-          nullptr>
-  FunctionView(F&& f)
-      : call_(f ? CallFunPtr<typename std::remove_pointer<F>::type> : nullptr) {
-    f_.fun_ptr = reinterpret_cast<void (*)()>(f);
-  }
-
-  // Constructor that accepts nullptr. It creates an empty FunctionView.
-  template <typename F, typename std::enable_if<std::is_same<
-                            std::nullptr_t, typename std::remove_cv<F>::type>::
-                                                    value>::type* = nullptr>
-  FunctionView(F&& /* f */) : call_(nullptr) {}
-
-  // Default constructor. Creates an empty FunctionView.
-  FunctionView() : call_(nullptr) {}
-
-  RetT operator()(ArgT... args) const {
-    return call_(f_, std::forward<ArgT>(args)...);
-  }
-
-  // Returns true if we have a function, false if we don't (i.e., we're null).
-  explicit operator bool() const { return !!call_; }
-
- private:
-  union VoidUnion {
-    void* void_ptr;
-    void (*fun_ptr)();
-  };
-
-  template <typename F>
-  static RetT CallVoidPtr(VoidUnion vu, ArgT... args) {
-    return (*static_cast<F*>(vu.void_ptr))(std::forward<ArgT>(args)...);
-  }
-  template <typename F>
-  static RetT CallFunPtr(VoidUnion vu, ArgT... args) {
-    return (reinterpret_cast<typename std::add_pointer<F>::type>(vu.fun_ptr))(
-        std::forward<ArgT>(args)...);
-  }
-
-  // A pointer to the callable thing, with type information erased. It's a
-  // union because we have to use separate types depending on if the callable
-  // thing is a function pointer or something else.
-  VoidUnion f_;
-
-  // Pointer to a dispatch function that knows the type of the callable thing
-  // that's stored in f_, and how to call it. A FunctionView object is empty
-  // (null) iff call_ is null.
-  RetT (*call_)(VoidUnion, ArgT...);
-};
-
-}  // namespace rtc
-
-#endif  // API_FUNCTION_VIEW_H_

src/common/api/media_types.h

@@ -1,42 +0,0 @@
-/*
- *  Copyright 2016 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.
- */
-
-#ifndef API_MEDIA_TYPES_H_
-#define API_MEDIA_TYPES_H_
-
-#include <string>
-
-// The cricket and webrtc have separate definitions for what a media type is.
-// They're not compatible. Watch out for this.
-
-namespace cricket {
-
-enum MediaType {
-  MEDIA_TYPE_AUDIO,
-  MEDIA_TYPE_VIDEO,
-  MEDIA_TYPE_DATA,
-  MEDIA_TYPE_UNSUPPORTED
-};
-
-extern const char kMediaTypeAudio[];
-extern const char kMediaTypeVideo[];
-extern const char kMediaTypeData[];
-
-std::string MediaTypeToString(MediaType type);
-
-}  // namespace cricket
-
-namespace webrtc {
-
-enum class MediaType { ANY, AUDIO, VIDEO, DATA };
-
-}  // namespace webrtc
-
-#endif  // API_MEDIA_TYPES_H_

src/common/api/network_state_predictor.h

@@ -1,51 +0,0 @@
-/*
- *  Copyright (c) 2019 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.
- */
-
-#ifndef API_NETWORK_STATE_PREDICTOR_H_
-#define API_NETWORK_STATE_PREDICTOR_H_
-
-#include <cstdint>
-#include <memory>
-
-#include "api/transport/bandwidth_usage.h"
-
-namespace webrtc {
-
-// TODO(yinwa): work in progress. API in class NetworkStatePredictor should not
-// be used by other users until this comment is removed.
-
-// NetworkStatePredictor predict network state based on current network metrics.
-// Usage:
-// Setup by calling Initialize.
-// For each update, call Update. Update returns network state
-// prediction.
-class NetworkStatePredictor {
- public:
-  virtual ~NetworkStatePredictor() {}
-
-  // Returns current network state prediction.
-  // Inputs:  send_time_ms - packet send time.
-  //          arrival_time_ms - packet arrival time.
-  //          network_state - computed network state.
-  virtual BandwidthUsage Update(int64_t send_time_ms,
-                                int64_t arrival_time_ms,
-                                BandwidthUsage network_state) = 0;
-};
-
-class NetworkStatePredictorFactoryInterface {
- public:
-  virtual std::unique_ptr<NetworkStatePredictor>
-  CreateNetworkStatePredictor() = 0;
-  virtual ~NetworkStatePredictorFactoryInterface() = default;
-};
-
-}  // namespace webrtc
-
-#endif  // API_NETWORK_STATE_PREDICTOR_H_

src/common/api/ntp/ntp_time.h

@@ -1,136 +0,0 @@
-/*
- *  Copyright (c) 2015 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.
- */
-#ifndef SYSTEM_WRAPPERS_INCLUDE_NTP_TIME_H_
-#define SYSTEM_WRAPPERS_INCLUDE_NTP_TIME_H_
-
-#include <cmath>
-#include <cstdint>
-#include <limits>
-
-#include "rtc_base/numerics/safe_conversions.h"
-
-namespace webrtc {
-
-class NtpTime {
- public:
-  static constexpr uint64_t kFractionsPerSecond = 0x100000000;
-  NtpTime() : value_(0) {}
-  explicit NtpTime(uint64_t value) : value_(value) {}
-  NtpTime(uint32_t seconds, uint32_t fractions)
-      : value_(seconds * kFractionsPerSecond + fractions) {}
-
-  NtpTime(const NtpTime&) = default;
-  NtpTime& operator=(const NtpTime&) = default;
-  explicit operator uint64_t() const { return value_; }
-
-  void Set(uint32_t seconds, uint32_t fractions) {
-    value_ = seconds * kFractionsPerSecond + fractions;
-  }
-  void Reset() { value_ = 0; }
-
-  int64_t ToMs() const {
-    static constexpr double kNtpFracPerMs = 4.294967296E6;  // 2^32 / 1000.
-    const double frac_ms = static_cast<double>(fractions()) / kNtpFracPerMs;
-    return 1000 * static_cast<int64_t>(seconds()) +
-           static_cast<int64_t>(frac_ms + 0.5);
-  }
-  // NTP standard (RFC1305, section 3.1) explicitly state value 0 is invalid.
-  bool Valid() const { return value_ != 0; }
-
-  uint32_t seconds() const {
-    return rtc::dchecked_cast<uint32_t>(value_ / kFractionsPerSecond);
-  }
-  uint32_t fractions() const {
-    return rtc::dchecked_cast<uint32_t>(value_ % kFractionsPerSecond);
-  }
-
- private:
-  uint64_t value_;
-};
-
-inline bool operator==(const NtpTime& n1, const NtpTime& n2) {
-  return static_cast<uint64_t>(n1) == static_cast<uint64_t>(n2);
-}
-inline bool operator!=(const NtpTime& n1, const NtpTime& n2) {
-  return !(n1 == n2);
-}
-
-// Converts `int64_t` milliseconds to Q32.32-formatted fixed-point seconds.
-// Performs clamping if the result overflows or underflows.
-inline int64_t Int64MsToQ32x32(int64_t milliseconds) {
-  // TODO(bugs.webrtc.org/10893): Change to use `rtc::saturated_cast` once the
-  // bug has been fixed.
-  double result =
-      std::round(milliseconds * (NtpTime::kFractionsPerSecond / 1000.0));
-
-  // Explicitly cast values to double to avoid implicit conversion warnings
-  // The conversion of the std::numeric_limits<int64_t>::max() triggers
-  // -Wimplicit-int-float-conversion warning in clang 10.0.0 without explicit
-  // cast
-  if (result <= static_cast<double>(std::numeric_limits<int64_t>::min())) {
-    return std::numeric_limits<int64_t>::min();
-  }
-
-  if (result >= static_cast<double>(std::numeric_limits<int64_t>::max())) {
-    return std::numeric_limits<int64_t>::max();
-  }
-
-  return rtc::dchecked_cast<int64_t>(result);
-}
-
-// Converts `int64_t` milliseconds to UQ32.32-formatted fixed-point seconds.
-// Performs clamping if the result overflows or underflows.
-inline uint64_t Int64MsToUQ32x32(int64_t milliseconds) {
-  // TODO(bugs.webrtc.org/10893): Change to use `rtc::saturated_cast` once the
-  // bug has been fixed.
-  double result =
-      std::round(milliseconds * (NtpTime::kFractionsPerSecond / 1000.0));
-
-  // Explicitly cast values to double to avoid implicit conversion warnings
-  // The conversion of the std::numeric_limits<int64_t>::max() triggers
-  // -Wimplicit-int-float-conversion warning in clang 10.0.0 without explicit
-  // cast
-  if (result <= static_cast<double>(std::numeric_limits<uint64_t>::min())) {
-    return std::numeric_limits<uint64_t>::min();
-  }
-
-  if (result >= static_cast<double>(std::numeric_limits<uint64_t>::max())) {
-    return std::numeric_limits<uint64_t>::max();
-  }
-
-  return rtc::dchecked_cast<uint64_t>(result);
-}
-
-// Converts Q32.32-formatted fixed-point seconds to `int64_t` milliseconds.
-inline int64_t Q32x32ToInt64Ms(int64_t q32x32) {
-  return rtc::dchecked_cast<int64_t>(
-      std::round(q32x32 * (1000.0 / NtpTime::kFractionsPerSecond)));
-}
-
-// Converts UQ32.32-formatted fixed-point seconds to `int64_t` milliseconds.
-inline int64_t UQ32x32ToInt64Ms(uint64_t q32x32) {
-  return rtc::dchecked_cast<int64_t>(
-      std::round(q32x32 * (1000.0 / NtpTime::kFractionsPerSecond)));
-}
-
-// Converts UQ32.32-formatted fixed-point seconds to `int64_t` microseconds.
-inline int64_t UQ32x32ToInt64Us(uint64_t q32x32) {
-  return rtc::dchecked_cast<int64_t>(
-      std::round(q32x32 * (1'000'000.0 / NtpTime::kFractionsPerSecond)));
-}
-
-// Converts Q32.32-formatted fixed-point seconds to `int64_t` microseconds.
-inline int64_t Q32x32ToInt64Us(int64_t q32x32) {
-  return rtc::dchecked_cast<int64_t>(
-      std::round(q32x32 * (1'000'000.0 / NtpTime::kFractionsPerSecond)));
-}
-
-}  // namespace webrtc
-#endif  // SYSTEM_WRAPPERS_INCLUDE_NTP_TIME_H_

src/common/api/ntp/ntp_time_util.cc

@@ -1,59 +0,0 @@
-/*
- *  Copyright (c) 2016 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 "api/ntp/ntp_time_util.h"
-
-#include <algorithm>
-#include <cstdint>
-
-#include "api/units/time_delta.h"
-#include "rtc_base/numerics/divide_round.h"
-#include "rtc_base/time_utils.h"
-
-namespace webrtc {
-
-uint32_t SaturatedToCompactNtp(TimeDelta delta) {
-  constexpr uint32_t kMaxCompactNtp = 0xFFFFFFFF;
-  constexpr int kCompactNtpInSecond = 0x10000;
-  if (delta <= TimeDelta::Zero()) return 0;
-  if (delta.us() >=
-      kMaxCompactNtp * rtc::kNumMicrosecsPerSec / kCompactNtpInSecond)
-    return kMaxCompactNtp;
-  // To convert to compact ntp need to divide by 1e6 to get seconds,
-  // then multiply by 0x10000 to get the final result.
-  // To avoid float operations, multiplication and division swapped.
-  return DivideRoundToNearest(delta.us() * kCompactNtpInSecond,
-                              rtc::kNumMicrosecsPerSec);
-}
-
-TimeDelta CompactNtpIntervalToTimeDelta(uint32_t compact_ntp_interval) {
-  // Convert to 64bit value to avoid multiplication overflow.
-  int64_t value = int64_t{compact_ntp_interval};
-  if (compact_ntp_interval > 0x8000'0000) {
-    value -= (int64_t{1} << 32);
-  }
-  // To convert to TimeDelta need to divide by 2^16 to get seconds,
-  // then multiply by 1'000'000 to get microseconds. To avoid float operations,
-  // multiplication and division are swapped.
-  int64_t us = DivideRoundToNearest(value * rtc::kNumMicrosecsPerSec, 1 << 16);
-  return TimeDelta::Micros(us);
-}
-
-TimeDelta CompactNtpRttToTimeDelta(uint32_t compact_ntp_interval) {
-  static constexpr TimeDelta kMinRtt = TimeDelta::Millis(1);
-  // Interval to convert expected to be positive, e.g. RTT or delay.
-  // Because interval can be derived from non-monotonic ntp clock,
-  // it might become negative that is indistinguishable from very large values.
-  // Since very large RTT/delay is less likely than non-monotonic ntp clock,
-  // such value is considered negative and converted to minimum value of 1ms.
-  // Small RTT value is considered too good to be true and increased to 1ms.
-  return std::max(CompactNtpIntervalToTimeDelta(compact_ntp_interval), kMinRtt);
-}
-}  // namespace webrtc

src/common/api/ntp/ntp_time_util.h

@@ -1,61 +0,0 @@
-/*
- *  Copyright (c) 2015 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.
- */
-
-#ifndef MODULES_RTP_RTCP_SOURCE_NTP_TIME_UTIL_H_
-#define MODULES_RTP_RTCP_SOURCE_NTP_TIME_UTIL_H_
-
-#include <stdint.h>
-
-#include "api/ntp/ntp_time.h"
-#include "api/units/time_delta.h"
-#include "rtc_base/numerics/safe_conversions.h"
-
-namespace webrtc {
-
-// Helper function for compact ntp representation:
-// RFC 3550, Section 4. Time Format.
-// Wallclock time is represented using the timestamp format of
-// the Network Time Protocol (NTP).
-// ...
-// In some fields where a more compact representation is
-// appropriate, only the middle 32 bits are used; that is, the low 16
-// bits of the integer part and the high 16 bits of the fractional part.
-inline uint32_t CompactNtp(NtpTime ntp) {
-  return (ntp.seconds() << 16) | (ntp.fractions() >> 16);
-}
-
-// Converts interval to compact ntp (1/2^16 seconds) resolution.
-// Negative values converted to 0, Overlarge values converted to max uint32_t.
-uint32_t SaturatedToCompactNtp(TimeDelta delta);
-
-// Convert interval to the NTP time resolution (1/2^32 seconds ~= 0.2 ns).
-// For deltas with absolute value larger than 35 minutes result is unspecified.
-inline constexpr int64_t ToNtpUnits(TimeDelta delta) {
-  // For better precision `delta` is taken with best TimeDelta precision (us),
-  // then multiplaction and conversion to seconds are swapped to avoid float
-  // arithmetic.
-  // 2^31 us ~= 35.8 minutes.
-  return (rtc::saturated_cast<int32_t>(delta.us()) * (int64_t{1} << 32)) /
-         1'000'000;
-}
-
-// Converts interval from compact ntp (1/2^16 seconds) resolution to TimeDelta.
-// This interval can be up to ~9.1 hours (2^15 seconds).
-// Values close to 2^16 seconds are considered negative.
-TimeDelta CompactNtpIntervalToTimeDelta(uint32_t compact_ntp_interval);
-
-// Converts interval from compact ntp (1/2^16 seconds) resolution to TimeDelta.
-// This interval can be up to ~9.1 hours (2^15 seconds).
-// Values close to 2^16 seconds are considered negative and are converted to
-// minimum value of 1ms.
-TimeDelta CompactNtpRttToTimeDelta(uint32_t compact_ntp_interval);
-
-}  // namespace webrtc
-#endif  // MODULES_RTP_RTCP_SOURCE_NTP_TIME_UTIL_H_

src/common/api/ref_count.h

@@ -1,67 +0,0 @@
-/*
- *  Copyright 2011 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.
- */
-#ifndef API_REF_COUNT_H_
-#define API_REF_COUNT_H_
-
-namespace webrtc {
-
-// Refcounted objects should implement the following informal interface:
-//
-// void AddRef() const ;
-// RefCountReleaseStatus Release() const;
-//
-// You may access members of a reference-counted object, including the AddRef()
-// and Release() methods, only if you already own a reference to it, or if
-// you're borrowing someone else's reference. (A newly created object is a
-// special case: the reference count is zero on construction, and the code that
-// creates the object should immediately call AddRef(), bringing the reference
-// count from zero to one, e.g., by constructing an rtc::scoped_refptr).
-//
-// AddRef() creates a new reference to the object.
-//
-// Release() releases a reference to the object; the caller now has one less
-// reference than before the call. Returns kDroppedLastRef if the number of
-// references dropped to zero because of this (in which case the object destroys
-// itself). Otherwise, returns kOtherRefsRemained, to signal that at the precise
-// time the caller's reference was dropped, other references still remained (but
-// if other threads own references, this may of course have changed by the time
-// Release() returns).
-//
-// The caller of Release() must treat it in the same way as a delete operation:
-// Regardless of the return value from Release(), the caller mustn't access the
-// object. The object might still be alive, due to references held by other
-// users of the object, but the object can go away at any time, e.g., as the
-// result of another thread calling Release().
-//
-// Calling AddRef() and Release() manually is discouraged. It's recommended to
-// use rtc::scoped_refptr to manage all pointers to reference counted objects.
-// Note that rtc::scoped_refptr depends on compile-time duck-typing; formally
-// implementing the below RefCountInterface is not required.
-
-enum class RefCountReleaseStatus { kDroppedLastRef, kOtherRefsRemained };
-
-// Interfaces where refcounting is part of the public api should
-// inherit this abstract interface. The implementation of these
-// methods is usually provided by the RefCountedObject template class,
-// applied as a leaf in the inheritance tree.
-class RefCountInterface {
- public:
-  virtual void AddRef() const = 0;
-  virtual RefCountReleaseStatus Release() const = 0;
-
-  // Non-public destructor, because Release() has exclusive responsibility for
-  // destroying the object.
- protected:
-  virtual ~RefCountInterface() {}
-};
-
-}  // namespace webrtc
-
-#endif  // API_REF_COUNT_H_

src/common/api/ref_counted_base.h

@@ -1,107 +0,0 @@
-/*
- *  Copyright 2017 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.
- */
-#ifndef API_REF_COUNTED_BASE_H_
-#define API_REF_COUNTED_BASE_H_
-
-#include <type_traits>
-
-#include "api/ref_count.h"
-#include "rtc_base/ref_counter.h"
-
-namespace webrtc {
-
-class RefCountedBase {
- public:
-  RefCountedBase() = default;
-
-  RefCountedBase(const RefCountedBase&) = delete;
-  RefCountedBase& operator=(const RefCountedBase&) = delete;
-
-  void AddRef() const { ref_count_.IncRef(); }
-  RefCountReleaseStatus Release() const {
-    const auto status = ref_count_.DecRef();
-    if (status == RefCountReleaseStatus::kDroppedLastRef) {
-      delete this;
-    }
-    return status;
-  }
-
- protected:
-  // Provided for internal webrtc subclasses for corner cases where it's
-  // necessary to know whether or not a reference is exclusively held.
-  bool HasOneRef() const { return ref_count_.HasOneRef(); }
-
-  virtual ~RefCountedBase() = default;
-
- private:
-  mutable webrtc::webrtc_impl::RefCounter ref_count_{0};
-};
-
-// Template based version of `RefCountedBase` for simple implementations that do
-// not need (or want) destruction via virtual destructor or the overhead of a
-// vtable.
-//
-// To use:
-//   struct MyInt : public rtc::RefCountedNonVirtual<MyInt>  {
-//     int foo_ = 0;
-//   };
-//
-//   rtc::scoped_refptr<MyInt> my_int(new MyInt());
-//
-// sizeof(MyInt) on a 32 bit system would then be 8, int + refcount and no
-// vtable generated.
-template <typename T>
-class RefCountedNonVirtual {
- public:
-  RefCountedNonVirtual() = default;
-
-  RefCountedNonVirtual(const RefCountedNonVirtual&) = delete;
-  RefCountedNonVirtual& operator=(const RefCountedNonVirtual&) = delete;
-
-  void AddRef() const { ref_count_.IncRef(); }
-  RefCountReleaseStatus Release() const {
-    // If you run into this assert, T has virtual methods. There are two
-    // options:
-    // 1) The class doesn't actually need virtual methods, the type is complete
-    //    so the virtual attribute(s) can be removed.
-    // 2) The virtual methods are a part of the design of the class. In this
-    //    case you can consider using `RefCountedBase` instead or alternatively
-    //    use `rtc::RefCountedObject`.
-    static_assert(!std::is_polymorphic<T>::value,
-                  "T has virtual methods. RefCountedBase is a better fit.");
-    const auto status = ref_count_.DecRef();
-    if (status == RefCountReleaseStatus::kDroppedLastRef) {
-      delete static_cast<const T*>(this);
-    }
-    return status;
-  }
-
- protected:
-  // Provided for internal webrtc subclasses for corner cases where it's
-  // necessary to know whether or not a reference is exclusively held.
-  bool HasOneRef() const { return ref_count_.HasOneRef(); }
-
-  ~RefCountedNonVirtual() = default;
-
- private:
-  mutable webrtc::webrtc_impl::RefCounter ref_count_{0};
-};
-
-}  // namespace webrtc
-
-// Backwards compatibe aliases.
-// TODO: https://issues.webrtc.org/42225969 - deprecate and remove.
-namespace rtc {
-using RefCountedBase = webrtc::RefCountedBase;
-template <typename T>
-using RefCountedNonVirtual = webrtc::RefCountedNonVirtual<T>;
-}  // namespace rtc
-
-#endif  // API_REF_COUNTED_BASE_H_

src/common/api/rtp_rtcp/rtp_rtcp_typedef.h

@@ -1,129 +0,0 @@
-/*
- *  Copyright (c) 2012 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.
- */
-
-#ifndef _RTP_RTCP_TYPEDEF_H_
-#define _RTP_RTCP_TYPEDEF_H_
-
-#include <stddef.h>
-
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-#include <numeric>
-#include <optional>
-#include <utility>
-#include <vector>
-
-#include "api/array_view.h"
-#include "api/transport/network_types.h"
-#include "api/units/data_rate.h"
-#include "api/units/time_delta.h"
-#include "api/units/timestamp.h"
-
-#define RTCP_CNAME_SIZE 256  // RFC 3550 page 44, including null termination
-#define IP_PACKET_SIZE 1500  // we assume ethernet
-
-namespace webrtc {
-
-const int kVideoPayloadTypeFrequency = 90000;
-
-// TODO(bugs.webrtc.org/6458): Remove this when all the depending projects are
-// updated to correctly set rtp rate for RtcpSender.
-const int kBogusRtpRateForAudioRtcp = 8000;
-
-// Minimum RTP header size in bytes.
-const uint8_t kRtpHeaderSize = 12;
-
-// This enum must not have any gaps, i.e., all integers between
-// kRtpExtensionNone and kRtpExtensionNumberOfExtensions must be valid enum
-// entries.
-enum RTPExtensionType : int {
-  kRtpExtensionNone,
-  kRtpExtensionTransmissionTimeOffset,
-  kRtpExtensionAudioLevel,
-  kRtpExtensionCsrcAudioLevel,
-  kRtpExtensionInbandComfortNoise,
-  kRtpExtensionAbsoluteSendTime,
-  kRtpExtensionAbsoluteCaptureTime,
-  kRtpExtensionVideoRotation,
-  kRtpExtensionTransportSequenceNumber,
-  kRtpExtensionTransportSequenceNumber02,
-  kRtpExtensionPlayoutDelay,
-  kRtpExtensionVideoContentType,
-  kRtpExtensionVideoLayersAllocation,
-  kRtpExtensionVideoTiming,
-  kRtpExtensionRtpStreamId,
-  kRtpExtensionRepairedRtpStreamId,
-  kRtpExtensionMid,
-  kRtpExtensionGenericFrameDescriptor,
-  kRtpExtensionGenericFrameDescriptor00 [[deprecated]] =
-      kRtpExtensionGenericFrameDescriptor,
-  kRtpExtensionDependencyDescriptor,
-  kRtpExtensionGenericFrameDescriptor02 [[deprecated]] =
-      kRtpExtensionDependencyDescriptor,
-  kRtpExtensionColorSpace,
-  kRtpExtensionVideoFrameTrackingId,
-  kRtpExtensionCorruptionDetection,
-  kRtpExtensionNumberOfExtensions  // Must be the last entity in the enum.
-};
-
-enum RTCPAppSubTypes { kAppSubtypeBwe = 0x00 };
-
-// TODO(sprang): Make this an enum class once rtcp_receiver has been cleaned up.
-enum RTCPPacketType : uint32_t {
-  kRtcpReport = 0x0001,
-  kRtcpSr = 0x0002,
-  kRtcpRr = 0x0004,
-  kRtcpSdes = 0x0008,
-  kRtcpBye = 0x0010,
-  kRtcpPli = 0x0020,
-  kRtcpNack = 0x0040,
-  kRtcpFir = 0x0080,
-  kRtcpTmmbr = 0x0100,
-  kRtcpTmmbn = 0x0200,
-  kRtcpSrReq = 0x0400,
-  kRtcpLossNotification = 0x2000,
-  kRtcpRemb = 0x10000,
-  kRtcpTransmissionTimeOffset = 0x20000,
-  kRtcpXrReceiverReferenceTime = 0x40000,
-  kRtcpXrDlrrReportBlock = 0x80000,
-  kRtcpTransportFeedback = 0x100000,
-  kRtcpXrTargetBitrate = 0x200000,
-};
-
-enum class KeyFrameReqMethod : uint8_t {
-  kNone,     // Don't request keyframes.
-  kPliRtcp,  // Request keyframes through Picture Loss Indication.
-  kFirRtcp   // Request keyframes through Full Intra-frame Request.
-};
-
-enum RtxMode {
-  kRtxOff = 0x0,
-  kRtxRetransmitted = 0x1,     // Only send retransmissions over RTX.
-  kRtxRedundantPayloads = 0x2  // Preventively send redundant payloads
-                               // instead of padding.
-};
-
-const size_t kRtxHeaderSize = 2;
-
-// NOTE! `kNumMediaTypes` must be kept in sync with RtpPacketMediaType!
-static constexpr size_t kNumMediaTypes = 5;
-enum class RtpPacketMediaType : size_t {
-  kAudio,                         // Audio media packets.
-  kVideo,                         // Video media packets.
-  kRetransmission,                // Retransmisions, sent as response to NACK.
-  kForwardErrorCorrection,        // FEC packets.
-  kPadding = kNumMediaTypes - 1,  // RTX or plain padding sent to maintain BWE.
-  // Again, don't forget to update `kNumMediaTypes` if you add another value!
-};
-
-}  // namespace webrtc
-#endif  // _RTP_RTCP_TYPEDEF_H_

src/common/api/scoped_refptr.h

@@ -1,203 +0,0 @@
-/*
- *  Copyright 2011 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.
- */
-
-// Originally these classes are from Chromium.
-// http://src.chromium.org/viewvc/chrome/trunk/src/base/memory/ref_counted.h?view=markup
-
-//
-// A smart pointer class for reference counted objects.  Use this class instead
-// of calling AddRef and Release manually on a reference counted object to
-// avoid common memory leaks caused by forgetting to Release an object
-// reference.  Sample usage:
-//
-//   class MyFoo : public RefCounted<MyFoo> {
-//    ...
-//   };
-//
-//   void some_function() {
-//     scoped_refptr<MyFoo> foo = make_ref_counted<MyFoo>();
-//     foo->Method(param);
-//     // `foo` is released when this function returns
-//   }
-//
-//   void some_other_function() {
-//     scoped_refptr<MyFoo> foo = make_ref_counted<MyFoo>();
-//     ...
-//     foo = nullptr;  // explicitly releases `foo`
-//     ...
-//     if (foo)
-//       foo->Method(param);
-//   }
-//
-// The above examples show how scoped_refptr<T> acts like a pointer to T.
-// Given two scoped_refptr<T> classes, it is also possible to exchange
-// references between the two objects, like so:
-//
-//   {
-//     scoped_refptr<MyFoo> a = make_ref_counted<MyFoo>();
-//     scoped_refptr<MyFoo> b;
-//
-//     b.swap(a);
-//     // now, `b` references the MyFoo object, and `a` references null.
-//   }
-//
-// To make both `a` and `b` in the above example reference the same MyFoo
-// object, simply use the assignment operator:
-//
-//   {
-//     scoped_refptr<MyFoo> a = make_ref_counted<MyFoo>();
-//     scoped_refptr<MyFoo> b;
-//
-//     b = a;
-//     // now, `a` and `b` each own a reference to the same MyFoo object.
-//   }
-//
-
-#ifndef API_SCOPED_REFPTR_H_
-#define API_SCOPED_REFPTR_H_
-
-#include <cstddef>
-#include <memory>
-#include <utility>
-
-namespace webrtc {
-
-template <class T>
-class scoped_refptr {
- public:
-  using element_type = T;
-
-  scoped_refptr() : ptr_(nullptr) {}
-  scoped_refptr(std::nullptr_t) : ptr_(nullptr) {}  // NOLINT(runtime/explicit)
-
-  explicit scoped_refptr(T* p) : ptr_(p) {}
-
-  scoped_refptr(const scoped_refptr<T>& r) : ptr_(r.ptr_) {}
-
-  template <typename U>
-  scoped_refptr(const scoped_refptr<U>& r) : ptr_(r.get()) {}
-
-  // Move constructors.
-  scoped_refptr(scoped_refptr<T>&& r) noexcept : ptr_(std::move(r.ptr_)) {}
-
-  template <typename U>
-  scoped_refptr(scoped_refptr<U>&& r) noexcept : ptr_(std::move(r.ptr_)) {}
-
-  ~scoped_refptr() = default;
-
-  T* get() const { return ptr_.get(); }
-  explicit operator bool() const { return ptr_ != nullptr; }
-  T& operator*() const { return *ptr_; }
-  T* operator->() const { return ptr_.get(); }
-
-  T* release() {
-    T* retVal = ptr_.get();
-    ptr_.reset();
-    return retVal;
-  }
-
-  scoped_refptr<T>& operator=(T* p) {
-    ptr_.reset(p);
-    return *this;
-  }
-
-  scoped_refptr<T>& operator=(const scoped_refptr<T>& r) {
-    ptr_ = r.ptr_;
-    return *this;
-  }
-
-  template <typename U>
-  scoped_refptr<T>& operator=(const scoped_refptr<U>& r) {
-    ptr_ = r.ptr_;
-    return *this;
-  }
-
-  scoped_refptr<T>& operator=(scoped_refptr<T>&& r) noexcept {
-    ptr_ = std::move(r.ptr_);
-    return *this;
-  }
-
-  template <typename U>
-  scoped_refptr<T>& operator=(scoped_refptr<U>&& r) noexcept {
-    ptr_ = std::move(r.ptr_);
-    return *this;
-  }
-
-  void swap(T** pp) noexcept { std::swap(ptr_, *pp); }
-
-  void swap(scoped_refptr<T>& r) noexcept { std::swap(ptr_, r.ptr_); }
-
- protected:
-  std::shared_ptr<T> ptr_;
-};
-
-template <typename T, typename U>
-bool operator==(const scoped_refptr<T>& a, const scoped_refptr<U>& b) {
-  return a.get() == b.get();
-}
-template <typename T, typename U>
-bool operator!=(const scoped_refptr<T>& a, const scoped_refptr<U>& b) {
-  return !(a == b);
-}
-
-template <typename T>
-bool operator==(const scoped_refptr<T>& a, std::nullptr_t) {
-  return a.get() == nullptr;
-}
-
-template <typename T>
-bool operator!=(const scoped_refptr<T>& a, std::nullptr_t) {
-  return !(a == nullptr);
-}
-
-template <typename T>
-bool operator==(std::nullptr_t, const scoped_refptr<T>& a) {
-  return a.get() == nullptr;
-}
-
-template <typename T>
-bool operator!=(std::nullptr_t, const scoped_refptr<T>& a) {
-  return !(a == nullptr);
-}
-
-// Comparison with raw pointer.
-template <typename T, typename U>
-bool operator==(const scoped_refptr<T>& a, const U* b) {
-  return a.get() == b;
-}
-template <typename T, typename U>
-bool operator!=(const scoped_refptr<T>& a, const U* b) {
-  return !(a == b);
-}
-
-template <typename T, typename U>
-bool operator==(const T* a, const scoped_refptr<U>& b) {
-  return a == b.get();
-}
-template <typename T, typename U>
-bool operator!=(const T* a, const scoped_refptr<U>& b) {
-  return !(a == b);
-}
-
-// Ordered comparison, needed for use as a std::map key.
-template <typename T, typename U>
-bool operator<(const scoped_refptr<T>& a, const scoped_refptr<U>& b) {
-  return a.get() < b.get();
-}
-
-}  // namespace webrtc
-
-namespace rtc {
-// Backwards compatible alias.
-// TODO: bugs.webrtc.org/42225969 - Deprecate and remove.
-using ::webrtc::scoped_refptr;
-}  // namespace rtc
-
-#endif  // API_SCOPED_REFPTR_H_

src/common/api/transport/bandwidth_usage.h

@@ -1,17 +0,0 @@
-/*
- * @Author: DI JUNKUN
- * @Date: 2025-01-15
- * Copyright (c) 2025 by DI JUNKUN, All Rights Reserved.
- */
-
-#ifndef _BANDWIDTH_USAGE_H_
-#define _BANDWIDTH_USAGE_H_
-
-enum class BandwidthUsage {
-  kBwNormal = 0,
-  kBwUnderusing = 1,
-  kBwOverusing = 2,
-  kLast
-};
-
-#endif

src/common/api/transport/ecn_marking.h

@@ -1,42 +0,0 @@
-/*
- *  Copyright 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.
- */
-
-#ifndef API_TRANSPORT_ECN_MARKING_H_
-#define API_TRANSPORT_ECN_MARKING_H_
-
-namespace webrtc {
-
-// TODO: bugs.webrtc.org/42225697 - L4S support is slowly being developed.
-// Help is appreciated.
-
-// L4S Explicit Congestion Notification (ECN) .
-// https://www.rfc-editor.org/rfc/rfc9331.html ECT stands for ECN-Capable
-// Transport and CE stands for Congestion Experienced.
-
-// RFC-3168, Section 5
-// +-----+-----+
-// | ECN FIELD |
-// +-----+-----+
-//   ECT   CE         [Obsolete] RFC 2481 names for the ECN bits.
-//    0     0         Not-ECT
-//    0     1         ECT(1)
-//    1     0         ECT(0)
-//    1     1         CE
-
-enum class EcnMarking {
-  kNotEct = 0,  // Not ECN-Capable Transport
-  kEct1 = 1,    // ECN-Capable Transport
-  kEct0 = 2,    // Not used by L4s (or webrtc.)
-  kCe = 3,      // Congestion experienced
-};
-
-}  // namespace webrtc
-
-#endif  // API_TRANSPORT_ECN_MARKING_H_

src/common/api/transport/network_control.h

@@ -1,124 +0,0 @@
-/*
- *  Copyright (c) 2018 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.
- */
-
-#ifndef API_TRANSPORT_NETWORK_CONTROL_H_
-#define API_TRANSPORT_NETWORK_CONTROL_H_
-
-#include <memory>
-#include <optional>
-
-#include "api/transport/network_types.h"
-#include "api/units/data_rate.h"
-#include "api/units/time_delta.h"
-
-namespace webrtc {
-
-class TargetTransferRateObserver {
- public:
-  virtual ~TargetTransferRateObserver() = default;
-  // Called to indicate target transfer rate as well as giving information about
-  // the current estimate of network parameters.
-  virtual void OnTargetTransferRate(TargetTransferRate) = 0;
-  // Called to provide updates to the expected target rate in case it changes
-  // before the first call to OnTargetTransferRate.
-  virtual void OnStartRateUpdate(DataRate) {}
-};
-
-// Configuration sent to factory create function. The parameters here are
-// optional to use for a network controller implementation.
-struct NetworkControllerConfig {
-  explicit NetworkControllerConfig() {}
-
-  // The initial constraints to start with, these can be changed at any later
-  // time by calls to OnTargetRateConstraints. Note that the starting rate
-  // has to be set initially to provide a starting state for the network
-  // controller, even though the field is marked as optional.
-  TargetRateConstraints constraints;
-  // Initial stream specific configuration, these are changed at any later time
-  // by calls to OnStreamsConfig.
-  StreamsConfig stream_based_config;
-};
-
-// NetworkControllerInterface is implemented by network controllers. A network
-// controller is a class that uses information about network state and traffic
-// to estimate network parameters such as round trip time and bandwidth. Network
-// controllers does not guarantee thread safety, the interface must be used in a
-// non-concurrent fashion.
-class NetworkControllerInterface {
- public:
-  virtual ~NetworkControllerInterface() = default;
-
-  // Called when network availabilty changes.
-  virtual NetworkControlUpdate OnNetworkAvailability(NetworkAvailability) = 0;
-  // Called when the receiving or sending endpoint changes address.
-  virtual NetworkControlUpdate OnNetworkRouteChange(NetworkRouteChange) = 0;
-  // Called periodically with a periodicy as specified by
-  // NetworkControllerFactoryInterface::GetProcessInterval.
-  virtual NetworkControlUpdate OnProcessInterval(ProcessInterval) = 0;
-  // Called when remotely calculated bitrate is received.
-  virtual NetworkControlUpdate OnRemoteBitrateReport(RemoteBitrateReport) = 0;
-  // Called round trip time has been calculated by protocol specific mechanisms.
-  virtual NetworkControlUpdate OnRoundTripTimeUpdate(RoundTripTimeUpdate) = 0;
-  // Called when a packet is sent on the network.
-  virtual NetworkControlUpdate OnSentPacket(SentPacket) = 0;
-  // Called when a packet is received from the remote client.
-  virtual NetworkControlUpdate OnReceivedPacket(ReceivedPacket) = 0;
-  // Called when the stream specific configuration has been updated.
-  virtual NetworkControlUpdate OnStreamsConfig(StreamsConfig) = 0;
-  // Called when target transfer rate constraints has been changed.
-  virtual NetworkControlUpdate OnTargetRateConstraints(
-      TargetRateConstraints) = 0;
-  // Called when a protocol specific calculation of packet loss has been made.
-  virtual NetworkControlUpdate OnTransportLossReport(TransportLossReport) = 0;
-  // Called with per packet feedback regarding receive time.
-  virtual NetworkControlUpdate OnTransportPacketsFeedback(
-      TransportPacketsFeedback) = 0;
-  // Called with network state estimate updates.
-  virtual NetworkControlUpdate OnNetworkStateEstimate(NetworkStateEstimate) = 0;
-};
-
-// NetworkControllerFactoryInterface is an interface for creating a network
-// controller.
-class NetworkControllerFactoryInterface {
- public:
-  virtual ~NetworkControllerFactoryInterface() = default;
-
-  // Used to create a new network controller, requires an observer to be
-  // provided to handle callbacks.
-  virtual std::unique_ptr<NetworkControllerInterface> Create(
-      NetworkControllerConfig config) = 0;
-  // Returns the interval by which the network controller expects
-  // OnProcessInterval calls.
-  virtual TimeDelta GetProcessInterval() const = 0;
-};
-
-// Under development, subject to change without notice.
-class NetworkStateEstimator {
- public:
-  // Gets the current best estimate according to the estimator.
-  virtual std::optional<NetworkStateEstimate> GetCurrentEstimate() = 0;
-  // Called with per packet feedback regarding receive time.
-  // Used when the NetworkStateEstimator runs in the sending endpoint.
-  virtual void OnTransportPacketsFeedback(const TransportPacketsFeedback&) = 0;
-  // Called with per packet feedback regarding receive time.
-  // Used when the NetworkStateEstimator runs in the receiving endpoint.
-  virtual void OnReceivedPacket(const PacketResult&) {}
-  // Called when the receiving or sending endpoint changes address.
-  virtual void OnRouteChange(const NetworkRouteChange&) = 0;
-  virtual ~NetworkStateEstimator() = default;
-};
-class NetworkStateEstimatorFactory {
- public:
-  virtual std::unique_ptr<NetworkStateEstimator> Create() = 0;
-  virtual ~NetworkStateEstimatorFactory() = default;
-};
-}  // namespace webrtc
-
-#endif  // API_TRANSPORT_NETWORK_CONTROL_H_

src/common/api/transport/network_types.cc

@@ -1,107 +0,0 @@
-/*
- *  Copyright (c) 2018 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 "api/transport/network_types.h"
-
-#include <algorithm>
-#include <vector>
-
-namespace webrtc {
-StreamsConfig::StreamsConfig() = default;
-StreamsConfig::StreamsConfig(const StreamsConfig&) = default;
-StreamsConfig::~StreamsConfig() = default;
-
-TargetRateConstraints::TargetRateConstraints() = default;
-TargetRateConstraints::TargetRateConstraints(const TargetRateConstraints&) =
-    default;
-TargetRateConstraints::~TargetRateConstraints() = default;
-
-NetworkRouteChange::NetworkRouteChange() = default;
-NetworkRouteChange::NetworkRouteChange(const NetworkRouteChange&) = default;
-NetworkRouteChange::~NetworkRouteChange() = default;
-
-PacketResult::PacketResult() = default;
-PacketResult::PacketResult(const PacketResult& other) = default;
-PacketResult::~PacketResult() = default;
-
-bool PacketResult::ReceiveTimeOrder::operator()(const PacketResult& lhs,
-                                                const PacketResult& rhs) {
-  if (lhs.receive_time != rhs.receive_time)
-    return lhs.receive_time < rhs.receive_time;
-  if (lhs.sent_packet.send_time != rhs.sent_packet.send_time)
-    return lhs.sent_packet.send_time < rhs.sent_packet.send_time;
-  return lhs.sent_packet.sequence_number < rhs.sent_packet.sequence_number;
-}
-
-TransportPacketsFeedback::TransportPacketsFeedback() = default;
-TransportPacketsFeedback::TransportPacketsFeedback(
-    const TransportPacketsFeedback& other) = default;
-TransportPacketsFeedback::~TransportPacketsFeedback() = default;
-
-std::vector<PacketResult> TransportPacketsFeedback::ReceivedWithSendInfo()
-    const {
-  std::vector<PacketResult> res;
-  for (const PacketResult& fb : packet_feedbacks) {
-    if (fb.IsReceived()) {
-      res.push_back(fb);
-    }
-  }
-  return res;
-}
-
-std::vector<PacketResult> TransportPacketsFeedback::LostWithSendInfo() const {
-  std::vector<PacketResult> res;
-  for (const PacketResult& fb : packet_feedbacks) {
-    if (!fb.IsReceived()) {
-      res.push_back(fb);
-    }
-  }
-  return res;
-}
-
-std::vector<PacketResult> TransportPacketsFeedback::PacketsWithFeedback()
-    const {
-  return packet_feedbacks;
-}
-
-std::vector<PacketResult> TransportPacketsFeedback::SortedByReceiveTime()
-    const {
-  std::vector<PacketResult> res;
-  for (const PacketResult& fb : packet_feedbacks) {
-    if (fb.IsReceived()) {
-      res.push_back(fb);
-    }
-  }
-  std::sort(res.begin(), res.end(), PacketResult::ReceiveTimeOrder());
-  return res;
-}
-
-NetworkControlUpdate::NetworkControlUpdate() = default;
-NetworkControlUpdate::NetworkControlUpdate(const NetworkControlUpdate&) =
-    default;
-NetworkControlUpdate::~NetworkControlUpdate() = default;
-
-PacedPacketInfo::PacedPacketInfo() = default;
-
-PacedPacketInfo::PacedPacketInfo(int probe_cluster_id,
-                                 int probe_cluster_min_probes,
-                                 int probe_cluster_min_bytes)
-    : probe_cluster_id(probe_cluster_id),
-      probe_cluster_min_probes(probe_cluster_min_probes),
-      probe_cluster_min_bytes(probe_cluster_min_bytes) {}
-
-bool PacedPacketInfo::operator==(const PacedPacketInfo& rhs) const {
-  return send_bitrate == rhs.send_bitrate &&
-         probe_cluster_id == rhs.probe_cluster_id &&
-         probe_cluster_min_probes == rhs.probe_cluster_min_probes &&
-         probe_cluster_min_bytes == rhs.probe_cluster_min_bytes;
-}
-
-}  // namespace webrtc

src/common/api/transport/network_types.h

@@ -1,292 +0,0 @@
-/*
- *  Copyright (c) 2018 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.
- */
-
-#ifndef API_TRANSPORT_NETWORK_TYPES_H_
-#define API_TRANSPORT_NETWORK_TYPES_H_
-#include <stdint.h>
-
-#include <cmath>
-#include <optional>
-#include <vector>
-
-#include "api/transport/ecn_marking.h"
-#include "api/units/data_rate.h"
-#include "api/units/data_size.h"
-#include "api/units/time_delta.h"
-#include "api/units/timestamp.h"
-
-namespace webrtc {
-
-// Configuration
-
-// Represents constraints and rates related to the currently enabled streams.
-// This is used as input to the congestion controller via the StreamsConfig
-// struct.
-struct BitrateAllocationLimits {
-  // The total minimum send bitrate required by all sending streams.
-  DataRate min_allocatable_rate = DataRate::Zero();
-  // The total maximum allocatable bitrate for all currently available streams.
-  DataRate max_allocatable_rate = DataRate::Zero();
-  // The max bitrate to use for padding. The sum of the per-stream max padding
-  // rate.
-  DataRate max_padding_rate = DataRate::Zero();
-};
-
-// Use StreamsConfig for information about streams that is required for specific
-// adjustments to the algorithms in network controllers. Especially useful
-// for experiments.
-struct StreamsConfig {
-  StreamsConfig();
-  StreamsConfig(const StreamsConfig&);
-  ~StreamsConfig();
-  Timestamp at_time = Timestamp::PlusInfinity();
-  std::optional<bool> requests_alr_probing;
-  // If `enable_repeated_initial_probing` is set to true, Probes are sent
-  // periodically every 1s during the first 5s after the network becomes
-  // available. The probes ignores max_total_allocated_bitrate.
-  std::optional<bool> enable_repeated_initial_probing;
-  std::optional<double> pacing_factor;
-
-  // TODO(srte): Use BitrateAllocationLimits here.
-  std::optional<DataRate> min_total_allocated_bitrate;
-  std::optional<DataRate> max_padding_rate;
-  std::optional<DataRate> max_total_allocated_bitrate;
-};
-
-struct TargetRateConstraints {
-  TargetRateConstraints();
-  TargetRateConstraints(const TargetRateConstraints&);
-  ~TargetRateConstraints();
-  Timestamp at_time = Timestamp::PlusInfinity();
-  std::optional<DataRate> min_data_rate;
-  std::optional<DataRate> max_data_rate;
-  // The initial bandwidth estimate to base target rate on. This should be used
-  // as the basis for initial OnTargetTransferRate and OnPacerConfig callbacks.
-  std::optional<DataRate> starting_rate;
-};
-
-// Send side information
-
-struct NetworkAvailability {
-  Timestamp at_time = Timestamp::PlusInfinity();
-  bool network_available = false;
-};
-
-struct NetworkRouteChange {
-  NetworkRouteChange();
-  NetworkRouteChange(const NetworkRouteChange&);
-  ~NetworkRouteChange();
-  Timestamp at_time = Timestamp::PlusInfinity();
-  // The TargetRateConstraints are set here so they can be changed synchronously
-  // when network route changes.
-  TargetRateConstraints constraints;
-};
-
-struct PacedPacketInfo {
-  PacedPacketInfo();
-  PacedPacketInfo(int probe_cluster_id, int probe_cluster_min_probes,
-                  int probe_cluster_min_bytes);
-
-  bool operator==(const PacedPacketInfo& rhs) const;
-
-  // TODO(srte): Move probing info to a separate, optional struct.
-  static constexpr int kNotAProbe = -1;
-  DataRate send_bitrate = DataRate::BitsPerSec(0);
-  int probe_cluster_id = kNotAProbe;
-  int probe_cluster_min_probes = -1;
-  int probe_cluster_min_bytes = -1;
-  int probe_cluster_bytes_sent = 0;
-};
-
-struct SentPacket {
-  Timestamp send_time = Timestamp::PlusInfinity();
-  // Size of packet with overhead up to IP layer.
-  DataSize size = DataSize::Zero();
-  // Size of preceeding packets that are not part of feedback.
-  DataSize prior_unacked_data = DataSize::Zero();
-  // Probe cluster id and parameters including bitrate, number of packets and
-  // number of bytes.
-  PacedPacketInfo pacing_info;
-  // True if the packet is an audio packet, false for video, padding, RTX etc.
-  bool audio = false;
-  // Transport independent sequence number, any tracked packet should have a
-  // sequence number that is unique over the whole call and increasing by 1 for
-  // each packet.
-  int64_t sequence_number;
-  // Tracked data in flight when the packet was sent, excluding unacked data.
-  DataSize data_in_flight = DataSize::Zero();
-};
-
-struct ReceivedPacket {
-  Timestamp send_time = Timestamp::MinusInfinity();
-  Timestamp receive_time = Timestamp::PlusInfinity();
-  DataSize size = DataSize::Zero();
-};
-
-// Transport level feedback
-
-struct RemoteBitrateReport {
-  Timestamp receive_time = Timestamp::PlusInfinity();
-  DataRate bandwidth = DataRate::Infinity();
-};
-
-struct RoundTripTimeUpdate {
-  Timestamp receive_time = Timestamp::PlusInfinity();
-  TimeDelta round_trip_time = TimeDelta::PlusInfinity();
-  bool smoothed = false;
-};
-
-struct TransportLossReport {
-  Timestamp receive_time = Timestamp::PlusInfinity();
-  Timestamp start_time = Timestamp::PlusInfinity();
-  Timestamp end_time = Timestamp::PlusInfinity();
-  uint64_t packets_lost_delta = 0;
-  uint64_t packets_received_delta = 0;
-};
-
-// Packet level feedback
-
-struct PacketResult {
-  class ReceiveTimeOrder {
-   public:
-    bool operator()(const PacketResult& lhs, const PacketResult& rhs);
-  };
-
-  PacketResult();
-  PacketResult(const PacketResult&);
-  ~PacketResult();
-
-  inline bool IsReceived() const { return !receive_time.IsPlusInfinity(); }
-
-  SentPacket sent_packet;
-  Timestamp receive_time = Timestamp::PlusInfinity();
-  EcnMarking ecn = EcnMarking::kNotEct;
-};
-
-struct TransportPacketsFeedback {
-  TransportPacketsFeedback();
-  TransportPacketsFeedback(const TransportPacketsFeedback& other);
-  ~TransportPacketsFeedback();
-
-  Timestamp feedback_time = Timestamp::PlusInfinity();
-  DataSize data_in_flight = DataSize::Zero();
-  bool transport_supports_ecn = false;
-  std::vector<PacketResult> packet_feedbacks;
-
-  // Arrival times for messages without send time information.
-  std::vector<Timestamp> sendless_arrival_times;
-
-  std::vector<PacketResult> ReceivedWithSendInfo() const;
-  std::vector<PacketResult> LostWithSendInfo() const;
-  std::vector<PacketResult> PacketsWithFeedback() const;
-  std::vector<PacketResult> SortedByReceiveTime() const;
-};
-
-// Network estimation
-
-struct NetworkEstimate {
-  Timestamp at_time = Timestamp::PlusInfinity();
-  // Deprecated, use TargetTransferRate::target_rate instead.
-  DataRate bandwidth = DataRate::Infinity();
-  TimeDelta round_trip_time = TimeDelta::PlusInfinity();
-  TimeDelta bwe_period = TimeDelta::PlusInfinity();
-
-  float loss_rate_ratio = 0;
-};
-
-// Network control
-
-struct PacerConfig {
-  Timestamp at_time = Timestamp::PlusInfinity();
-  // Pacer should send at most data_window data over time_window duration.
-  DataSize data_window = DataSize::Infinity();
-  TimeDelta time_window = TimeDelta::PlusInfinity();
-  // Pacer should send at least pad_window data over time_window duration.
-  DataSize pad_window = DataSize::Zero();
-  DataRate data_rate() const { return data_window / time_window; }
-  DataRate pad_rate() const { return pad_window / time_window; }
-};
-
-struct ProbeClusterConfig {
-  Timestamp at_time = Timestamp::PlusInfinity();
-  DataRate target_data_rate = DataRate::Zero();
-  // Duration of a probe.
-  TimeDelta target_duration = TimeDelta::Zero();
-  // Delta time between sent bursts of packets during probe.
-  TimeDelta min_probe_delta = TimeDelta::Millis(2);
-  int32_t target_probe_count = 0;
-  int32_t id = 0;
-};
-
-struct TargetTransferRate {
-  Timestamp at_time = Timestamp::PlusInfinity();
-  // The estimate on which the target rate is based on.
-  NetworkEstimate network_estimate;
-  DataRate target_rate = DataRate::Zero();
-  DataRate stable_target_rate = DataRate::Zero();
-  double cwnd_reduce_ratio = 0;
-};
-
-// Contains updates of network controller comand state. Using optionals to
-// indicate whether a member has been updated. The array of probe clusters
-// should be used to send out probes if not empty.
-struct NetworkControlUpdate {
-  NetworkControlUpdate();
-  NetworkControlUpdate(const NetworkControlUpdate&);
-  ~NetworkControlUpdate();
-
-  bool has_updates() const {
-    return congestion_window.has_value() || pacer_config.has_value() ||
-           !probe_cluster_configs.empty() || target_rate.has_value();
-  }
-
-  std::optional<DataSize> congestion_window;
-  std::optional<PacerConfig> pacer_config;
-  std::vector<ProbeClusterConfig> probe_cluster_configs;
-  std::optional<TargetTransferRate> target_rate;
-};
-
-// Process control
-struct ProcessInterval {
-  Timestamp at_time = Timestamp::PlusInfinity();
-  std::optional<DataSize> pacer_queue;
-};
-
-// Under development, subject to change without notice.
-struct NetworkStateEstimate {
-  double confidence = NAN;
-  // The time the estimate was received/calculated.
-  Timestamp update_time = Timestamp::MinusInfinity();
-  Timestamp last_receive_time = Timestamp::MinusInfinity();
-  Timestamp last_send_time = Timestamp::MinusInfinity();
-
-  // Total estimated link capacity.
-  DataRate link_capacity = DataRate::MinusInfinity();
-  // Used as a safe measure of available capacity.
-  DataRate link_capacity_lower = DataRate::MinusInfinity();
-  // Used as limit for increasing bitrate.
-  DataRate link_capacity_upper = DataRate::MinusInfinity();
-
-  TimeDelta pre_link_buffer_delay = TimeDelta::MinusInfinity();
-  TimeDelta post_link_buffer_delay = TimeDelta::MinusInfinity();
-  TimeDelta propagation_delay = TimeDelta::MinusInfinity();
-
-  // Only for debugging
-  TimeDelta time_delta = TimeDelta::MinusInfinity();
-  Timestamp last_feed_time = Timestamp::MinusInfinity();
-  double cross_delay_rate = NAN;
-  double spike_delay_rate = NAN;
-  DataRate link_capacity_std_dev = DataRate::MinusInfinity();
-  DataRate link_capacity_min = DataRate::MinusInfinity();
-  double cross_traffic_ratio = NAN;
-};
-}  // namespace webrtc
-
-#endif  // API_TRANSPORT_NETWORK_TYPES_H_

src/common/api/units/data_rate.cc

@@ -1,30 +0,0 @@
-/*
- *  Copyright (c) 2018 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 "api/units/data_rate.h"
-
-#include <string>
-
-namespace webrtc {
-
-std::string ToString(DataRate value) {
-  if (value.IsPlusInfinity()) {
-    return "+inf bps";
-  } else if (value.IsMinusInfinity()) {
-    return "-inf bps";
-  } else {
-    if (value.bps() == 0 || value.bps() % 1000 != 0) {
-      return std::to_string(value.bps()) + " bps";
-    } else {
-      return std::to_string(value.kbps()) + " kbps";
-    }
-  }
-}
-}  // namespace webrtc

src/common/api/units/data_rate.h

@@ -1,141 +0,0 @@
-/*
- *  Copyright (c) 2018 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.
- */
-
-#ifndef API_UNITS_DATA_RATE_H_
-#define API_UNITS_DATA_RATE_H_
-
-#include <cstdint>
-#include <limits>
-#include <string>
-#include <type_traits>
-
-#include "api/units/data_size.h"
-#include "api/units/frequency.h"
-#include "api/units/time_delta.h"
-#include "unit_base.h"
-
-namespace webrtc {
-// DataRate is a class that represents a given data rate. This can be used to
-// represent bandwidth, encoding bitrate, etc. The internal storage is bits per
-// second (bps).
-class DataRate final : public rtc_units_impl::RelativeUnit<DataRate> {
- public:
-  template <typename T>
-  static constexpr DataRate BitsPerSec(T value) {
-    static_assert(std::is_arithmetic<T>::value, "");
-    return FromValue(value);
-  }
-  template <typename T>
-  static constexpr DataRate BytesPerSec(T value) {
-    static_assert(std::is_arithmetic<T>::value, "");
-    return FromFraction(8, value);
-  }
-  template <typename T>
-  static constexpr DataRate KilobitsPerSec(T value) {
-    static_assert(std::is_arithmetic<T>::value, "");
-    return FromFraction(1000, value);
-  }
-  static constexpr DataRate Infinity() { return PlusInfinity(); }
-
-  constexpr DataRate() = default;
-
-  template <typename Sink>
-  friend void AbslStringify(Sink& sink, DataRate value);
-
-  template <typename T = int64_t>
-  constexpr T bps() const {
-    return ToValue<T>();
-  }
-  template <typename T = int64_t>
-  constexpr T bytes_per_sec() const {
-    return ToFraction<8, T>();
-  }
-  template <typename T = int64_t>
-  constexpr T kbps() const {
-    return ToFraction<1000, T>();
-  }
-  constexpr int64_t bps_or(int64_t fallback_value) const {
-    return ToValueOr(fallback_value);
-  }
-  constexpr int64_t kbps_or(int64_t fallback_value) const {
-    return ToFractionOr<1000>(fallback_value);
-  }
-
- private:
-  // Bits per second used internally to simplify debugging by making the value
-  // more recognizable.
-  friend class rtc_units_impl::UnitBase<DataRate>;
-  using RelativeUnit::RelativeUnit;
-  static constexpr bool one_sided = true;
-};
-
-namespace data_rate_impl {
-inline constexpr int64_t Microbits(const DataSize& size) {
-  constexpr int64_t kMaxBeforeConversion =
-      std::numeric_limits<int64_t>::max() / 8000000;
-  return size.bytes() * 8000000;
-}
-
-inline constexpr int64_t MillibytePerSec(const DataRate& size) {
-  constexpr int64_t kMaxBeforeConversion =
-      std::numeric_limits<int64_t>::max() / (1000 / 8);
-  return size.bps() * (1000 / 8);
-}
-}  // namespace data_rate_impl
-
-inline constexpr DataRate operator/(const DataSize size,
-                                    const TimeDelta duration) {
-  return DataRate::BitsPerSec(data_rate_impl::Microbits(size) / duration.us());
-}
-inline constexpr TimeDelta operator/(const DataSize size, const DataRate rate) {
-  return TimeDelta::Micros(data_rate_impl::Microbits(size) / rate.bps());
-}
-inline constexpr DataSize operator*(const DataRate rate,
-                                    const TimeDelta duration) {
-  int64_t microbits = rate.bps() * duration.us();
-  return DataSize::Bytes((microbits + 4000000) / 8000000);
-}
-inline constexpr DataSize operator*(const TimeDelta duration,
-                                    const DataRate rate) {
-  return rate * duration;
-}
-
-inline constexpr DataSize operator/(const DataRate rate,
-                                    const Frequency frequency) {
-  int64_t millihertz = frequency.millihertz<int64_t>();
-  // Note that the value is truncated here reather than rounded, potentially
-  // introducing an error of .5 bytes if rounding were expected.
-  return DataSize::Bytes(data_rate_impl::MillibytePerSec(rate) / millihertz);
-}
-inline constexpr Frequency operator/(const DataRate rate, const DataSize size) {
-  return Frequency::MilliHertz(data_rate_impl::MillibytePerSec(rate) /
-                               size.bytes());
-}
-inline constexpr DataRate operator*(const DataSize size,
-                                    const Frequency frequency) {
-  int64_t millibits_per_second =
-      size.bytes() * 8 * frequency.millihertz<int64_t>();
-  return DataRate::BitsPerSec((millibits_per_second + 500) / 1000);
-}
-inline constexpr DataRate operator*(const Frequency frequency,
-                                    const DataSize size) {
-  return size * frequency;
-}
-
-std::string ToString(DataRate value);
-
-template <typename Sink>
-void AbslStringify(Sink& sink, DataRate value) {
-  sink.Append(ToString(value));
-}
-
-}  // namespace webrtc
-
-#endif  // API_UNITS_DATA_RATE_H_

src/common/api/units/data_size.cc

@@ -1,26 +0,0 @@
-/*
- *  Copyright (c) 2018 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 "api/units/data_size.h"
-
-#include <string>
-
-namespace webrtc {
-
-std::string ToString(DataSize value) {
-  if (value.IsPlusInfinity()) {
-    return "+inf bytes";
-  } else if (value.IsMinusInfinity()) {
-    return "-inf bytes";
-  } else {
-    return std::to_string(value.bytes()) + " bytes";
-  }
-}
-}  // namespace webrtc

src/common/api/units/data_size.h

@@ -1,60 +0,0 @@
-/*
- *  Copyright (c) 2018 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.
- */
-
-#ifndef API_UNITS_DATA_SIZE_H_
-#define API_UNITS_DATA_SIZE_H_
-
-#include <cstdint>
-#include <string>
-#include <type_traits>
-
-#include "unit_base.h"  // IWYU pragma: export
-
-namespace webrtc {
-// DataSize is a class represeting a count of bytes.
-class DataSize final : public rtc_units_impl::RelativeUnit<DataSize> {
- public:
-  template <typename T>
-  static constexpr DataSize Bytes(T value) {
-    static_assert(std::is_arithmetic<T>::value, "");
-    return FromValue(value);
-  }
-  static constexpr DataSize Infinity() { return PlusInfinity(); }
-
-  constexpr DataSize() = default;
-
-  template <typename Sink>
-  friend void AbslStringify(Sink& sink, DataSize value);
-
-  template <typename T = int64_t>
-  constexpr T bytes() const {
-    return ToValue<T>();
-  }
-
-  constexpr int64_t bytes_or(int64_t fallback_value) const {
-    return ToValueOr(fallback_value);
-  }
-
- private:
-  friend class rtc_units_impl::UnitBase<DataSize>;
-  using RelativeUnit::RelativeUnit;
-  static constexpr bool one_sided = true;
-};
-
-std::string ToString(DataSize value);
-
-template <typename Sink>
-void AbslStringify(Sink& sink, DataSize value) {
-  sink.Append(ToString(value));
-}
-
-}  // namespace webrtc
-
-#endif  // API_UNITS_DATA_SIZE_H_

src/common/api/units/frequency.cc

@@ -1,27 +0,0 @@
-/*
- *  Copyright (c) 2019 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 "frequency.h"
-
-#include <cstdint>
-#include <string>
-
-namespace webrtc {
-std::string ToString(Frequency value) {
-  if (value.IsPlusInfinity()) {
-    return "+inf Hz";
-  } else if (value.IsMinusInfinity()) {
-    return "-inf Hz";
-  } else if (value.millihertz<int64_t>() % 1000 != 0) {
-    return std::to_string(value.hertz<double>()) + " Hz";
-  } else {
-    return std::to_string(value.hertz<int64_t>()) + " Hz";
-  }
-}
-}  // namespace webrtc

src/common/api/units/frequency.h

@@ -1,89 +0,0 @@
-/*
- *  Copyright (c) 2019 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.
- */
-#ifndef API_UNITS_FREQUENCY_H_
-#define API_UNITS_FREQUENCY_H_
-
-#include <cstdint>
-#include <cstdlib>
-#include <limits>
-#include <string>
-#include <type_traits>
-
-#include "api/units/time_delta.h"
-#include "unit_base.h"  // IWYU pragma: export
-
-namespace webrtc {
-
-class Frequency final : public rtc_units_impl::RelativeUnit<Frequency> {
- public:
-  template <typename T>
-  static constexpr Frequency MilliHertz(T value) {
-    static_assert(std::is_arithmetic<T>::value, "");
-    return FromValue(value);
-  }
-  template <typename T>
-  static constexpr Frequency Hertz(T value) {
-    static_assert(std::is_arithmetic<T>::value, "");
-    return FromFraction(1'000, value);
-  }
-  template <typename T>
-  static constexpr Frequency KiloHertz(T value) {
-    static_assert(std::is_arithmetic<T>::value, "");
-    return FromFraction(1'000'000, value);
-  }
-
-  constexpr Frequency() = default;
-
-  template <typename Sink>
-  friend void AbslStringify(Sink& sink, Frequency value);
-
-  template <typename T = int64_t>
-  constexpr T hertz() const {
-    return ToFraction<1000, T>();
-  }
-  template <typename T = int64_t>
-  constexpr T millihertz() const {
-    return ToValue<T>();
-  }
-
- private:
-  friend class rtc_units_impl::UnitBase<Frequency>;
-  using RelativeUnit::RelativeUnit;
-  static constexpr bool one_sided = true;
-};
-
-inline constexpr Frequency operator/(int64_t nominator,
-                                     const TimeDelta& interval) {
-  constexpr int64_t kKiloPerMicro = 1000 * 1000000;
-  return Frequency::MilliHertz(nominator * kKiloPerMicro / interval.us());
-}
-
-inline constexpr TimeDelta operator/(int64_t nominator,
-                                     const Frequency& frequency) {
-  constexpr int64_t kMegaPerMilli = 1000000 * 1000;
-  return TimeDelta::Micros(nominator * kMegaPerMilli / frequency.millihertz());
-}
-
-inline constexpr double operator*(Frequency frequency, TimeDelta time_delta) {
-  return frequency.hertz<double>() * time_delta.seconds<double>();
-}
-inline constexpr double operator*(TimeDelta time_delta, Frequency frequency) {
-  return frequency * time_delta;
-}
-
-std::string ToString(Frequency value);
-
-template <typename Sink>
-void AbslStringify(Sink& sink, Frequency value) {
-  sink.Append(ToString(value));
-}
-
-}  // namespace webrtc
-#endif  // API_UNITS_FREQUENCY_H_

src/common/api/units/time_delta.cc

@@ -1,32 +0,0 @@
-/*
- *  Copyright (c) 2018 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 "api/units/time_delta.h"
-
-#include <string>
-
-namespace webrtc {
-
-std::string ToString(TimeDelta value) {
-  if (value.IsPlusInfinity()) {
-    return "+inf ms";
-  } else if (value.IsMinusInfinity()) {
-    return "-inf ms";
-  } else {
-    if (value.us() == 0 || (value.us() % 1000) != 0)
-      return std::to_string(value.us()) + " us";
-    else if (value.ms() % 1000 != 0)
-      return std::to_string(value.ms()) + " ms";
-    else
-      return std::to_string(value.seconds()) + " s";
-  }
-}
-
-}  // namespace webrtc

src/common/api/units/time_delta.h

@@ -1,104 +0,0 @@
-/*
- *  Copyright (c) 2018 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.
- */
-
-#ifndef API_UNITS_TIME_DELTA_H_
-#define API_UNITS_TIME_DELTA_H_
-
-#include <cstdint>
-#include <cstdlib>
-#include <string>
-#include <type_traits>
-
-#include "unit_base.h"  // IWYU pragma: export
-
-namespace webrtc {
-
-// TimeDelta represents the difference between two timestamps. Commonly this can
-// be a duration. However since two Timestamps are not guaranteed to have the
-// same epoch (they might come from different computers, making exact
-// synchronisation infeasible), the duration covered by a TimeDelta can be
-// undefined. To simplify usage, it can be constructed and converted to
-// different units, specifically seconds (s), milliseconds (ms) and
-// microseconds (us).
-class TimeDelta final : public rtc_units_impl::RelativeUnit<TimeDelta> {
- public:
-  template <typename T>
-  static constexpr TimeDelta Minutes(T value) {
-    static_assert(std::is_arithmetic<T>::value, "");
-    return Seconds(value * 60);
-  }
-  template <typename T>
-  static constexpr TimeDelta Seconds(T value) {
-    static_assert(std::is_arithmetic<T>::value, "");
-    return FromFraction(1'000'000, value);
-  }
-  template <typename T>
-  static constexpr TimeDelta Millis(T value) {
-    static_assert(std::is_arithmetic<T>::value, "");
-    return FromFraction(1'000, value);
-  }
-  template <typename T>
-  static constexpr TimeDelta Micros(T value) {
-    static_assert(std::is_arithmetic<T>::value, "");
-    return FromValue(value);
-  }
-
-  constexpr TimeDelta() = default;
-
-  template <typename Sink>
-  friend void AbslStringify(Sink& sink, TimeDelta value);
-
-  template <typename T = int64_t>
-  constexpr T seconds() const {
-    return ToFraction<1000000, T>();
-  }
-  template <typename T = int64_t>
-  constexpr T ms() const {
-    return ToFraction<1000, T>();
-  }
-  template <typename T = int64_t>
-  constexpr T us() const {
-    return ToValue<T>();
-  }
-  template <typename T = int64_t>
-  constexpr T ns() const {
-    return ToMultiple<1000, T>();
-  }
-
-  constexpr int64_t seconds_or(int64_t fallback_value) const {
-    return ToFractionOr<1000000>(fallback_value);
-  }
-  constexpr int64_t ms_or(int64_t fallback_value) const {
-    return ToFractionOr<1000>(fallback_value);
-  }
-  constexpr int64_t us_or(int64_t fallback_value) const {
-    return ToValueOr(fallback_value);
-  }
-
-  constexpr TimeDelta Abs() const {
-    return us() < 0 ? TimeDelta::Micros(-us()) : *this;
-  }
-
- private:
-  friend class rtc_units_impl::UnitBase<TimeDelta>;
-  using RelativeUnit::RelativeUnit;
-  static constexpr bool one_sided = false;
-};
-
-std::string ToString(TimeDelta value);
-
-template <typename Sink>
-void AbslStringify(Sink& sink, TimeDelta value) {
-  sink.Append(ToString(value));
-}
-
-}  // namespace webrtc
-
-#endif  // API_UNITS_TIME_DELTA_H_

src/common/api/units/timestamp.cc

@@ -1,30 +0,0 @@
-/*
- *  Copyright (c) 2018 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 "api/units/timestamp.h"
-
-#include <string>
-
-namespace webrtc {
-std::string ToString(Timestamp value) {
-  if (value.IsPlusInfinity()) {
-    return "+inf ms";
-  } else if (value.IsMinusInfinity()) {
-    return "-inf ms";
-  } else {
-    if (value.us() == 0 || (value.us() % 1000) != 0)
-      return std::to_string(value.us()) + " us";
-    else if (value.ms() % 1000 != 0)
-      return std::to_string(value.ms()) + " ms";
-    else
-      return std::to_string(value.seconds()) + " s";
-  }
-}
-}  // namespace webrtc

src/common/api/units/timestamp.h

@@ -1,120 +0,0 @@
-/*
- *  Copyright (c) 2018 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.
- */
-
-#ifndef API_UNITS_TIMESTAMP_H_
-#define API_UNITS_TIMESTAMP_H_
-
-#include <cstdint>
-#include <string>
-#include <type_traits>
-
-#include "time_delta.h"
-#include "unit_base.h"  // IWYU pragma: export
-
-namespace webrtc {
-// Timestamp represents the time that has passed since some unspecified epoch.
-// The epoch is assumed to be before any represented timestamps, this means that
-// negative values are not valid. The most notable feature is that the
-// difference of two Timestamps results in a TimeDelta.
-class Timestamp final : public rtc_units_impl::UnitBase<Timestamp> {
- public:
-  template <typename T>
-  static constexpr Timestamp Seconds(T value) {
-    static_assert(std::is_arithmetic<T>::value, "");
-    return FromFraction(1'000'000, value);
-  }
-  template <typename T>
-  static constexpr Timestamp Millis(T value) {
-    static_assert(std::is_arithmetic<T>::value, "");
-    return FromFraction(1'000, value);
-  }
-  template <typename T>
-  static constexpr Timestamp Micros(T value) {
-    static_assert(std::is_arithmetic<T>::value, "");
-    return FromValue(value);
-  }
-
-  Timestamp() = delete;
-
-  template <typename Sink>
-  friend void AbslStringify(Sink& sink, Timestamp value);
-
-  template <typename T = int64_t>
-  constexpr T seconds() const {
-    return ToFraction<1000000, T>();
-  }
-  template <typename T = int64_t>
-  constexpr T ms() const {
-    return ToFraction<1000, T>();
-  }
-  template <typename T = int64_t>
-  constexpr T us() const {
-    return ToValue<T>();
-  }
-
-  constexpr int64_t seconds_or(int64_t fallback_value) const {
-    return ToFractionOr<1000000>(fallback_value);
-  }
-  constexpr int64_t ms_or(int64_t fallback_value) const {
-    return ToFractionOr<1000>(fallback_value);
-  }
-  constexpr int64_t us_or(int64_t fallback_value) const {
-    return ToValueOr(fallback_value);
-  }
-
-  constexpr Timestamp operator+(const TimeDelta delta) const {
-    if (IsPlusInfinity() || delta.IsPlusInfinity()) {
-      return PlusInfinity();
-    } else if (IsMinusInfinity() || delta.IsMinusInfinity()) {
-      return MinusInfinity();
-    }
-    return Timestamp::Micros(us() + delta.us());
-  }
-  constexpr Timestamp operator-(const TimeDelta delta) const {
-    if (IsPlusInfinity() || delta.IsMinusInfinity()) {
-      return PlusInfinity();
-    } else if (IsMinusInfinity() || delta.IsPlusInfinity()) {
-      return MinusInfinity();
-    }
-    return Timestamp::Micros(us() - delta.us());
-  }
-  constexpr TimeDelta operator-(const Timestamp other) const {
-    if (IsPlusInfinity() || other.IsMinusInfinity()) {
-      return TimeDelta::PlusInfinity();
-    } else if (IsMinusInfinity() || other.IsPlusInfinity()) {
-      return TimeDelta::MinusInfinity();
-    }
-    return TimeDelta::Micros(us() - other.us());
-  }
-  constexpr Timestamp& operator-=(const TimeDelta delta) {
-    *this = *this - delta;
-    return *this;
-  }
-  constexpr Timestamp& operator+=(const TimeDelta delta) {
-    *this = *this + delta;
-    return *this;
-  }
-
- private:
-  friend class rtc_units_impl::UnitBase<Timestamp>;
-  using UnitBase::UnitBase;
-  static constexpr bool one_sided = true;
-};
-
-std::string ToString(Timestamp value);
-
-template <typename Sink>
-void AbslStringify(Sink& sink, Timestamp value) {
-  sink.Append(ToString(value));
-}
-
-}  // namespace webrtc
-
-#endif  // API_UNITS_TIMESTAMP_H_

src/common/api/units/unit_base.h

@@ -1,275 +0,0 @@
-/*
- *  Copyright 2018 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.
- */
-#ifndef RTC_BASE_UNITS_UNIT_BASE_H_
-#define RTC_BASE_UNITS_UNIT_BASE_H_
-
-#include <stdint.h>
-
-#include <algorithm>
-#include <cmath>
-#include <limits>
-#include <type_traits>
-
-#include "rtc_base/numerics/divide_round.h"
-#include "rtc_base/numerics/safe_conversions.h"
-
-namespace webrtc {
-namespace rtc_units_impl {
-
-// UnitBase is a base class for implementing custom value types with a specific
-// unit. It provides type safety and commonly useful operations. The underlying
-// storage is always an int64_t, it's up to the unit implementation to choose
-// what scale it represents.
-//
-// It's used like:
-// class MyUnit: public UnitBase<MyUnit> {...};
-//
-// Unit_T is the subclass representing the specific unit.
-template <class Unit_T>
-class UnitBase {
- public:
-  UnitBase() = delete;
-  static constexpr Unit_T Zero() { return Unit_T(0); }
-  static constexpr Unit_T PlusInfinity() { return Unit_T(PlusInfinityVal()); }
-  static constexpr Unit_T MinusInfinity() { return Unit_T(MinusInfinityVal()); }
-
-  constexpr bool IsZero() const { return value_ == 0; }
-  constexpr bool IsFinite() const { return !IsInfinite(); }
-  constexpr bool IsInfinite() const {
-    return value_ == PlusInfinityVal() || value_ == MinusInfinityVal();
-  }
-  constexpr bool IsPlusInfinity() const { return value_ == PlusInfinityVal(); }
-  constexpr bool IsMinusInfinity() const {
-    return value_ == MinusInfinityVal();
-  }
-
-  constexpr bool operator==(const UnitBase<Unit_T>& other) const {
-    return value_ == other.value_;
-  }
-  constexpr bool operator!=(const UnitBase<Unit_T>& other) const {
-    return value_ != other.value_;
-  }
-  constexpr bool operator<=(const UnitBase<Unit_T>& other) const {
-    return value_ <= other.value_;
-  }
-  constexpr bool operator>=(const UnitBase<Unit_T>& other) const {
-    return value_ >= other.value_;
-  }
-  constexpr bool operator>(const UnitBase<Unit_T>& other) const {
-    return value_ > other.value_;
-  }
-  constexpr bool operator<(const UnitBase<Unit_T>& other) const {
-    return value_ < other.value_;
-  }
-  constexpr Unit_T RoundTo(const Unit_T& resolution) const {
-    return Unit_T((value_ + resolution.value_ / 2) / resolution.value_) *
-           resolution.value_;
-  }
-  constexpr Unit_T RoundUpTo(const Unit_T& resolution) const {
-    return Unit_T((value_ + resolution.value_ - 1) / resolution.value_) *
-           resolution.value_;
-  }
-  constexpr Unit_T RoundDownTo(const Unit_T& resolution) const {
-    return Unit_T(value_ / resolution.value_) * resolution.value_;
-  }
-
- protected:
-  template <typename T, typename std::enable_if<
-                            std::is_integral<T>::value>::type* = nullptr>
-  static constexpr Unit_T FromValue(T value) {
-    return Unit_T(rtc::dchecked_cast<int64_t>(value));
-  }
-  template <typename T, typename std::enable_if<
-                            std::is_floating_point<T>::value>::type* = nullptr>
-  static constexpr Unit_T FromValue(T value) {
-    if (value == std::numeric_limits<T>::infinity()) {
-      return PlusInfinity();
-    } else if (value == -std::numeric_limits<T>::infinity()) {
-      return MinusInfinity();
-    } else {
-      return FromValue(rtc::dchecked_cast<int64_t>(value));
-    }
-  }
-
-  template <typename T, typename std::enable_if<
-                            std::is_integral<T>::value>::type* = nullptr>
-  static constexpr Unit_T FromFraction(int64_t denominator, T value) {
-    return Unit_T(rtc::dchecked_cast<int64_t>(value * denominator));
-  }
-  template <typename T, typename std::enable_if<
-                            std::is_floating_point<T>::value>::type* = nullptr>
-  static constexpr Unit_T FromFraction(int64_t denominator, T value) {
-    return FromValue(value * denominator);
-  }
-
-  template <typename T = int64_t>
-  constexpr typename std::enable_if<std::is_integral<T>::value, T>::type
-  ToValue() const {
-    return rtc::dchecked_cast<T>(value_);
-  }
-  template <typename T>
-  constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
-  ToValue() const {
-    return IsPlusInfinity()    ? std::numeric_limits<T>::infinity()
-           : IsMinusInfinity() ? -std::numeric_limits<T>::infinity()
-                               : value_;
-  }
-  template <typename T>
-  constexpr T ToValueOr(T fallback_value) const {
-    return IsFinite() ? value_ : fallback_value;
-  }
-
-  template <int64_t Denominator, typename T = int64_t>
-  constexpr typename std::enable_if<std::is_integral<T>::value, T>::type
-  ToFraction() const {
-    return rtc::dchecked_cast<T>(DivideRoundToNearest(value_, Denominator));
-  }
-  template <int64_t Denominator, typename T>
-  constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
-  ToFraction() const {
-    return ToValue<T>() * (1 / static_cast<T>(Denominator));
-  }
-
-  template <int64_t Denominator>
-  constexpr int64_t ToFractionOr(int64_t fallback_value) const {
-    return IsFinite() ? DivideRoundToNearest(value_, Denominator)
-                      : fallback_value;
-  }
-
-  template <int64_t Factor, typename T = int64_t>
-  constexpr typename std::enable_if<std::is_integral<T>::value, T>::type
-  ToMultiple() const {
-    return rtc::dchecked_cast<T>(ToValue() * Factor);
-  }
-  template <int64_t Factor, typename T>
-  constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
-  ToMultiple() const {
-    return ToValue<T>() * Factor;
-  }
-
-  explicit constexpr UnitBase(int64_t value) : value_(value) {}
-
- private:
-  template <class RelativeUnit_T>
-  friend class RelativeUnit;
-
-  static inline constexpr int64_t PlusInfinityVal() {
-    return std::numeric_limits<int64_t>::max();
-  }
-  static inline constexpr int64_t MinusInfinityVal() {
-    return std::numeric_limits<int64_t>::min();
-  }
-
-  constexpr Unit_T& AsSubClassRef() { return static_cast<Unit_T&>(*this); }
-  constexpr const Unit_T& AsSubClassRef() const {
-    return static_cast<const Unit_T&>(*this);
-  }
-
-  int64_t value_;
-};
-
-// Extends UnitBase to provide operations for relative units, that is, units
-// that have a meaningful relation between values such that a += b is a
-// sensible thing to do. For a,b <- same unit.
-template <class Unit_T>
-class RelativeUnit : public UnitBase<Unit_T> {
- public:
-  constexpr Unit_T Clamped(Unit_T min_value, Unit_T max_value) const {
-    return std::max(min_value,
-                    std::min(UnitBase<Unit_T>::AsSubClassRef(), max_value));
-  }
-  constexpr void Clamp(Unit_T min_value, Unit_T max_value) {
-    *this = Clamped(min_value, max_value);
-  }
-  constexpr Unit_T operator+(const Unit_T other) const {
-    if (this->IsPlusInfinity() || other.IsPlusInfinity()) {
-      return this->PlusInfinity();
-    } else if (this->IsMinusInfinity() || other.IsMinusInfinity()) {
-      return this->MinusInfinity();
-    }
-    return UnitBase<Unit_T>::FromValue(this->ToValue() + other.ToValue());
-  }
-  constexpr Unit_T operator-(const Unit_T other) const {
-    if (this->IsPlusInfinity() || other.IsMinusInfinity()) {
-      return this->PlusInfinity();
-    } else if (this->IsMinusInfinity() || other.IsPlusInfinity()) {
-      return this->MinusInfinity();
-    }
-    return UnitBase<Unit_T>::FromValue(this->ToValue() - other.ToValue());
-  }
-  constexpr Unit_T& operator+=(const Unit_T other) {
-    *this = *this + other;
-    return this->AsSubClassRef();
-  }
-  constexpr Unit_T& operator-=(const Unit_T other) {
-    *this = *this - other;
-    return this->AsSubClassRef();
-  }
-  constexpr double operator/(const Unit_T other) const {
-    return UnitBase<Unit_T>::template ToValue<double>() /
-           other.template ToValue<double>();
-  }
-  template <typename T,
-            typename std::enable_if_t<std::is_floating_point_v<T>>* = nullptr>
-  constexpr Unit_T operator/(T scalar) const {
-    return UnitBase<Unit_T>::FromValue(std::llround(this->ToValue() / scalar));
-  }
-  template <typename T,
-            typename std::enable_if_t<std::is_integral_v<T>>* = nullptr>
-  constexpr Unit_T operator/(T scalar) const {
-    return UnitBase<Unit_T>::FromValue(this->ToValue() / scalar);
-  }
-  constexpr Unit_T operator*(double scalar) const {
-    return UnitBase<Unit_T>::FromValue(std::llround(this->ToValue() * scalar));
-  }
-  constexpr Unit_T operator*(int64_t scalar) const {
-    return UnitBase<Unit_T>::FromValue(this->ToValue() * scalar);
-  }
-  constexpr Unit_T operator*(int32_t scalar) const {
-    return UnitBase<Unit_T>::FromValue(this->ToValue() * scalar);
-  }
-  constexpr Unit_T operator*(size_t scalar) const {
-    return UnitBase<Unit_T>::FromValue(this->ToValue() * scalar);
-  }
-
- protected:
-  using UnitBase<Unit_T>::UnitBase;
-  constexpr RelativeUnit() : UnitBase<Unit_T>(0) {}
-};
-
-template <class Unit_T>
-inline constexpr Unit_T operator*(double scalar, RelativeUnit<Unit_T> other) {
-  return other * scalar;
-}
-template <class Unit_T>
-inline constexpr Unit_T operator*(int64_t scalar, RelativeUnit<Unit_T> other) {
-  return other * scalar;
-}
-template <class Unit_T>
-inline constexpr Unit_T operator*(int32_t scalar, RelativeUnit<Unit_T> other) {
-  return other * scalar;
-}
-template <class Unit_T>
-inline constexpr Unit_T operator*(size_t scalar, RelativeUnit<Unit_T> other) {
-  return other * scalar;
-}
-
-template <class Unit_T>
-inline constexpr Unit_T operator-(RelativeUnit<Unit_T> other) {
-  if (other.IsPlusInfinity()) return UnitBase<Unit_T>::MinusInfinity();
-  if (other.IsMinusInfinity()) return UnitBase<Unit_T>::PlusInfinity();
-  return -1 * other;
-}
-
-}  // namespace rtc_units_impl
-
-}  // namespace webrtc
-
-#endif  // RTC_BASE_UNITS_UNIT_BASE_H_

src/common/api/video/video_timing.cc

@@ -1,118 +0,0 @@
-/*
- *  Copyright (c) 2017 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 "api/video/video_timing.h"
-
-#include <algorithm>
-#include <cstdint>
-#include <string>
-
-#include "api/array_view.h"
-#include "api/units/time_delta.h"
-#include "log.h"
-#include "rtc_base/numerics/safe_conversions.h"
-
-namespace webrtc {
-
-uint16_t VideoSendTiming::GetDeltaCappedMs(int64_t base_ms, int64_t time_ms) {
-  if (time_ms < base_ms) {
-    LOG_ERROR("Delta {} ms expected to be positive", (time_ms - base_ms));
-  }
-  return rtc::saturated_cast<uint16_t>(time_ms - base_ms);
-}
-
-uint16_t VideoSendTiming::GetDeltaCappedMs(TimeDelta delta) {
-  if (delta < TimeDelta::Zero()) {
-    LOG_ERROR("Delta {} ms expected to be positive", delta.ms());
-  }
-  return rtc::saturated_cast<uint16_t>(delta.ms());
-}
-
-TimingFrameInfo::TimingFrameInfo()
-    : rtp_timestamp(0),
-      capture_time_ms(-1),
-      encode_start_ms(-1),
-      encode_finish_ms(-1),
-      packetization_finish_ms(-1),
-      pacer_exit_ms(-1),
-      network_timestamp_ms(-1),
-      network2_timestamp_ms(-1),
-      receive_start_ms(-1),
-      receive_finish_ms(-1),
-      decode_start_ms(-1),
-      decode_finish_ms(-1),
-      render_time_ms(-1),
-      flags(VideoSendTiming::kNotTriggered) {}
-
-int64_t TimingFrameInfo::EndToEndDelay() const {
-  return capture_time_ms >= 0 ? decode_finish_ms - capture_time_ms : -1;
-}
-
-bool TimingFrameInfo::IsLongerThan(const TimingFrameInfo& other) const {
-  int64_t other_delay = other.EndToEndDelay();
-  return other_delay == -1 || EndToEndDelay() > other_delay;
-}
-
-bool TimingFrameInfo::operator<(const TimingFrameInfo& other) const {
-  return other.IsLongerThan(*this);
-}
-
-bool TimingFrameInfo::operator<=(const TimingFrameInfo& other) const {
-  return !IsLongerThan(other);
-}
-
-bool TimingFrameInfo::IsOutlier() const {
-  return !IsInvalid() && (flags & VideoSendTiming::kTriggeredBySize);
-}
-
-bool TimingFrameInfo::IsTimerTriggered() const {
-  return !IsInvalid() && (flags & VideoSendTiming::kTriggeredByTimer);
-}
-
-bool TimingFrameInfo::IsInvalid() const {
-  return flags == VideoSendTiming::kInvalid;
-}
-
-std::string TimingFrameInfo::ToString() const {
-  if (IsInvalid()) {
-    return "";
-  }
-
-  std::ostringstream oss;
-  oss << rtp_timestamp << ',' << capture_time_ms << ',' << encode_start_ms
-      << ',' << encode_finish_ms << ',' << packetization_finish_ms << ','
-      << pacer_exit_ms << ',' << network_timestamp_ms << ','
-      << network2_timestamp_ms << ',' << receive_start_ms << ','
-      << receive_finish_ms << ',' << decode_start_ms << ',' << decode_finish_ms
-      << ',' << render_time_ms << ',' << IsOutlier() << ','
-      << IsTimerTriggered();
-
-  return oss.str();
-}
-
-VideoPlayoutDelay::VideoPlayoutDelay(TimeDelta min, TimeDelta max)
-    : min_(std::clamp(min, TimeDelta::Zero(), kMax)),
-      max_(std::clamp(max, min_, kMax)) {
-  if (!(TimeDelta::Zero() <= min && min <= max && max <= kMax)) {
-    LOG_ERROR("Invalid video playout delay: [{},{}]. Clamped to [{},{}]", min,
-              max, this->min(), this->max());
-  }
-}
-
-bool VideoPlayoutDelay::Set(TimeDelta min, TimeDelta max) {
-  if (TimeDelta::Zero() <= min && min <= max && max <= kMax) {
-    min_ = min;
-    max_ = max;
-    return true;
-  }
-  return false;
-}
-
-}  // namespace webrtc

src/common/api/video/video_timing.h

@@ -1,149 +0,0 @@
-/*
- *  Copyright (c) 2017 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.
- */
-
-#ifndef API_VIDEO_VIDEO_TIMING_H_
-#define API_VIDEO_VIDEO_TIMING_H_
-
-#include <stdint.h>
-
-#include <limits>
-#include <string>
-
-#include "api/units/time_delta.h"
-
-namespace webrtc {
-
-// Video timing timestamps in ms counted from capture_time_ms of a frame.
-// This structure represents data sent in video-timing RTP header extension.
-struct VideoSendTiming {
-  enum TimingFrameFlags : uint8_t {
-    kNotTriggered = 0,  // Timing info valid, but not to be transmitted.
-                        // Used on send-side only.
-    kTriggeredByTimer = 1 << 0,  // Frame marked for tracing by periodic timer.
-    kTriggeredBySize = 1 << 1,   // Frame marked for tracing due to size.
-    kInvalid = std::numeric_limits<uint8_t>::max()  // Invalid, ignore!
-  };
-
-  // Returns |time_ms - base_ms| capped at max 16-bit value.
-  // Used to fill this data structure as per
-  // https://webrtc.org/experiments/rtp-hdrext/video-timing/ extension stores
-  // 16-bit deltas of timestamps from packet capture time.
-  static uint16_t GetDeltaCappedMs(int64_t base_ms, int64_t time_ms);
-  static uint16_t GetDeltaCappedMs(TimeDelta delta);
-
-  uint16_t encode_start_delta_ms;
-  uint16_t encode_finish_delta_ms;
-  uint16_t packetization_finish_delta_ms;
-  uint16_t pacer_exit_delta_ms;
-  uint16_t network_timestamp_delta_ms;
-  uint16_t network2_timestamp_delta_ms;
-  uint8_t flags = TimingFrameFlags::kInvalid;
-};
-
-// Used to report precise timings of a 'timing frames'. Contains all important
-// timestamps for a lifetime of that specific frame. Reported as a string via
-// GetStats(). Only frame which took the longest between two GetStats calls is
-// reported.
-struct TimingFrameInfo {
-  TimingFrameInfo();
-
-  // Returns end-to-end delay of a frame, if sender and receiver timestamps are
-  // synchronized, -1 otherwise.
-  int64_t EndToEndDelay() const;
-
-  // Returns true if current frame took longer to process than `other` frame.
-  // If other frame's clocks are not synchronized, current frame is always
-  // preferred.
-  bool IsLongerThan(const TimingFrameInfo& other) const;
-
-  // Returns true if flags are set to indicate this frame was marked for tracing
-  // due to the size being outside some limit.
-  bool IsOutlier() const;
-
-  // Returns true if flags are set to indicate this frame was marked fro tracing
-  // due to cyclic timer.
-  bool IsTimerTriggered() const;
-
-  // Returns true if the timing data is marked as invalid, in which case it
-  // should be ignored.
-  bool IsInvalid() const;
-
-  std::string ToString() const;
-
-  bool operator<(const TimingFrameInfo& other) const;
-
-  bool operator<=(const TimingFrameInfo& other) const;
-
-  uint32_t rtp_timestamp;  // Identifier of a frame.
-  // All timestamps below are in local monotonous clock of a receiver.
-  // If sender clock is not yet estimated, sender timestamps
-  // (capture_time_ms ... pacer_exit_ms) are negative values, still
-  // relatively correct.
-  int64_t capture_time_ms;          // Captrue time of a frame.
-  int64_t encode_start_ms;          // Encode start time.
-  int64_t encode_finish_ms;         // Encode completion time.
-  int64_t packetization_finish_ms;  // Time when frame was passed to pacer.
-  int64_t pacer_exit_ms;  // Time when last packet was pushed out of pacer.
-  // Two in-network RTP processor timestamps: meaning is application specific.
-  int64_t network_timestamp_ms;
-  int64_t network2_timestamp_ms;
-  int64_t receive_start_ms;   // First received packet time.
-  int64_t receive_finish_ms;  // Last received packet time.
-  int64_t decode_start_ms;    // Decode start time.
-  int64_t decode_finish_ms;   // Decode completion time.
-  int64_t render_time_ms;     // Proposed render time to insure smooth playback.
-
-  uint8_t flags;  // Flags indicating validity and/or why tracing was triggered.
-};
-
-// Minimum and maximum playout delay values from capture to render.
-// These are best effort values.
-//
-// min = max = 0 indicates that the receiver should try and render
-// frame as soon as possible.
-//
-// min = x, max = y indicates that the receiver is free to adapt
-// in the range (x, y) based on network jitter.
-// This class ensures invariant 0 <= min <= max <= kMax.
-class VideoPlayoutDelay {
- public:
-  // Maximum supported value for the delay limit.
-  static constexpr TimeDelta kMax = TimeDelta::Millis(10) * 0xFFF;
-
-  // Creates delay limits that indicates receiver should try to render frame
-  // as soon as possible.
-  static VideoPlayoutDelay Minimal() {
-    return VideoPlayoutDelay(TimeDelta::Zero(), TimeDelta::Zero());
-  }
-
-  // Creates valid, but unspecified limits.
-  VideoPlayoutDelay() = default;
-  VideoPlayoutDelay(const VideoPlayoutDelay&) = default;
-  VideoPlayoutDelay& operator=(const VideoPlayoutDelay&) = default;
-  VideoPlayoutDelay(TimeDelta min, TimeDelta max);
-
-  bool Set(TimeDelta min, TimeDelta max);
-
-  TimeDelta min() const { return min_; }
-  TimeDelta max() const { return max_; }
-
-  friend bool operator==(const VideoPlayoutDelay& lhs,
-                         const VideoPlayoutDelay& rhs) {
-    return lhs.min_ == rhs.min_ && lhs.max_ == rhs.max_;
-  }
-
- private:
-  TimeDelta min_ = TimeDelta::Zero();
-  TimeDelta max_ = kMax;
-};
-
-}  // namespace webrtc
-
-#endif  // API_VIDEO_VIDEO_TIMING_H_

src/common/byte_io.h

@@ -1,390 +0,0 @@
-/*
- * @Author: DI JUNKUN
- * @Date: 2024-12-18
- * Copyright 2018 The WebRTC project authors. All Rights Reserved.
- */
-
-#ifndef _BYTE_IO_H_
-#define _BYTE_IO_H_
-
-// This file contains classes for reading and writing integer types from/to
-// byte array representations. Signed/unsigned, partial (whole byte) sizes,
-// and big/little endian byte order is all supported.
-//
-// Usage examples:
-//
-// uint8_t* buffer = ...;
-//
-// // Read an unsigned 4 byte integer in big endian format
-// uint32_t val = ByteReader<uint32_t>::ReadBigEndian(buffer);
-//
-// // Read a signed 24-bit (3 byte) integer in little endian format
-// int32_t val = ByteReader<int32_t, 3>::ReadLittle(buffer);
-//
-// // Write an unsigned 8 byte integer in little endian format
-// ByteWriter<uint64_t>::WriteLittleEndian(buffer, val);
-//
-// Write an unsigned 40-bit (5 byte) integer in big endian format
-// ByteWriter<uint64_t, 5>::WriteBigEndian(buffer, val);
-//
-// These classes are implemented as recursive templetizations, intended to make
-// it easy for the compiler to completely inline the reading/writing.
-
-#include <stdint.h>
-
-#include <limits>
-
-// According to ISO C standard ISO/IEC 9899, section 6.2.6.2 (2), the three
-// representations of signed integers allowed are two's complement, one's
-// complement and sign/magnitude. We can detect which is used by looking at
-// the two last bits of -1, which will be 11 in two's complement, 10 in one's
-// complement and 01 in sign/magnitude.
-// TODO(sprang): In the unlikely event that we actually need to support a
-// platform that doesn't use two's complement, implement conversion to/from
-// wire format.
-
-// Assume the if any one signed integer type is two's complement, then all
-// other will be too.
-static_assert(
-    (-1 & 0x03) == 0x03,
-    "Only two's complement representation of signed integers supported.");
-
-// Plain const char* won't work for static_assert, use #define instead.
-#define kSizeErrorMsg "Byte size must be less than or equal to data type size."
-
-// Utility class for getting the unsigned equivalent of a signed type.
-template <typename T>
-struct UnsignedOf;
-
-// Class for reading integers from a sequence of bytes.
-// T = type of integer, B = bytes to read, is_signed = true if signed integer.
-// If is_signed is true and B < sizeof(T), sign extension might be needed.
-template <typename T, unsigned int B = sizeof(T),
-          bool is_signed = std::numeric_limits<T>::is_signed>
-class ByteReader;
-
-// Specialization of ByteReader for unsigned types.
-template <typename T, unsigned int B>
-class ByteReader<T, B, false> {
- public:
-  static T ReadBigEndian(const uint8_t* data) {
-    static_assert(B <= sizeof(T), kSizeErrorMsg);
-    return InternalReadBigEndian(data);
-  }
-
-  static T ReadLittleEndian(const uint8_t* data) {
-    static_assert(B <= sizeof(T), kSizeErrorMsg);
-    return InternalReadLittleEndian(data);
-  }
-
- private:
-  static T InternalReadBigEndian(const uint8_t* data) {
-    T val(0);
-    for (unsigned int i = 0; i < B; ++i)
-      val |= static_cast<T>(data[i]) << ((B - 1 - i) * 8);
-    return val;
-  }
-
-  static T InternalReadLittleEndian(const uint8_t* data) {
-    T val(0);
-    for (unsigned int i = 0; i < B; ++i)
-      val |= static_cast<T>(data[i]) << (i * 8);
-    return val;
-  }
-};
-
-// Specialization of ByteReader for signed types.
-template <typename T, unsigned int B>
-class ByteReader<T, B, true> {
- public:
-  typedef typename UnsignedOf<T>::Type U;
-
-  static T ReadBigEndian(const uint8_t* data) {
-    U unsigned_val = ByteReader<T, B, false>::ReadBigEndian(data);
-    if (B < sizeof(T)) unsigned_val = SignExtend(unsigned_val);
-    return ReinterpretAsSigned(unsigned_val);
-  }
-
-  static T ReadLittleEndian(const uint8_t* data) {
-    U unsigned_val = ByteReader<T, B, false>::ReadLittleEndian(data);
-    if (B < sizeof(T)) unsigned_val = SignExtend(unsigned_val);
-    return ReinterpretAsSigned(unsigned_val);
-  }
-
- private:
-  // As a hack to avoid implementation-specific or undefined behavior when
-  // bit-shifting or casting signed integers, read as a signed equivalent
-  // instead and convert to signed. This is safe since we have asserted that
-  // two's complement for is used.
-  static T ReinterpretAsSigned(U unsigned_val) {
-    // An unsigned value with only the highest order bit set (ex 0x80).
-    const U kUnsignedHighestBitMask = static_cast<U>(1)
-                                      << ((sizeof(U) * 8) - 1);
-    // A signed value with only the highest bit set. Since this is two's
-    // complement form, we can use the min value from std::numeric_limits.
-    const T kSignedHighestBitMask = std::numeric_limits<T>::min();
-
-    T val;
-    if ((unsigned_val & kUnsignedHighestBitMask) != 0) {
-      // Casting is only safe when unsigned value can be represented in the
-      // signed target type, so mask out highest bit and mask it back manually.
-      val = static_cast<T>(unsigned_val & ~kUnsignedHighestBitMask);
-      val |= kSignedHighestBitMask;
-    } else {
-      val = static_cast<T>(unsigned_val);
-    }
-    return val;
-  }
-
-  // If number of bytes is less than native data type (eg 24 bit, in int32_t),
-  // and the most significant bit of the actual data is set, we must sign
-  // extend the remaining byte(s) with ones so that the correct negative
-  // number is retained.
-  // Ex: 0x810A0B -> 0xFF810A0B, but 0x710A0B -> 0x00710A0B
-  static U SignExtend(const U val) {
-    const uint8_t kMsb = static_cast<uint8_t>(val >> ((B - 1) * 8));
-    if ((kMsb & 0x80) != 0) {
-      // Create a mask where all bits used by the B bytes are set to one,
-      // for instance 0x00FFFFFF for B = 3. Bit-wise invert that mask (to
-      // (0xFF000000 in the example above) and add it to the input value.
-      // The "B % sizeof(T)" is a workaround to undefined values warnings for
-      // B == sizeof(T), in which case this code won't be called anyway.
-      const U kUsedBitsMask = (1 << ((B % sizeof(T)) * 8)) - 1;
-      return ~kUsedBitsMask | val;
-    }
-    return val;
-  }
-};
-
-// Class for writing integers to a sequence of bytes
-// T = type of integer, B = bytes to write
-template <typename T, unsigned int B = sizeof(T),
-          bool is_signed = std::numeric_limits<T>::is_signed>
-class ByteWriter;
-
-// Specialization of ByteWriter for unsigned types.
-template <typename T, unsigned int B>
-class ByteWriter<T, B, false> {
- public:
-  static void WriteBigEndian(uint8_t* data, T val) {
-    static_assert(B <= sizeof(T), kSizeErrorMsg);
-    for (unsigned int i = 0; i < B; ++i) {
-      data[i] = val >> ((B - 1 - i) * 8);
-    }
-  }
-
-  static void WriteLittleEndian(uint8_t* data, T val) {
-    static_assert(B <= sizeof(T), kSizeErrorMsg);
-    for (unsigned int i = 0; i < B; ++i) {
-      data[i] = val >> (i * 8);
-    }
-  }
-};
-
-// Specialization of ByteWriter for signed types.
-template <typename T, unsigned int B>
-class ByteWriter<T, B, true> {
- public:
-  typedef typename UnsignedOf<T>::Type U;
-
-  static void WriteBigEndian(uint8_t* data, T val) {
-    ByteWriter<U, B, false>::WriteBigEndian(data, ReinterpretAsUnsigned(val));
-  }
-
-  static void WriteLittleEndian(uint8_t* data, T val) {
-    ByteWriter<U, B, false>::WriteLittleEndian(data,
-                                               ReinterpretAsUnsigned(val));
-  }
-
- private:
-  static U ReinterpretAsUnsigned(T val) {
-    // According to ISO C standard ISO/IEC 9899, section 6.3.1.3 (1, 2) a
-    // conversion from signed to unsigned keeps the value if the new type can
-    // represent it, and otherwise adds one more than the max value of T until
-    // the value is in range. For two's complement, this fortunately means
-    // that the bit-wise value will be intact. Thus, since we have asserted that
-    // two's complement form is actually used, a simple cast is sufficient.
-    return static_cast<U>(val);
-  }
-};
-
-// ----- Below follows specializations of UnsignedOf utility class -----
-
-template <>
-struct UnsignedOf<int8_t> {
-  typedef uint8_t Type;
-};
-template <>
-struct UnsignedOf<int16_t> {
-  typedef uint16_t Type;
-};
-template <>
-struct UnsignedOf<int32_t> {
-  typedef uint32_t Type;
-};
-template <>
-struct UnsignedOf<int64_t> {
-  typedef uint64_t Type;
-};
-
-// ----- Below follows specializations for unsigned, B in { 1, 2, 4, 8 } -----
-
-// TODO(sprang): Check if these actually help or if generic cases will be
-// unrolled to and optimized to similar performance.
-
-// Specializations for single bytes
-template <typename T>
-class ByteReader<T, 1, false> {
- public:
-  static T ReadBigEndian(const uint8_t* data) {
-    static_assert(sizeof(T) == 1, kSizeErrorMsg);
-    return data[0];
-  }
-
-  static T ReadLittleEndian(const uint8_t* data) {
-    static_assert(sizeof(T) == 1, kSizeErrorMsg);
-    return data[0];
-  }
-};
-
-template <typename T>
-class ByteWriter<T, 1, false> {
- public:
-  static void WriteBigEndian(uint8_t* data, T val) {
-    static_assert(sizeof(T) == 1, kSizeErrorMsg);
-    data[0] = val;
-  }
-
-  static void WriteLittleEndian(uint8_t* data, T val) {
-    static_assert(sizeof(T) == 1, kSizeErrorMsg);
-    data[0] = val;
-  }
-};
-
-// Specializations for two byte words
-template <typename T>
-class ByteReader<T, 2, false> {
- public:
-  static T ReadBigEndian(const uint8_t* data) {
-    static_assert(sizeof(T) >= 2, kSizeErrorMsg);
-    return (data[0] << 8) | data[1];
-  }
-
-  static T ReadLittleEndian(const uint8_t* data) {
-    static_assert(sizeof(T) >= 2, kSizeErrorMsg);
-    return data[0] | (data[1] << 8);
-  }
-};
-
-template <typename T>
-class ByteWriter<T, 2, false> {
- public:
-  static void WriteBigEndian(uint8_t* data, T val) {
-    static_assert(sizeof(T) >= 2, kSizeErrorMsg);
-    data[0] = val >> 8;
-    data[1] = val;
-  }
-
-  static void WriteLittleEndian(uint8_t* data, T val) {
-    static_assert(sizeof(T) >= 2, kSizeErrorMsg);
-    data[0] = val;
-    data[1] = val >> 8;
-  }
-};
-
-// Specializations for four byte words.
-template <typename T>
-class ByteReader<T, 4, false> {
- public:
-  static T ReadBigEndian(const uint8_t* data) {
-    static_assert(sizeof(T) >= 4, kSizeErrorMsg);
-    return (Get(data, 0) << 24) | (Get(data, 1) << 16) | (Get(data, 2) << 8) |
-           Get(data, 3);
-  }
-
-  static T ReadLittleEndian(const uint8_t* data) {
-    static_assert(sizeof(T) >= 4, kSizeErrorMsg);
-    return Get(data, 0) | (Get(data, 1) << 8) | (Get(data, 2) << 16) |
-           (Get(data, 3) << 24);
-  }
-
- private:
-  inline static T Get(const uint8_t* data, unsigned int index) {
-    return static_cast<T>(data[index]);
-  }
-};
-
-// Specializations for four byte words.
-template <typename T>
-class ByteWriter<T, 4, false> {
- public:
-  static void WriteBigEndian(uint8_t* data, T val) {
-    static_assert(sizeof(T) >= 4, kSizeErrorMsg);
-    data[0] = val >> 24;
-    data[1] = val >> 16;
-    data[2] = val >> 8;
-    data[3] = val;
-  }
-
-  static void WriteLittleEndian(uint8_t* data, T val) {
-    static_assert(sizeof(T) >= 4, kSizeErrorMsg);
-    data[0] = val;
-    data[1] = val >> 8;
-    data[2] = val >> 16;
-    data[3] = val >> 24;
-  }
-};
-
-// Specializations for eight byte words.
-template <typename T>
-class ByteReader<T, 8, false> {
- public:
-  static T ReadBigEndian(const uint8_t* data) {
-    static_assert(sizeof(T) >= 8, kSizeErrorMsg);
-    return (Get(data, 0) << 56) | (Get(data, 1) << 48) | (Get(data, 2) << 40) |
-           (Get(data, 3) << 32) | (Get(data, 4) << 24) | (Get(data, 5) << 16) |
-           (Get(data, 6) << 8) | Get(data, 7);
-  }
-
-  static T ReadLittleEndian(const uint8_t* data) {
-    static_assert(sizeof(T) >= 8, kSizeErrorMsg);
-    return Get(data, 0) | (Get(data, 1) << 8) | (Get(data, 2) << 16) |
-           (Get(data, 3) << 24) | (Get(data, 4) << 32) | (Get(data, 5) << 40) |
-           (Get(data, 6) << 48) | (Get(data, 7) << 56);
-  }
-
- private:
-  inline static T Get(const uint8_t* data, unsigned int index) {
-    return static_cast<T>(data[index]);
-  }
-};
-
-template <typename T>
-class ByteWriter<T, 8, false> {
- public:
-  static void WriteBigEndian(uint8_t* data, T val) {
-    static_assert(sizeof(T) >= 8, kSizeErrorMsg);
-    data[0] = val >> 56;
-    data[1] = val >> 48;
-    data[2] = val >> 40;
-    data[3] = val >> 32;
-    data[4] = val >> 24;
-    data[5] = val >> 16;
-    data[6] = val >> 8;
-    data[7] = val;
-  }
-
-  static void WriteLittleEndian(uint8_t* data, T val) {
-    static_assert(sizeof(T) >= 8, kSizeErrorMsg);
-    data[0] = val;
-    data[1] = val >> 8;
-    data[2] = val >> 16;
-    data[3] = val >> 24;
-    data[4] = val >> 32;
-    data[5] = val >> 40;
-    data[6] = val >> 48;
-    data[7] = val >> 56;
-  }
-};
-
-#endif

src/common/clock/system_clock.cpp

@@ -1,140 +0,0 @@
-#include "system_clock.h"
-
-#include <time.h>
-
-#include <cstdint>
-#include <limits>
-
-#if defined(__POSIX__)
-#include <sys/time.h>
-#endif
-#if defined(__APPLE__)
-#include <mach/mach_time.h>
-#endif
-#if defined(_WIN32)
-#include <windows.h>
-#endif
-
-int64_t SystemClock::ConvertToNtpTime(int64_t time_us) {
-  constexpr int64_t kMicrosecondsPerSecond = 1000000;
-  constexpr uint64_t kNtpFractionalUnit = 0x100000000;  // 2^32
-  uint32_t seconds = static_cast<uint32_t>(time_us / kMicrosecondsPerSecond);
-  uint32_t fractions =
-      static_cast<uint32_t>((time_us % kMicrosecondsPerSecond) *
-                            kNtpFractionalUnit / kMicrosecondsPerSecond);
-
-  return seconds * kNtpFractionalUnit + fractions;
-}
-
-int64_t SystemClock::CurrentTimeNs() {
-  int64_t ticks = -1;  // Default to error case
-
-#if defined(__APPLE__)
-  static mach_timebase_info_data_t timebase;
-  if (timebase.denom == 0 && mach_timebase_info(&timebase) != KERN_SUCCESS) {
-    return -1;  // Error case for macOS timebase info retrieval
-  }
-  ticks = static_cast<int64_t>(mach_absolute_time() * timebase.numer) /
-          timebase.denom;
-
-#elif defined(__POSIX__)
-  struct timespec ts;
-  if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) {
-    return -1;  // Error case for POSIX clock retrieval
-  }
-  ticks = static_cast<int64_t>(ts.tv_sec) * kNumNanosecsPerSec +
-          static_cast<int64_t>(ts.tv_nsec);
-
-#elif defined(_WIN32)
-  static volatile LONG last_timegettime = 0;
-  static volatile int64_t num_wrap_timegettime = 0;
-  volatile LONG* last_timegettime_ptr = &last_timegettime;
-
-  DWORD now = timeGetTime();
-  DWORD old = InterlockedExchange(last_timegettime_ptr, now);
-
-  if (now < old) {
-    // Handle wraparound (when timeGetTime() wraps around after ~49.7 days)
-    if (old > 0xf0000000 && now < 0x0fffffff) {
-      num_wrap_timegettime++;
-    }
-  }
-
-  // Convert milliseconds to nanoseconds and add wraparound offset
-  ticks = static_cast<int64_t>(now) + (num_wrap_timegettime << 32);
-  ticks *= 1000000;
-#endif
-
-  return ticks;
-}
-
-int64_t SystemClock::CurrentTime() { return CurrentTimeNs() / 1000LL; }
-
-int64_t SystemClock::CurrentTimeUs() { return CurrentTimeNs() / 1000LL; }
-
-int64_t SystemClock::CurrentTimeMs() { return CurrentTimeNs() / 1000000LL; }
-
-int64_t SystemClock::CurrentNtpTime() {
-  return ConvertToNtpTime(CurrentTimeNs());
-}
-
-int64_t SystemClock::CurrentNtpTimeMs() {
-  int64_t ntp_ts = ConvertToNtpTime(CurrentTimeNs());
-  uint32_t seconds = static_cast<uint32_t>(ntp_ts / 1000000000);
-  uint32_t fractions = static_cast<uint32_t>(ntp_ts % 1000000000);
-
-  static constexpr double kNtpFracPerMs = 4.294967296E6;  // 2^32 / 1000.
-  const double frac_ms = static_cast<double>(fractions) / kNtpFracPerMs;
-  return 1000 * static_cast<int64_t>(seconds) +
-         static_cast<int64_t>(frac_ms + 0.5);
-}
-
-int64_t SystemClock::CurrentUtcTimeNs() {
-#if defined(__POSIX__)
-  struct timeval time;
-  gettimeofday(&time, nullptr);
-  return (static_cast<int64_t>(time.tv_sec) * 1000000000 + time.tv_usec * 1000);
-#elif defined(_WIN32)
-  FILETIME file_time;
-  GetSystemTimeAsFileTime(&file_time);
-  int64_t file_time_100ns =
-      ((int64_t)file_time.dwHighDateTime << 32) | file_time.dwLowDateTime;
-  constexpr int64_t kUnixEpochFileTimeOffsetIn100ns = 116444736000000000LL;
-  return (file_time_100ns - kUnixEpochFileTimeOffsetIn100ns) * 100;
-#elif defined(__APPLE__)
-  struct timespec ts;
-  if (clock_gettime(CLOCK_REALTIME, &ts) != 0) {
-    return -1;  // Error case for macOS clock retrieval
-  }
-  return static_cast<int64_t>(ts.tv_sec) * 1000000000LL + ts.tv_nsec;
-#endif
-  return 0;
-}
-
-int64_t SystemClock::CurrentUtcTimeUs() { return CurrentUtcTimeNs() / 1000LL; }
-
-int64_t SystemClock::CurrentUtcTimeMs() {
-  return CurrentUtcTimeNs() / 1000000LL;
-}
-
-int64_t SystemClock::CurrentUtcTime() {
-  return CurrentUtcTimeNs() / 1000000000LL;
-}
-
-int64_t SystemClock::NtpToUtc(int64_t ntp_time) {
-  constexpr int64_t kNtpEpochOffset =
-      2208988800LL;  // NTP epoch starts at 1900-01-01, Unix epoch starts at
-                     // 1970-01-01
-  constexpr int64_t kMicrosecondsPerSecond = 1000000;
-  constexpr uint64_t kNtpFractionalUnit = 0x100000000;  // 2^32
-
-  uint32_t seconds = static_cast<uint32_t>(ntp_time / kNtpFractionalUnit);
-  uint32_t fractions = static_cast<uint32_t>(ntp_time % kNtpFractionalUnit);
-
-  int64_t unix_seconds = static_cast<int64_t>(seconds) - kNtpEpochOffset;
-  int64_t microseconds =
-      (static_cast<int64_t>(fractions) * kMicrosecondsPerSecond) /
-      kNtpFractionalUnit;
-
-  return unix_seconds * kMicrosecondsPerSecond + microseconds;
-}

src/common/clock/system_clock.h

@@ -1,40 +0,0 @@
-/*
- * @Author: DI JUNKUN
- * @Date: 2025-02-19
- * Copyright (c) 2025 by DI JUNKUN, All Rights Reserved.
- */
-
-#ifndef _SYSTEM_CLOCK_H_
-#define _SYSTEM_CLOCK_H_
-
-#include <cstdint>
-#include <memory>
-
-static const int64_t kNtpEpochOffset = 2208988800LL;
-
-class SystemClock {
- public:
-  SystemClock() = default;
-  ~SystemClock() = default;
-
-  int64_t CurrentTime();
-  int64_t CurrentTimeUs();
-  int64_t CurrentTimeMs();
-  int64_t CurrentTimeNs();
-
-  int64_t CurrentNtpTime();
-  int64_t CurrentNtpTimeMs();
-
-  int64_t CurrentUtcTime();
-  int64_t CurrentUtcTimeMs();
-  int64_t CurrentUtcTimeUs();
-  int64_t CurrentUtcTimeNs();
-
-  int64_t ConvertToNtpTime(int64_t time_us);
-
-  int64_t NtpToUtc(int64_t ntp_time);
-
-  int64_t CurrentNtpInMilliseconds() { return CurrentNtpTimeMs(); }
-};
-
-#endif

src/common/common.cpp

@@ -1,6 +0,0 @@
-#include "common.h"
-
-int CommonDummy()
-{
-    return 0;
-}

src/common/common.h

@@ -1,88 +0,0 @@
-#ifndef _COMMON_H_
-#define _COMMON_H_
-
-#include <iostream>
-#include <mutex>
-#include <random>
-#include <unordered_set>
-
-int CommonDummy();
-
-constexpr size_t HASH_STRING_PIECE(const char *string_piece) {
-  std::size_t result = 0;
-  while (*string_piece) {
-    result = (result * 131) + *string_piece++;
-  }
-  return result;
-}
-
-constexpr size_t operator"" _H(const char *string_piece, size_t) {
-  return HASH_STRING_PIECE(string_piece);
-}
-
-inline const std::string GetIceUsername(const std::string &sdp) {
-  std::string result = "";
-
-  std::string start = "ice-ufrag:";
-  std::string end = "\r\n";
-  size_t startPos = sdp.find(start);
-  size_t endPos = sdp.find(end);
-
-  if (startPos != std::string::npos && endPos != std::string::npos) {
-    result = sdp.substr(startPos + start.length(),
-                        endPos - startPos - start.length());
-  }
-  return result;
-}
-
-// SSRCManager is used to manage the SSRCs that have been used.
-
-class SSRCManager {
- public:
-  static SSRCManager &Instance() {
-    static SSRCManager instance;
-    return instance;
-  }
-
-  void AddSsrc(uint32_t ssrc) {
-    std::lock_guard<std::mutex> lock(mutex_);
-    ssrcs_.insert(ssrc);
-  }
-
-  void DeleteSsrc(uint32_t ssrc) {
-    std::lock_guard<std::mutex> lock(mutex_);
-    ssrcs_.erase(ssrc);
-  }
-
-  bool Contains(uint32_t ssrc) {
-    std::lock_guard<std::mutex> lock(mutex_);
-    return ssrcs_.count(ssrc) > 0;
-  }
-
- private:
-  SSRCManager() = default;
-  ~SSRCManager() = default;
-  SSRCManager(const SSRCManager &) = delete;
-  SSRCManager &operator=(const SSRCManager &) = delete;
-
-  std::unordered_set<uint32_t> ssrcs_;
-  std::mutex mutex_;
-};
-
-inline uint32_t GenerateRandomSSRC() {
-  std::random_device rd;
-  std::mt19937 gen(rd());
-  std::uniform_int_distribution<uint32_t> dis(1, 0xFFFFFFFF);
-  return dis(gen);
-}
-
-inline uint32_t GenerateUniqueSsrc() {
-  uint32_t new_ssrc;
-  do {
-    new_ssrc = GenerateRandomSSRC();
-  } while (SSRCManager::Instance().Contains(new_ssrc));
-  SSRCManager::Instance().AddSsrc(new_ssrc);
-  return new_ssrc;
-}
-
-#endif

src/common/copy_on_write_buffer.h

@@ -1,58 +0,0 @@
-/*
- * @Author: DI JUNKUN
- * @Date: 2025-01-22
- * Copyright (c) 2025 by DI JUNKUN, All Rights Reserved.
- */
-
-#ifndef _COPY_ON_WRITE_BUFFER_H_
-#define _COPY_ON_WRITE_BUFFER_H_
-
-#include <memory>
-#include <vector>
-
-class CopyOnWriteBuffer {
- public:
-  CopyOnWriteBuffer() = default;
-  CopyOnWriteBuffer(size_t size) {
-    buffer_ = std::make_shared<std::vector<uint8_t>>(size);
-  }
-  CopyOnWriteBuffer(const uint8_t* data, size_t size) {
-    buffer_ = std::make_shared<std::vector<uint8_t>>(data, data + size);
-  }
-
-  CopyOnWriteBuffer(const CopyOnWriteBuffer& other) = default;
-  CopyOnWriteBuffer(CopyOnWriteBuffer&& other) noexcept = default;
-  CopyOnWriteBuffer& operator=(const CopyOnWriteBuffer& other) = default;
-  CopyOnWriteBuffer& operator=(CopyOnWriteBuffer&& other) noexcept = default;
-
-  void SetData(const uint8_t* data, size_t size) {
-    buffer_ = std::make_shared<std::vector<uint8_t>>(data, data + size);
-  }
-
-  void InsertDataAt(size_t offset, const uint8_t* data, size_t size) {
-    EnsureUnique();
-    buffer_->insert(buffer_->begin() + offset, data, data + size);
-  }
-
-  const uint8_t* data() const { return buffer_ ? buffer_->data() : nullptr; }
-
-  size_t size() const { return buffer_ ? buffer_->size() : 0; }
-
-  uint8_t& operator[](size_t index) {
-    EnsureUnique();
-    return (*buffer_)[index];
-  }
-
-  const uint8_t& operator[](size_t index) const { return (*buffer_)[index]; }
-
- private:
-  void EnsureUnique() {
-    if (buffer_.use_count() != 1) {
-      buffer_ = std::make_shared<std::vector<uint8_t>>(*buffer_);
-    }
-  }
-
-  std::shared_ptr<std::vector<uint8_t>> buffer_;
-};
-
-#endif

src/common/display_info.h

@@ -0,0 +1,46 @@
+/*
+ * @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>
+
+namespace crossdesk {
+
+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;
+};
+}  // namespace crossdesk
+#endif

src/common/inlined_vector.h

@@ -1,65 +0,0 @@
-/*
- * @Author: DI JUNKUN
- * @Date: 2025-03-12
- * Copyright (c) 2025 by DI JUNKUN, All Rights Reserved.
- */
-
-#ifndef _INLINED_VECTOR_H_
-#define _INLINED_VECTOR_H_
-
-#include <array>
-#include <initializer_list>
-#include <iostream>
-#include <vector>
-
-template <typename T, size_t N>
-class InlinedVector {
- public:
-  InlinedVector() : size_(0), use_heap_(false) {}
-
-  void push_back(const T& value) {
-    if (!use_heap_ && size_ < N) {
-      stack_data_[size_] = value;
-    } else {
-      if (!use_heap_) {
-        heap_data_.reserve(N * 2);
-        for (size_t i = 0; i < size_; ++i) {
-          heap_data_.push_back(stack_data_[i]);
-        }
-        use_heap_ = true;
-      }
-      heap_data_.push_back(value);
-    }
-    ++size_;
-  }
-
-  void assign(size_t n, const T& value) {
-    clear();
-    for (size_t i = 0; i < n; ++i) {
-      push_back(value);
-    }
-  }
-
-  size_t size() const { return size_; }
-  T& operator[](size_t index) {
-    return use_heap_ ? heap_data_[index] : stack_data_[index];
-  }
-
-  const T& operator[](size_t index) const {
-    return use_heap_ ? heap_data_[index] : stack_data_[index];
-  }
-
- private:
-  void clear() {
-    size_ = 0;
-    use_heap_ = false;
-    heap_data_.clear();
-  }
-
-  size_t size_;
-  bool use_heap_;
-  std::array<T, N> stack_data_;
-  std::vector<T> heap_data_;
-};
-
-#endif  // _INLINED_VECTOR_H_

src/common/limits_base.h

@@ -1,36 +0,0 @@
-/*
- * @Author: DI JUNKUN
- * @Date: 2025-01-14
- * Copyright (c) 2025 by DI JUNKUN, All Rights Reserved.
- */
-
-#ifndef _LIMITS_BASE_H_
-#define _LIMITS_BASE_H_
-
-#include <limits>
-
-template <typename T>
-bool IsInfinite(const T& value) {
-  return value == std::numeric_limits<T>::min() ||
-         value == std::numeric_limits<T>::max();
-}
-
-template <typename T>
-bool IsFinite(const T& value) {
-  return !IsInfinite(value);
-}
-
-template <typename T>
-bool IsPlusFinite(const T& value) {
-  return value == std::numeric_limits<T>::max();
-}
-
-template <typename T>
-bool IsMinusFinite(const T& value) {
-  return value == std::numeric_limits<T>::min();
-}
-
-#define INT64_T_MAX std::numeric_limits<int64_t>::max()
-#define INT64_T_MIN std::numeric_limits<int64_t>::min()
-
-#endif

src/common/mod_ops.h

@@ -1,130 +0,0 @@
-/*
- * @Author: DI JUNKUN
- * @Date: 2025-01-08
- * Copyright (c) 2025 by DI JUNKUN, All Rights Reserved.
- */
-
-#ifndef _MOD_OPS_H_
-#define _MOD_OPS_H_
-
-#include <algorithm>
-#include <type_traits>
-
-template <unsigned long M>                                    // NOLINT
-inline unsigned long Add(unsigned long a, unsigned long b) {  // NOLINT
-  // RTC_DCHECK_LT(a, M);
-  unsigned long t = M - b % M;  // NOLINT
-  unsigned long res = a - t;    // NOLINT
-  if (t > a) return res + M;
-  return res;
-}
-
-template <unsigned long M>                                         // NOLINT
-inline unsigned long Subtract(unsigned long a, unsigned long b) {  // NOLINT
-  // RTC_DCHECK_LT(a, M);
-  unsigned long sub = b % M;  // NOLINT
-  if (a < sub) return M - (sub - a);
-  return a - sub;
-}
-
-// Calculates the forward difference between two wrapping numbers.
-//
-// Example:
-// uint8_t x = 253;
-// uint8_t y = 2;
-//
-// ForwardDiff(x, y) == 5
-//
-//   252   253   254   255    0     1     2     3
-// #################################################
-// |     |  x  |     |     |     |     |  y  |     |
-// #################################################
-//          |----->----->----->----->----->
-//
-// ForwardDiff(y, x) == 251
-//
-//   252   253   254   255    0     1     2     3
-// #################################################
-// |     |  x  |     |     |     |     |  y  |     |
-// #################################################
-// -->----->                              |----->---
-//
-// If M > 0 then wrapping occurs at M, if M == 0 then wrapping occurs at the
-// largest value representable by T.
-template <typename T, T M>
-inline typename std::enable_if<(M > 0), T>::type ForwardDiff(T a, T b) {
-  static_assert(std::is_unsigned<T>::value,
-                "Type must be an unsigned integer.");
-  // RTC_DCHECK_LT(a, M);
-  // RTC_DCHECK_LT(b, M);
-  return a <= b ? b - a : M - (a - b);
-}
-
-template <typename T, T M>
-inline typename std::enable_if<(M == 0), T>::type ForwardDiff(T a, T b) {
-  static_assert(std::is_unsigned<T>::value,
-                "Type must be an unsigned integer.");
-  return b - a;
-}
-
-template <typename T>
-inline T ForwardDiff(T a, T b) {
-  return ForwardDiff<T, 0>(a, b);
-}
-
-// Calculates the reverse difference between two wrapping numbers.
-//
-// Example:
-// uint8_t x = 253;
-// uint8_t y = 2;
-//
-// ReverseDiff(y, x) == 5
-//
-//   252   253   254   255    0     1     2     3
-// #################################################
-// |     |  x  |     |     |     |     |  y  |     |
-// #################################################
-//          <-----<-----<-----<-----<-----|
-//
-// ReverseDiff(x, y) == 251
-//
-//   252   253   254   255    0     1     2     3
-// #################################################
-// |     |  x  |     |     |     |     |  y  |     |
-// #################################################
-// ---<-----|                             |<-----<--
-//
-// If M > 0 then wrapping occurs at M, if M == 0 then wrapping occurs at the
-// largest value representable by T.
-template <typename T, T M>
-inline typename std::enable_if<(M > 0), T>::type ReverseDiff(T a, T b) {
-  static_assert(std::is_unsigned<T>::value,
-                "Type must be an unsigned integer.");
-  // RTC_DCHECK_LT(a, M);
-  // RTC_DCHECK_LT(b, M);
-  return b <= a ? a - b : M - (b - a);
-}
-
-template <typename T, T M>
-inline typename std::enable_if<(M == 0), T>::type ReverseDiff(T a, T b) {
-  static_assert(std::is_unsigned<T>::value,
-                "Type must be an unsigned integer.");
-  return a - b;
-}
-
-template <typename T>
-inline T ReverseDiff(T a, T b) {
-  return ReverseDiff<T, 0>(a, b);
-}
-
-// Calculates the minimum distance between to wrapping numbers.
-//
-// The minimum distance is defined as min(ForwardDiff(a, b), ReverseDiff(a, b))
-template <typename T, T M = 0>
-inline T MinDiff(T a, T b) {
-  static_assert(std::is_unsigned<T>::value,
-                "Type must be an unsigned integer.");
-  return (std::min)(ForwardDiff<T, M>(a, b), ReverseDiff<T, M>(a, b));
-}
-
-#endif

src/common/module_common_types_public.h

@@ -1,61 +0,0 @@
-/*
- *  Copyright (c) 2017 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.
- */
-
-#ifndef MODULES_INCLUDE_MODULE_COMMON_TYPES_PUBLIC_H_
-#define MODULES_INCLUDE_MODULE_COMMON_TYPES_PUBLIC_H_
-
-#include <limits>
-#include <optional>
-
-namespace webrtc {
-
-template <typename U>
-inline bool IsNewer(U value, U prev_value) {
-  static_assert(!std::numeric_limits<U>::is_signed, "U must be unsigned");
-  // kBreakpoint is the half-way mark for the type U. For instance, for a
-  // uint16_t it will be 0x8000, and for a uint32_t, it will be 0x8000000.
-  constexpr U kBreakpoint = (std::numeric_limits<U>::max() >> 1) + 1;
-  // Distinguish between elements that are exactly kBreakpoint apart.
-  // If t1>t2 and |t1-t2| = kBreakpoint: IsNewer(t1,t2)=true,
-  // IsNewer(t2,t1)=false
-  // rather than having IsNewer(t1,t2) = IsNewer(t2,t1) = false.
-  if (value - prev_value == kBreakpoint) {
-    return value > prev_value;
-  }
-  return value != prev_value &&
-         static_cast<U>(value - prev_value) < kBreakpoint;
-}
-
-// NB: Doesn't fulfill strict weak ordering requirements.
-//     Mustn't be used as std::map Compare function.
-inline bool IsNewerSequenceNumber(uint16_t sequence_number,
-                                  uint16_t prev_sequence_number) {
-  return IsNewer(sequence_number, prev_sequence_number);
-}
-
-// NB: Doesn't fulfill strict weak ordering requirements.
-//     Mustn't be used as std::map Compare function.
-inline bool IsNewerTimestamp(uint32_t timestamp, uint32_t prev_timestamp) {
-  return IsNewer(timestamp, prev_timestamp);
-}
-
-inline uint16_t LatestSequenceNumber(uint16_t sequence_number1,
-                                     uint16_t sequence_number2) {
-  return IsNewerSequenceNumber(sequence_number1, sequence_number2)
-             ? sequence_number1
-             : sequence_number2;
-}
-
-inline uint32_t LatestTimestamp(uint32_t timestamp1, uint32_t timestamp2) {
-  return IsNewerTimestamp(timestamp1, timestamp2) ? timestamp1 : timestamp2;
-}
-
-}  // namespace webrtc
-#endif  // MODULES_INCLUDE_MODULE_COMMON_TYPES_PUBLIC_H_

src/common/platform.cpp

@@ -0,0 +1,152 @@
+#include "platform.h"
+
+#include <cstdlib>
+#include <cstring>
+
+#include "rd_log.h"
+
+#ifdef _WIN32
+#include <Winsock2.h>
+#include <iphlpapi.h>
+#elif __APPLE__
+#include <ifaddrs.h>
+#include <net/if_dl.h>
+#include <net/if_types.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#elif __linux__
+#include <fcntl.h>
+#include <net/if.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#endif
+
+namespace crossdesk {
+
+std::string GetMac() {
+  char mac_addr[16];
+  int len = 0;
+#ifdef _WIN32
+  IP_ADAPTER_INFO adapterInfo[16];
+  DWORD bufferSize = sizeof(adapterInfo);
+  DWORD result = GetAdaptersInfo(adapterInfo, &bufferSize);
+  if (result == ERROR_SUCCESS) {
+    PIP_ADAPTER_INFO adapter = adapterInfo;
+    while (adapter) {
+      for (UINT i = 0; i < adapter->AddressLength; i++) {
+        len += sprintf_s(mac_addr + len, sizeof(mac_addr) - len, "%.2X",
+                         adapter->Address[i]);
+      }
+      break;
+    }
+  }
+#elif __APPLE__
+  std::string if_name = "en0";
+
+  struct ifaddrs* addrs;
+  struct ifaddrs* cursor;
+  const struct sockaddr_dl* dlAddr;
+
+  if (!getifaddrs(&addrs)) {
+    cursor = addrs;
+    while (cursor != 0) {
+      const struct sockaddr_dl* socAddr =
+          (const struct sockaddr_dl*)cursor->ifa_addr;
+      if ((cursor->ifa_addr->sa_family == AF_LINK) &&
+          (socAddr->sdl_type == IFT_ETHER) &&
+          strcmp(if_name.c_str(), cursor->ifa_name) == 0) {
+        dlAddr = (const struct sockaddr_dl*)cursor->ifa_addr;
+        const unsigned char* base =
+            (const unsigned char*)&dlAddr->sdl_data[dlAddr->sdl_nlen];
+        for (int i = 0; i < dlAddr->sdl_alen; i++) {
+          len +=
+              snprintf(mac_addr + len, sizeof(mac_addr) - len, "%.2X", base[i]);
+        }
+      }
+      cursor = cursor->ifa_next;
+    }
+    freeifaddrs(addrs);
+  }
+#elif __linux__
+  int sock = socket(AF_INET, SOCK_DGRAM, 0);
+  if (sock < 0) {
+    return "";
+  }
+  struct ifreq ifr;
+  struct ifconf ifc;
+  char buf[1024];
+  ifc.ifc_len = sizeof(buf);
+  ifc.ifc_buf = buf;
+  if (ioctl(sock, SIOCGIFCONF, &ifc) < 0) {
+    close(sock);
+    return "";
+  }
+  struct ifreq* it = ifc.ifc_req;
+  const struct ifreq* const end = it + (ifc.ifc_len / sizeof(struct ifreq));
+  for (; it != end; ++it) {
+    std::strcpy(ifr.ifr_name, it->ifr_name);
+    if (ioctl(sock, SIOCGIFFLAGS, &ifr) < 0) {
+      continue;
+    }
+    if (ifr.ifr_flags & IFF_LOOPBACK) {
+      continue;
+    }
+    if (ioctl(sock, SIOCGIFHWADDR, &ifr) < 0) {
+      continue;
+    }
+    std::string mac_address;
+    for (int i = 0; i < 6; ++i) {
+      len += sprintf(mac_addr + len, "%.2X", ifr.ifr_hwaddr.sa_data[i] & 0xff);
+    }
+    break;
+  }
+  close(sock);
+#endif
+  return mac_addr;
+}
+
+std::string GetHostName() {
+  char hostname[256];
+#ifdef _WIN32
+  WSADATA wsaData;
+  if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
+    LOG_ERROR("WSAStartup failed");
+    return "";
+  }
+  if (gethostname(hostname, sizeof(hostname)) == SOCKET_ERROR) {
+    LOG_ERROR("gethostname failed: {}", WSAGetLastError());
+    WSACleanup();
+    return "";
+  }
+  WSACleanup();
+#else
+  if (gethostname(hostname, sizeof(hostname)) == -1) {
+    LOG_ERROR("gethostname failed");
+    return "";
+  }
+#endif
+  return hostname;
+}
+
+bool IsWaylandSession() {
+#if defined(__linux__) && !defined(__APPLE__)
+  const char* session_type = std::getenv("XDG_SESSION_TYPE");
+  if (session_type) {
+    if (std::strcmp(session_type, "wayland") == 0 ||
+        std::strcmp(session_type, "Wayland") == 0) {
+      return true;
+    }
+    if (std::strcmp(session_type, "x11") == 0 ||
+        std::strcmp(session_type, "X11") == 0) {
+      return false;
+    }
+  }
+
+  const char* wayland_display = std::getenv("WAYLAND_DISPLAY");
+  return wayland_display && wayland_display[0] != '\0';
+#else
+  return false;
+#endif
+}
+}  // namespace crossdesk

src/common/platform.h

@@ -0,0 +1,19 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2023-12-18
+ * Copyright (c) 2023 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _PLATFORM_H_
+#define _PLATFORM_H_
+
+#include <iostream>
+
+namespace crossdesk {
+
+std::string GetMac();
+std::string GetHostName();
+bool IsWaylandSession();
+
+}  // namespace crossdesk
+#endif

src/common/rounded_corner_button.cpp

@@ -0,0 +1,63 @@
+#include "rounded_corner_button.h"
+
+namespace crossdesk {
+bool RoundedCornerButton(const char* label, const ImVec2& size, float rounding,
+                         ImDrawFlags round_flags, bool enabled,
+                         ImU32 normal_col, ImU32 hover_col, ImU32 active_col,
+                         ImU32 border_col) {
+  ImGuiWindow* current_window = ImGui::GetCurrentWindow();
+  if (current_window->SkipItems) return false;
+
+  const ImGuiStyle& style = ImGui::GetStyle();
+
+  ImGuiID button_id = current_window->GetID(label);
+  ImVec2 cursor_pos = current_window->DC.CursorPos;
+  ImVec2 button_size = ImGui::CalcItemSize(size, 0.0f, 0.0f);
+  ImRect button_rect(cursor_pos, ImVec2(cursor_pos.x + button_size.x,
+                                        cursor_pos.y + button_size.y));
+  ImGui::ItemSize(button_rect);
+  if (!ImGui::ItemAdd(button_rect, button_id)) return false;
+
+  bool is_hovered = false, is_held = false;
+  bool is_pressed = false;
+  if (enabled) {
+    is_pressed =
+        ImGui::ButtonBehavior(button_rect, button_id, &is_hovered, &is_held);
+  }
+
+  if (normal_col == 0) normal_col = ImGui::GetColorU32(ImGuiCol_Button);
+  if (hover_col == 0) hover_col = ImGui::GetColorU32(ImGuiCol_ButtonHovered);
+  if (active_col == 0) active_col = ImGui::GetColorU32(ImGuiCol_ButtonActive);
+  if (border_col == 0) border_col = ImGui::GetColorU32(ImGuiCol_Border);
+
+  ImU32 fill_color = normal_col;
+  if (is_held && is_hovered)
+    fill_color = active_col;
+  else if (is_hovered)
+    fill_color = hover_col;
+
+  if (!enabled) fill_color = IM_COL32(120, 120, 120, 180);
+
+  ImDrawList* window_draw_list = ImGui::GetWindowDrawList();
+
+  window_draw_list->AddRectFilled(button_rect.Min, button_rect.Max, fill_color,
+                                  rounding, round_flags);
+
+  if (style.FrameBorderSize > 0.0f) {
+    window_draw_list->AddRect(button_rect.Min, button_rect.Max, border_col,
+                              rounding, round_flags, style.FrameBorderSize);
+  }
+
+  ImU32 text_color =
+      ImGui::GetColorU32(enabled ? ImGuiCol_Text : ImGuiCol_TextDisabled);
+
+  const char* label_end = ImGui::FindRenderedTextEnd(label);
+  ImGui::PushStyleColor(ImGuiCol_Text,
+                        ImGui::ColorConvertU32ToFloat4(text_color));
+  ImGui::RenderTextClipped(button_rect.Min, button_rect.Max, label, label_end,
+                           nullptr, ImVec2(0.5f, 0.5f), &button_rect);
+  ImGui::PopStyleColor();
+
+  return is_pressed;
+}
+}  // namespace crossdesk

src/common/rounded_corner_button.h

@@ -0,0 +1,20 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-02-26
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _ROUNDED_CORNER_BUTTON_H_
+#define _ROUNDED_CORNER_BUTTON_H_
+
+#include "imgui.h"
+#include "imgui_internal.h"
+
+namespace crossdesk {
+bool RoundedCornerButton(const char* label, const ImVec2& size, float rounding,
+                         ImDrawFlags round_flags, bool enabled = true,
+                         ImU32 normal_col = 0, ImU32 hover_col = 0,
+                         ImU32 active_col = 0, ImU32 border_col = 0);
+}  // namespace crossdesk
+
+#endif

src/common/rtc_base/arraysize.h

@@ -1,32 +0,0 @@
-/*
- *  Copyright (c) 2015 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.
- */
-
-#ifndef RTC_BASE_ARRAYSIZE_H_
-#define RTC_BASE_ARRAYSIZE_H_
-
-#include <stddef.h>
-
-// This file defines the arraysize() macro and is derived from Chromium's
-// base/macros.h.
-
-// The arraysize(arr) macro returns the # of elements in an array arr.
-// The expression is a compile-time constant, and therefore can be
-// used in defining new arrays, for example.  If you use arraysize on
-// a pointer by mistake, you will get a compile-time error.
-
-// This template function declaration is used in defining arraysize.
-// Note that the function doesn't need an implementation, as we only
-// use its type.
-template <typename T, size_t N>
-char (&ArraySizeHelper(T (&array)[N]))[N];
-
-#define arraysize(array) (sizeof(ArraySizeHelper(array)))
-
-#endif  // RTC_BASE_ARRAYSIZE_H_

src/common/rtc_base/bitrate_tracker.cc

@@ -1,39 +0,0 @@
-/*
- *  Copyright (c) 2023 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 "rtc_base/bitrate_tracker.h"
-
-#include <optional>
-
-#include "api/units/data_rate.h"
-#include "api/units/timestamp.h"
-#include "rtc_base/rate_statistics.h"
-
-namespace webrtc {
-
-BitrateTracker::BitrateTracker(TimeDelta max_window_size)
-    : impl_(max_window_size.ms(), RateStatistics::kBpsScale) {}
-
-std::optional<DataRate> BitrateTracker::Rate(Timestamp now) const {
-  if (std::optional<int64_t> rate = impl_.Rate(now.ms())) {
-    return DataRate::BitsPerSec(*rate);
-  }
-  return std::nullopt;
-}
-
-bool BitrateTracker::SetWindowSize(TimeDelta window_size, Timestamp now) {
-  return impl_.SetWindowSize(window_size.ms(), now.ms());
-}
-
-void BitrateTracker::Update(int64_t bytes, Timestamp now) {
-  impl_.Update(bytes, now.ms());
-}
-
-}  // namespace webrtc

src/common/rtc_base/bitrate_tracker.h

@@ -1,64 +0,0 @@
-/*
- *  Copyright (c) 2023 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.
- */
-
-#ifndef RTC_BASE_BITRATE_TRACKER_H_
-#define RTC_BASE_BITRATE_TRACKER_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <optional>
-
-#include "api/units/data_rate.h"
-#include "api/units/data_size.h"
-#include "api/units/time_delta.h"
-#include "api/units/timestamp.h"
-#include "rtc_base/rate_statistics.h"
-
-namespace webrtc {
-// Class to estimate bitrates over running window.
-// Timestamps used in Update(), Rate() and SetWindowSize() must never
-// decrease for two consecutive calls.
-// This class is thread unsafe.
-class BitrateTracker {
- public:
-  // max_window_sizes = Maximum window size for the rate estimation.
-  //                    Initial window size is set to this, but may be changed
-  //                    to something lower by calling SetWindowSize().
-  explicit BitrateTracker(TimeDelta max_window_size);
-
-  BitrateTracker(const BitrateTracker&) = default;
-  BitrateTracker(BitrateTracker&&) = default;
-  BitrateTracker& operator=(const BitrateTracker&) = delete;
-  BitrateTracker& operator=(BitrateTracker&&) = delete;
-
-  ~BitrateTracker() = default;
-
-  // Resets instance to original state.
-  void Reset() { impl_.Reset(); }
-
-  // Updates bitrate with a new data point, moving averaging window as needed.
-  void Update(int64_t bytes, Timestamp now);
-  void Update(DataSize size, Timestamp now) { Update(size.bytes(), now); }
-
-  // Returns bitrate, moving averaging window as needed.
-  // Returns nullopt when bitrate can't be measured.
-  std::optional<DataRate> Rate(Timestamp now) const;
-
-  // Update the size of the averaging window. The maximum allowed value for
-  // `window_size` is `max_window_size` as supplied in the constructor.
-  bool SetWindowSize(TimeDelta window_size, Timestamp now);
-
- private:
-  RateStatistics impl_;
-};
-}  // namespace webrtc
-
-#endif  // RTC_BASE_BITRATE_TRACKER_H_

src/common/rtc_base/byte_order.h

@@ -1,199 +0,0 @@
-/*
- *  Copyright 2004 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.
- */
-
-#ifndef RTC_BASE_BYTE_ORDER_H_
-#define RTC_BASE_BYTE_ORDER_H_
-
-#include <stdint.h>
-
-#include <cstring>
-
-#if defined(__POSIX__) && !defined(__native_client__)
-#include <arpa/inet.h>
-#endif
-
-#include "rtc_base/system/arch.h"
-
-#if defined(__APPLE__)
-#include <libkern/OSByteOrder.h>
-
-#define htobe16(v) OSSwapHostToBigInt16(v)
-#define htobe32(v) OSSwapHostToBigInt32(v)
-#define htobe64(v) OSSwapHostToBigInt64(v)
-#define be16toh(v) OSSwapBigToHostInt16(v)
-#define be32toh(v) OSSwapBigToHostInt32(v)
-#define be64toh(v) OSSwapBigToHostInt64(v)
-
-#define htole16(v) OSSwapHostToLittleInt16(v)
-#define htole32(v) OSSwapHostToLittleInt32(v)
-#define htole64(v) OSSwapHostToLittleInt64(v)
-#define le16toh(v) OSSwapLittleToHostInt16(v)
-#define le32toh(v) OSSwapLittleToHostInt32(v)
-#define le64toh(v) OSSwapLittleToHostInt64(v)
-
-#elif defined(_WIN32) || defined(__native_client__)
-#if defined(_WIN32)
-#include <stdlib.h>
-#include <winsock2.h>
-#else
-#include <netinet/in.h>  // no-presubmit-check
-#endif                   // defined(_WIN32)
-
-#if defined(WEBRTC_ARCH_LITTLE_ENDIAN)
-#define htobe16(v) htons(v)
-#define htobe32(v) htonl(v)
-#define be16toh(v) ntohs(v)
-#define be32toh(v) ntohl(v)
-#define htole16(v) (v)
-#define htole32(v) (v)
-#define htole64(v) (v)
-#define le16toh(v) (v)
-#define le32toh(v) (v)
-#define le64toh(v) (v)
-#if defined(_WIN32)
-#define htobe64(v) _byteswap_uint64(v)
-#define be64toh(v) _byteswap_uint64(v)
-#endif  // defined(_WIN32)
-#if defined(__native_client__)
-#define htobe64(v) __builtin_bswap64(v)
-#define be64toh(v) __builtin_bswap64(v)
-#endif  // defined(__native_client__)
-
-#elif defined(WEBRTC_ARCH_BIG_ENDIAN)
-#define htobe16(v) (v)
-#define htobe32(v) (v)
-#define be16toh(v) (v)
-#define be32toh(v) (v)
-#define htole16(v) __builtin_bswap16(v)
-#define htole32(v) __builtin_bswap32(v)
-#define htole64(v) __builtin_bswap64(v)
-#define le16toh(v) __builtin_bswap16(v)
-#define le32toh(v) __builtin_bswap32(v)
-#define le64toh(v) __builtin_bswap64(v)
-#if defined(_WIN32)
-#define htobe64(v) (v)
-#define be64toh(v) (v)
-#endif  // defined(_WIN32)
-#if defined(__native_client__)
-#define htobe64(v) (v)
-#define be64toh(v) (v)
-#endif  // defined(__native_client__)
-#else
-#error WEBRTC_ARCH_BIG_ENDIAN or WEBRTC_ARCH_LITTLE_ENDIAN must be defined.
-#endif  // defined(WEBRTC_ARCH_LITTLE_ENDIAN)
-
-#elif defined(__POSIX__)
-#include <endian.h>
-#else
-#error "Missing byte order functions for this arch."
-#endif  // defined(__APPLE__)
-
-namespace rtc {
-
-// Reading and writing of little and big-endian numbers from memory
-
-inline void Set8(void* memory, size_t offset, uint8_t v) {
-  static_cast<uint8_t*>(memory)[offset] = v;
-}
-
-inline uint8_t Get8(const void* memory, size_t offset) {
-  return static_cast<const uint8_t*>(memory)[offset];
-}
-
-inline void SetBE16(void* memory, uint16_t v) {
-  uint16_t val = htobe16(v);
-  memcpy(memory, &val, sizeof(val));
-}
-
-inline void SetBE32(void* memory, uint32_t v) {
-  uint32_t val = htobe32(v);
-  memcpy(memory, &val, sizeof(val));
-}
-
-inline void SetBE64(void* memory, uint64_t v) {
-  uint64_t val = htobe64(v);
-  memcpy(memory, &val, sizeof(val));
-}
-
-inline uint16_t GetBE16(const void* memory) {
-  uint16_t val;
-  memcpy(&val, memory, sizeof(val));
-  return be16toh(val);
-}
-
-inline uint32_t GetBE32(const void* memory) {
-  uint32_t val;
-  memcpy(&val, memory, sizeof(val));
-  return be32toh(val);
-}
-
-inline uint64_t GetBE64(const void* memory) {
-  uint64_t val;
-  memcpy(&val, memory, sizeof(val));
-  return be64toh(val);
-}
-
-inline void SetLE16(void* memory, uint16_t v) {
-  uint16_t val = htole16(v);
-  memcpy(memory, &val, sizeof(val));
-}
-
-inline void SetLE32(void* memory, uint32_t v) {
-  uint32_t val = htole32(v);
-  memcpy(memory, &val, sizeof(val));
-}
-
-inline void SetLE64(void* memory, uint64_t v) {
-  uint64_t val = htole64(v);
-  memcpy(memory, &val, sizeof(val));
-}
-
-inline uint16_t GetLE16(const void* memory) {
-  uint16_t val;
-  memcpy(&val, memory, sizeof(val));
-  return le16toh(val);
-}
-
-inline uint32_t GetLE32(const void* memory) {
-  uint32_t val;
-  memcpy(&val, memory, sizeof(val));
-  return le32toh(val);
-}
-
-inline uint64_t GetLE64(const void* memory) {
-  uint64_t val;
-  memcpy(&val, memory, sizeof(val));
-  return le64toh(val);
-}
-
-// Check if the current host is big endian.
-inline bool IsHostBigEndian() {
-#if defined(WEBRTC_ARCH_BIG_ENDIAN)
-  return true;
-#else
-  return false;
-#endif
-}
-
-inline uint16_t HostToNetwork16(uint16_t n) { return htobe16(n); }
-
-inline uint32_t HostToNetwork32(uint32_t n) { return htobe32(n); }
-
-inline uint64_t HostToNetwork64(uint64_t n) { return htobe64(n); }
-
-inline uint16_t NetworkToHost16(uint16_t n) { return be16toh(n); }
-
-inline uint32_t NetworkToHost32(uint32_t n) { return be32toh(n); }
-
-inline uint64_t NetworkToHost64(uint64_t n) { return be64toh(n); }
-
-}  // namespace rtc
-
-#endif  // RTC_BASE_BYTE_ORDER_H_

src/common/rtc_base/module_common_types_public.h

@@ -1,61 +0,0 @@
-/*
- *  Copyright (c) 2017 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.
- */
-
-#ifndef MODULES_INCLUDE_MODULE_COMMON_TYPES_PUBLIC_H_
-#define MODULES_INCLUDE_MODULE_COMMON_TYPES_PUBLIC_H_
-
-#include <limits>
-#include <optional>
-
-namespace webrtc {
-
-template <typename U>
-inline bool IsNewer(U value, U prev_value) {
-  static_assert(!std::numeric_limits<U>::is_signed, "U must be unsigned");
-  // kBreakpoint is the half-way mark for the type U. For instance, for a
-  // uint16_t it will be 0x8000, and for a uint32_t, it will be 0x8000000.
-  constexpr U kBreakpoint = (std::numeric_limits<U>::max() >> 1) + 1;
-  // Distinguish between elements that are exactly kBreakpoint apart.
-  // If t1>t2 and |t1-t2| = kBreakpoint: IsNewer(t1,t2)=true,
-  // IsNewer(t2,t1)=false
-  // rather than having IsNewer(t1,t2) = IsNewer(t2,t1) = false.
-  if (value - prev_value == kBreakpoint) {
-    return value > prev_value;
-  }
-  return value != prev_value &&
-         static_cast<U>(value - prev_value) < kBreakpoint;
-}
-
-// NB: Doesn't fulfill strict weak ordering requirements.
-//     Mustn't be used as std::map Compare function.
-inline bool IsNewerSequenceNumber(uint16_t sequence_number,
-                                  uint16_t prev_sequence_number) {
-  return IsNewer(sequence_number, prev_sequence_number);
-}
-
-// NB: Doesn't fulfill strict weak ordering requirements.
-//     Mustn't be used as std::map Compare function.
-inline bool IsNewerTimestamp(uint32_t timestamp, uint32_t prev_timestamp) {
-  return IsNewer(timestamp, prev_timestamp);
-}
-
-inline uint16_t LatestSequenceNumber(uint16_t sequence_number1,
-                                     uint16_t sequence_number2) {
-  return IsNewerSequenceNumber(sequence_number1, sequence_number2)
-             ? sequence_number1
-             : sequence_number2;
-}
-
-inline uint32_t LatestTimestamp(uint32_t timestamp1, uint32_t timestamp2) {
-  return IsNewerTimestamp(timestamp1, timestamp2) ? timestamp1 : timestamp2;
-}
-
-}  // namespace webrtc
-#endif  // MODULES_INCLUDE_MODULE_COMMON_TYPES_PUBLIC_H_

src/common/rtc_base/network/sent_packet.cc

@@ -1,27 +0,0 @@
-/*
- *  Copyright 2018 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 "rtc_base/network/sent_packet.h"
-
-namespace rtc {
-
-PacketInfo::PacketInfo() = default;
-PacketInfo::PacketInfo(const PacketInfo& info) = default;
-PacketInfo::~PacketInfo() = default;
-
-SentPacket::SentPacket() = default;
-SentPacket::SentPacket(int64_t packet_id, int64_t send_time_ms)
-    : packet_id(packet_id), send_time_ms(send_time_ms) {}
-SentPacket::SentPacket(int64_t packet_id,
-                       int64_t send_time_ms,
-                       const rtc::PacketInfo& info)
-    : packet_id(packet_id), send_time_ms(send_time_ms), info(info) {}
-
-}  // namespace rtc

src/common/rtc_base/network/sent_packet.h

@@ -1,70 +0,0 @@
-/*
- *  Copyright 2018 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.
- */
-
-#ifndef RTC_BASE_NETWORK_SENT_PACKET_H_
-#define RTC_BASE_NETWORK_SENT_PACKET_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <optional>
-
-namespace rtc {
-
-enum class PacketType {
-  kUnknown,
-  kData,
-  kIceConnectivityCheck,
-  kIceConnectivityCheckResponse,
-  kStunMessage,
-  kTurnMessage,
-};
-
-enum class PacketInfoProtocolType {
-  kUnknown,
-  kUdp,
-  kTcp,
-  kSsltcp,
-  kTls,
-};
-
-struct PacketInfo {
-  PacketInfo();
-  PacketInfo(const PacketInfo& info);
-  ~PacketInfo();
-
-  bool included_in_feedback = false;
-  bool included_in_allocation = false;
-  // `is_media` is true if this is an audio or video packet, excluding
-  // retransmissions.
-  bool is_media = false;
-  PacketType packet_type = PacketType::kUnknown;
-  PacketInfoProtocolType protocol = PacketInfoProtocolType::kUnknown;
-  // A unique id assigned by the network manager, and std::nullopt if not set.
-  std::optional<uint16_t> network_id;
-  size_t packet_size_bytes = 0;
-  size_t turn_overhead_bytes = 0;
-  size_t ip_overhead_bytes = 0;
-};
-
-struct SentPacket {
-  SentPacket();
-  SentPacket(int64_t packet_id, int64_t send_time_ms);
-  SentPacket(int64_t packet_id, int64_t send_time_ms,
-             const rtc::PacketInfo& info);
-
-  int64_t packet_id = -1;
-  int64_t send_time_ms = -1;
-  rtc::PacketInfo info;
-};
-
-}  // namespace rtc
-
-#endif  // RTC_BASE_NETWORK_SENT_PACKET_H_

src/common/rtc_base/network_constants.cc

@@ -1,44 +0,0 @@
-/*
- *  Copyright 2020 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 "rtc_base/network_constants.h"
-
-namespace rtc {
-
-std::string AdapterTypeToString(AdapterType type) {
-  switch (type) {
-    case ADAPTER_TYPE_ANY:
-      return "Wildcard";
-    case ADAPTER_TYPE_UNKNOWN:
-      return "Unknown";
-    case ADAPTER_TYPE_ETHERNET:
-      return "Ethernet";
-    case ADAPTER_TYPE_WIFI:
-      return "Wifi";
-    case ADAPTER_TYPE_CELLULAR:
-      return "Cellular";
-    case ADAPTER_TYPE_CELLULAR_2G:
-      return "Cellular2G";
-    case ADAPTER_TYPE_CELLULAR_3G:
-      return "Cellular3G";
-    case ADAPTER_TYPE_CELLULAR_4G:
-      return "Cellular4G";
-    case ADAPTER_TYPE_CELLULAR_5G:
-      return "Cellular5G";
-    case ADAPTER_TYPE_VPN:
-      return "VPN";
-    case ADAPTER_TYPE_LOOPBACK:
-      return "Loopback";
-    default:
-      return std::string();
-  }
-}
-
-}  // namespace rtc

src/common/rtc_base/network_constants.h

@@ -1,72 +0,0 @@
-/*
- *  Copyright 2004 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.
- */
-
-#ifndef RTC_BASE_NETWORK_CONSTANTS_H_
-#define RTC_BASE_NETWORK_CONSTANTS_H_
-
-#include <stdint.h>
-
-#include <string>
-
-namespace rtc {
-
-constexpr uint16_t kNetworkCostMax = 999;
-constexpr uint16_t kNetworkCostCellular2G = 980;
-constexpr uint16_t kNetworkCostCellular3G = 910;
-constexpr uint16_t kNetworkCostCellular = 900;
-constexpr uint16_t kNetworkCostCellular4G = 500;
-constexpr uint16_t kNetworkCostCellular5G = 250;
-constexpr uint16_t kNetworkCostUnknown = 50;
-constexpr uint16_t kNetworkCostLow = 10;
-constexpr uint16_t kNetworkCostMin = 0;
-
-// Add 1 to network cost of underlying network type
-// so that e.g a "plain" WIFI is prefered over a VPN over WIFI
-// everything else being equal.
-constexpr uint16_t kNetworkCostVpn = 1;
-
-// alias
-constexpr uint16_t kNetworkCostHigh = kNetworkCostCellular;
-
-enum AdapterType {
-  // This enum resembles the one in Chromium net::ConnectionType.
-  ADAPTER_TYPE_UNKNOWN = 0,
-  ADAPTER_TYPE_ETHERNET = 1 << 0,
-  ADAPTER_TYPE_WIFI = 1 << 1,
-  ADAPTER_TYPE_CELLULAR = 1 << 2,  // This is CELLULAR of unknown type.
-  ADAPTER_TYPE_VPN = 1 << 3,
-  ADAPTER_TYPE_LOOPBACK = 1 << 4,
-  // ADAPTER_TYPE_ANY is used for a network, which only contains a single "any
-  // address" IP address (INADDR_ANY for IPv4 or in6addr_any for IPv6), and can
-  // use any/all network interfaces. Whereas ADAPTER_TYPE_UNKNOWN is used
-  // when the network uses a specific interface/IP, but its interface type can
-  // not be determined or not fit in this enum.
-  ADAPTER_TYPE_ANY = 1 << 5,
-  ADAPTER_TYPE_CELLULAR_2G = 1 << 6,
-  ADAPTER_TYPE_CELLULAR_3G = 1 << 7,
-  ADAPTER_TYPE_CELLULAR_4G = 1 << 8,
-  ADAPTER_TYPE_CELLULAR_5G = 1 << 9
-};
-
-std::string AdapterTypeToString(AdapterType type);
-
-// Useful for testing!
-constexpr AdapterType kAllAdapterTypes[] = {
-    ADAPTER_TYPE_UNKNOWN,     ADAPTER_TYPE_ETHERNET,
-    ADAPTER_TYPE_WIFI,        ADAPTER_TYPE_CELLULAR,
-    ADAPTER_TYPE_VPN,         ADAPTER_TYPE_LOOPBACK,
-    ADAPTER_TYPE_ANY,         ADAPTER_TYPE_CELLULAR_2G,
-    ADAPTER_TYPE_CELLULAR_3G, ADAPTER_TYPE_CELLULAR_4G,
-    ADAPTER_TYPE_CELLULAR_5G,
-};
-
-}  // namespace rtc
-
-#endif  // RTC_BASE_NETWORK_CONSTANTS_H_

src/common/rtc_base/network_route.cc

@@ -1,27 +0,0 @@
-/*
- *  Copyright 2020 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 "rtc_base/network_route.h"
-
-namespace rtc {
-
-bool RouteEndpoint::operator==(const RouteEndpoint& other) const {
-  return adapter_type_ == other.adapter_type_ &&
-         adapter_id_ == other.adapter_id_ && network_id_ == other.network_id_ &&
-         uses_turn_ == other.uses_turn_;
-}
-
-bool NetworkRoute::operator==(const NetworkRoute& other) const {
-  return connected == other.connected && local == other.local &&
-         remote == other.remote && packet_overhead == other.packet_overhead &&
-         last_sent_packet_id == other.last_sent_packet_id;
-}
-
-}  // namespace rtc

src/common/rtc_base/network_route.h

@@ -1,93 +0,0 @@
-/*
- *  Copyright 2016 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.
- */
-
-#ifndef RTC_BASE_NETWORK_ROUTE_H_
-#define RTC_BASE_NETWORK_ROUTE_H_
-
-#include <stdint.h>
-
-#include <sstream>
-#include <string>
-
-#include "rtc_base/network_constants.h"
-
-// TODO(honghaiz): Make a directory that describes the interfaces and structs
-// the media code can rely on and the network code can implement, and both can
-// depend on that, but not depend on each other. Then, move this file to that
-// directory.
-namespace rtc {
-
-class RouteEndpoint {
- public:
-  RouteEndpoint() {}  // Used by tests.
-  RouteEndpoint(AdapterType adapter_type, uint16_t adapter_id,
-                uint16_t network_id, bool uses_turn)
-      : adapter_type_(adapter_type),
-        adapter_id_(adapter_id),
-        network_id_(network_id),
-        uses_turn_(uses_turn) {}
-
-  RouteEndpoint(const RouteEndpoint&) = default;
-  RouteEndpoint& operator=(const RouteEndpoint&) = default;
-
-  // Used by tests.
-  static RouteEndpoint CreateWithNetworkId(uint16_t network_id) {
-    return RouteEndpoint(ADAPTER_TYPE_UNKNOWN,
-                         /* adapter_id = */ 0, network_id,
-                         /* uses_turn = */ false);
-  }
-  RouteEndpoint CreateWithTurn(bool uses_turn) const {
-    return RouteEndpoint(adapter_type_, adapter_id_, network_id_, uses_turn);
-  }
-
-  AdapterType adapter_type() const { return adapter_type_; }
-  uint16_t adapter_id() const { return adapter_id_; }
-  uint16_t network_id() const { return network_id_; }
-  bool uses_turn() const { return uses_turn_; }
-
-  bool operator==(const RouteEndpoint& other) const;
-
- private:
-  AdapterType adapter_type_ = ADAPTER_TYPE_UNKNOWN;
-  uint16_t adapter_id_ = 0;
-  uint16_t network_id_ = 0;
-  bool uses_turn_ = false;
-};
-
-struct NetworkRoute {
-  bool connected = false;
-  RouteEndpoint local;
-  RouteEndpoint remote;
-  // Last packet id sent on the PREVIOUS route.
-  int last_sent_packet_id = -1;
-  // The overhead in bytes from IP layer and above.
-  // This is the maximum of any part of the route.
-  int packet_overhead = 0;
-
-  std::string DebugString() const {
-    std::ostringstream oss;
-    oss << "[ connected: " << connected << " local: [ " << local.adapter_id()
-        << "/" << local.network_id() << " "
-        << AdapterTypeToString(local.adapter_type())
-        << " turn: " << local.uses_turn() << " ] remote: [ "
-        << remote.adapter_id() << "/" << remote.network_id() << " "
-        << AdapterTypeToString(remote.adapter_type())
-        << " turn: " << remote.uses_turn()
-        << " ] packet_overhead_bytes: " << packet_overhead << " ]";
-    return oss.str();
-  }
-
-  bool operator==(const NetworkRoute& other) const;
-  bool operator!=(const NetworkRoute& other) { return !operator==(other); }
-};
-
-}  // namespace rtc
-
-#endif  // RTC_BASE_NETWORK_ROUTE_H_

src/common/rtc_base/numerics/divide_round.h

@@ -1,56 +0,0 @@
-/*
- *  Copyright 2019 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.
- */
-
-#ifndef RTC_BASE_NUMERICS_DIVIDE_ROUND_H_
-#define RTC_BASE_NUMERICS_DIVIDE_ROUND_H_
-
-#include <type_traits>
-
-#include "safe_compare.h"
-
-namespace webrtc {
-
-template <typename Dividend, typename Divisor>
-inline auto constexpr DivideRoundUp(Dividend dividend, Divisor divisor) {
-  static_assert(std::is_integral<Dividend>(), "");
-  static_assert(std::is_integral<Divisor>(), "");
-
-  auto quotient = dividend / divisor;
-  auto remainder = dividend % divisor;
-  return quotient + (remainder > 0 ? 1 : 0);
-}
-
-template <typename Dividend, typename Divisor>
-inline auto constexpr DivideRoundToNearest(Dividend dividend, Divisor divisor) {
-  static_assert(std::is_integral<Dividend>(), "");
-  static_assert(std::is_integral<Divisor>(), "");
-
-  if (dividend < Dividend{0}) {
-    auto half_of_divisor = divisor / 2;
-    auto quotient = dividend / divisor;
-    auto remainder = dividend % divisor;
-    if (rtc::SafeGt(-remainder, half_of_divisor)) {
-      --quotient;
-    }
-    return quotient;
-  }
-
-  auto half_of_divisor = (divisor - 1) / 2;
-  auto quotient = dividend / divisor;
-  auto remainder = dividend % divisor;
-  if (rtc::SafeGt(remainder, half_of_divisor)) {
-    ++quotient;
-  }
-  return quotient;
-}
-
-}  // namespace webrtc
-
-#endif  // RTC_BASE_NUMERICS_DIVIDE_ROUND_H_

src/common/rtc_base/numerics/event_based_exponential_moving_average.cc

@@ -1,81 +0,0 @@
-/*
- *  Copyright 2019 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 "event_based_exponential_moving_average.h"
-
-#include <cmath>
-#include <cstdint>
-#include <limits>
-
-namespace {
-
-// For a normal distributed value, the 95% double sided confidence interval is
-// is 1.96 * stddev.
-constexpr double ninetyfive_percent_confidence = 1.96;
-
-}  // namespace
-
-namespace rtc {
-
-// `half_time` specifies how much weight will be given to old samples,
-// a sample gets exponentially less weight so that it's 50%
-// after `half_time` time units has passed.
-EventBasedExponentialMovingAverage::EventBasedExponentialMovingAverage(
-    int half_time) {
-  SetHalfTime(half_time);
-}
-
-void EventBasedExponentialMovingAverage::SetHalfTime(int half_time) {
-  tau_ = static_cast<double>(half_time) / log(2);
-  Reset();
-}
-
-void EventBasedExponentialMovingAverage::Reset() {
-  value_ = std::nan("uninit");
-  sample_variance_ = std::numeric_limits<double>::infinity();
-  estimator_variance_ = 1;
-  last_observation_timestamp_.reset();
-}
-
-void EventBasedExponentialMovingAverage::AddSample(int64_t now, int sample) {
-  if (!last_observation_timestamp_.has_value()) {
-    value_ = sample;
-  } else {
-    // TODO(webrtc:11140): This should really be > (e.g not >=)
-    // but some pesky tests run with simulated clock and let
-    // samples arrive simultaneously!
-    // Variance gets computed after second sample.
-    int64_t age = now - *last_observation_timestamp_;
-    double e = exp(-age / tau_);
-    double alpha = e / (1 + e);
-    double one_minus_alpha = 1 - alpha;
-    double sample_diff = sample - value_;
-    value_ = one_minus_alpha * value_ + alpha * sample;
-    estimator_variance_ =
-        (one_minus_alpha * one_minus_alpha) * estimator_variance_ +
-        (alpha * alpha);
-    if (sample_variance_ == std::numeric_limits<double>::infinity()) {
-      // First variance.
-      sample_variance_ = sample_diff * sample_diff;
-    } else {
-      double new_variance = one_minus_alpha * sample_variance_ +
-                            alpha * sample_diff * sample_diff;
-      sample_variance_ = new_variance;
-    }
-  }
-  last_observation_timestamp_ = now;
-}
-
-double EventBasedExponentialMovingAverage::GetConfidenceInterval() const {
-  return ninetyfive_percent_confidence *
-         sqrt(sample_variance_ * estimator_variance_);
-}
-
-}  // namespace rtc

src/common/rtc_base/numerics/event_based_exponential_moving_average.h

@@ -1,70 +0,0 @@
-/*
- *  Copyright 2019 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.
- */
-
-#ifndef RTC_BASE_NUMERICS_EVENT_BASED_EXPONENTIAL_MOVING_AVERAGE_H_
-#define RTC_BASE_NUMERICS_EVENT_BASED_EXPONENTIAL_MOVING_AVERAGE_H_
-
-#include <cmath>
-#include <cstdint>
-#include <limits>
-#include <optional>
-
-namespace rtc {
-
-/**
- * This class implements exponential moving average for time series
- * estimating both value, variance and variance of estimator based on
- * https://en.wikipedia.org/w/index.php?title=Moving_average&section=9#Application_to_measuring_computer_performance
- * with the additions from nisse@ added to
- * https://en.wikipedia.org/wiki/Talk:Moving_average.
- *
- * A sample gets exponentially less weight so that it's 50%
- * after `half_time` time units.
- */
-class EventBasedExponentialMovingAverage {
- public:
-  // `half_time` specifies how much weight will be given to old samples,
-  // see example above.
-  explicit EventBasedExponentialMovingAverage(int half_time);
-
-  void AddSample(int64_t now, int value);
-
-  double GetAverage() const { return value_; }
-  double GetVariance() const { return sample_variance_; }
-
-  // Compute 95% confidence interval assuming that
-  // - variance of samples are normal distributed.
-  // - variance of estimator is normal distributed.
-  //
-  // The returned values specifies the distance from the average,
-  // i.e if X = GetAverage(), m = GetConfidenceInterval()
-  // then a there is 95% likelihood that the observed variables is inside
-  // [ X +/- m ].
-  double GetConfidenceInterval() const;
-
-  // Reset
-  void Reset();
-
-  // Update the half_time.
-  // NOTE: resets estimate too.
-  void SetHalfTime(int half_time);
-
- private:
-  double tau_;
-  double value_ = std::nan("uninit");
-  double sample_variance_ = std::numeric_limits<double>::infinity();
-  // This is the ratio between variance of the estimate and variance of samples.
-  double estimator_variance_ = 1;
-  std::optional<int64_t> last_observation_timestamp_;
-};
-
-}  // namespace rtc
-
-#endif  // RTC_BASE_NUMERICS_EVENT_BASED_EXPONENTIAL_MOVING_AVERAGE_H_

src/common/rtc_base/numerics/exp_filter.cc

@@ -1,41 +0,0 @@
-/*
- *  Copyright (c) 2011 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 "exp_filter.h"
-
-#include <cmath>
-
-namespace rtc {
-
-const float ExpFilter::kValueUndefined = -1.0f;
-
-void ExpFilter::Reset(float alpha) {
-  alpha_ = alpha;
-  filtered_ = kValueUndefined;
-}
-
-float ExpFilter::Apply(float exp, float sample) {
-  if (filtered_ == kValueUndefined) {
-    // Initialize filtered value.
-    filtered_ = sample;
-  } else if (exp == 1.0) {
-    filtered_ = alpha_ * filtered_ + (1 - alpha_) * sample;
-  } else {
-    float alpha = std::pow(alpha_, exp);
-    filtered_ = alpha * filtered_ + (1 - alpha) * sample;
-  }
-  if (max_ != kValueUndefined && filtered_ > max_) {
-    filtered_ = max_;
-  }
-  return filtered_;
-}
-
-void ExpFilter::UpdateBase(float alpha) { alpha_ = alpha; }
-}  // namespace rtc