From 4cc9f2a3f3c1fbbe2efd9fbd7ae678e035d66833 Mon Sep 17 00:00:00 2001
From: starwishHi <121095733+starwishHi@users.noreply.github.com>
Date: Mon, 5 Oct 2026 00:13:13 +0800
Subject: [PATCH 1/5] Add Korean,Japanese and Traditional Chinese(Taiwan,Macau
and Hongkong)translate (#216)
---
app/src/main/res/values-ja/strings.xml | 952 ++++++++++++++++++
app/src/main/res/values-ko/strings.xml | 952 ++++++++++++++++++
.../{values-zh => values-zh-rCN}/strings.xml | 0
app/src/main/res/values-zh-rHK/strings.xml | 952 ++++++++++++++++++
app/src/main/res/values-zh-rTW/strings.xml | 952 ++++++++++++++++++
5 files changed, 3808 insertions(+)
create mode 100644 app/src/main/res/values-ja/strings.xml
create mode 100644 app/src/main/res/values-ko/strings.xml
rename app/src/main/res/{values-zh => values-zh-rCN}/strings.xml (100%)
create mode 100644 app/src/main/res/values-zh-rHK/strings.xml
create mode 100644 app/src/main/res/values-zh-rTW/strings.xml
diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml
new file mode 100644
index 0000000000..baddb067ad
--- /dev/null
+++ b/app/src/main/res/values-ja/strings.xml
@@ -0,0 +1,952 @@
+
+
+ DroidDeck
+
+ - 初回起動時はSteamをダウンロードします。数分かかる場合があります。
+ - デフォルトでは、アプリを離れるとSteamが一時停止し、戻ると前回の続きから再開します。
+ - コントローラーはXbox 360コントローラーとして認識されます。それ以外の場合は、画面コントローラーを使用してください。
+
+
+ - 初回起動時はデスクトップをセットアップします。数分かかる場合があります。
+ - デフォルトでは、アプリを離れるとセッションが一時停止し、戻ると前回の続きから再開します。
+ - タッチはトラックパッドのように機能します。ドラッグでポインタを移動し、タップでクリックします。
+ - コントローラーはXbox 360コントローラーとして認識されます。それ以外の場合は、画面コントローラーを使用してください。
+
+ セッション
+ Steamまたはデスクトップセッションの開始時に表示
+ Steamが実行中です
+ セッションが一時停止中 - 準備ができたらタップして再開
+ 再開
+ このセッションを終了
+ フレーム生成
+ 使用するフレーム生成モードを選択してください
+ オフ
+ Win-FG %1$d×
+ LSFG %1$d×
+ LSFG アダプティブ %1$d
+ Steam版のLossless Scalingが必要です
+ SteamでLossless Scalingをインストールするか、Lossless.dllをインポートしてください
+ Lossless.dllをインポート…
+ Steam版を使用中
+ インポート版を使用中
+ Lossless.dllファイルを選択
+ Lossless.dllをインポートしました
+ このLossless.dllはすでに使用されています
+ このSteamアカウントはLossless Scalingを所有していません
+ このファイルはLossless ScalingのLossless.dllではありません
+ このLossless.dllからLSFGを準備できませんでした
+ LSFGにはSteam版のLossless Scaling、またはインポートされたLossless.dllファイルが必要です
+ LSFGはこのLossless.dllからシェーダーを準備できませんでした
+ %1$s:サポート外
+ %1$s:エンジンエラー
+ %1$s:Lossless Scalingが必要です
+ %1$s %2$s · 起動中
+ 複数のサブフォルダを含むフォルダ。各サブフォルダはWindowsゲームに対応します。Steamで所有しているゲームはSteamの再起動後にSteamの項目を使用し、それ以外のゲームは非Steamショートカットになります。
+ Steamライブラリを追加し、その中のWindowsゲームをスキャンします。所有しているゲームはSteamの項目を使用し、それ以外のゲームは非Steamショートカットになります。
+ 「忘れる」を選択すると、次回のセッションでこれらのショートカットが削除されます。ただし、ファイルはディスク上に残ります。
+ ゲーム環境
+ Protonゲームの環境変数です。
+ 編集
+ すべてのProtonゲーム
+ プロファイル
+ SteamアプリID
+ 開く
+ ゲーム %1$s
+ 変数を追加
+ 変数名
+ 値
+ 保存
+ 削除
+ 継承を復元
+ このプロファイルをリセット
+ このプロファイルの設定を解除
+ 変数が設定されていません。
+ 継承済み
+ カスタム変数
+ 読み込みまたは保存に失敗しました。空き容量を確認して再試行してください。
+ 有効な名前と値を入力してください。最大8192文字です。
+ 標準のProton実行環境では、この変数は読み取られません。
+ 読み込み中…
+ D3D12機能レベルのオーバーライド。12_2はDirectX 12 Ultimateの機能を報告します。サポートされていない機能は失敗する可能性があります。自動検出するには空にします。
+ D3D12シェーダーモデルのオーバーライド。6_9には十分に新しいVKD3Dと対応するGPU機能が必要です。自動検出するには空にします。
+ Mesaシェーダーキャッシュを有効にして再コンパイルを減らします。無効にするにはfalseに設定します。
+ Mesaシェーダーキャッシュの最大サイズ(例:1G)。キャッシュが大きいほど、ストレージを多く消費します。
+ D3D12のVKD3Dオプション。nodxrはレイトレーシングを無効にします。ゲームが必要とする場合のみ使用してください。
+ 1に設定するとProtonの診断ログを生成します。ログ記録はパフォーマンスを低下させ、ストレージを消費する可能性があります。
+ 1に設定すると、D3D9~11の互換性テストのためにDXVKの代わりにOpenGLベースのWineD3Dを使用します。
+ 0に設定すると、このゲームのProtonコントローラーナビゲーション補助を無効にします。
+ D3D9~11のDXVKオーバーレイ。fpsはフレームレートを表示します。設定を解除するとオーバーレイが非表示になります。
+ セミコロンで区切られたDXVK設定。最近のバージョンではdxvk.maxFrameRateでフレームレートを制限します。通常のプレイにはセッションフレームレートリミッターを推奨します。
+ D3D12のフレームレート制限。0で制限を無効にします。
+ Mesa OpenGLマルチスレッド。CPUに制限のあるOpenGLゲームではtrueが有効な場合があります。ゲームごとにテストしてください。
+ FEXプリセット
+ 次回のゲーム起動時に有効になります。
+ ゲーム
+ FEXデフォルト
+ FEXのデフォルト設定を使用します。
+ 安定性
+ 最も安全で最も遅い設定。
+ 互換性
+ 完全なTSO + multiblock。
+ 中間
+ バランスの取れたTSO設定とx87精度の低下。
+ パフォーマンス
+ すべてのTSOを無効化。multiblockを有効化。
+ パフォーマンス + TSO
+ パフォーマンス設定で、メインTSOを有効化。
+ 極限
+ 自己書き換えコードのチェックを無効化。JITゲームやDRMは動作しない可能性があります。
+ 極限 + TSO
+ 極限設定で、メインTSOを有効化。
+ 極限-gn
+ パフォーマンス設定で、TSCとメタデータヒントを有効化。「極限」を試す前にこのモードを試すことをお勧めします。
+ Denuvo
+ パフォーマンス設定で、完全なコードチェックを有効にし、ハイパーバイザービットを非表示にします。
+ カスタム値
+ 値を選択
+ エミュレーターとアプリ
+ 追加
+ 独自のアプリまたはゲーム
+ スクリプト
+ AppImage
+ Flatpak
+ %1$s · %2$s
+ %1$s · %2$s · %3$d%%
+ 起動中…
+ %1$sを追加しました
+ %1$sを削除しました
+ デスクトップ
+ このアプリは存在しません。デスクトップから再選択してください。
+ %1$sを開く
+ 削除
+ もう一度タップして削除
+ 削除する前にセッションを終了してください
+ %1$sが存在するフォルダから実行し、そのフォルダをセッションにリンクします。アプリを削除してもフォルダには影響しません。
+ DroidDeck内部にコピーされたフォルダから%1$sを実行します。アプリを削除するとコピーは削除されますが、元のファイルは削除されません。
+ 先にLinux実行環境をインストールしてください
+ ファイルが存在しません
+ 空き容量不足:このフォルダのコピーには%1$sが必要です
+ %1$sをコピー中
+ アプリの追加に失敗しました
+ %1$sのリリースを検索中
+ %1$sのリリースを読み取れません
+ %1$sにはARM64 AppImageのリリースがありません
+ %1$sをダウンロード中
+ ダウンロードに失敗しました
+ アプリの更新に失敗しました
+ アイコンを読み取れません
+ %1$sを保存しました
+ 編集
+ アップデートを確認
+ アップデートを確認中…
+ %1$sに更新
+ 最新です · %1$s
+ %1$sを更新しました
+ %1$s · %2$s
+ アプリを追加
+ スクリプト
+ AppImage
+ GitHub
+ Flatpak
+ .shファイル。自身のフォルダから実行され、gamescopeを介して全画面表示されます。
+ ARM64(aarch64)AppImage。初回使用時にLinux実行環境に解凍されます。
+ リポジトリの最新リリースからARM64 AppImageをインストールします。
+ FlathubアプリIDまたはそのFlathubページ。Flatpakがまだセットアップされていない場合は、先にセットアップします。
+ ファイル
+ ファイルが選択されていません
+ ファイルを選択
+ 変更
+ スクリプトを選択
+ AppImageを選択
+ アイコンを選択
+ リポジトリ
+ owner/repo または github.com リンク
+ GitHubリポジトリではありません
+ アプリID
+ org.ppsspp.PPSSPP
+ 有効なFlathubアプリIDではありません
+ ソース
+ デスクトップに表示
+ 新しいアプリ
+ 名前
+ アプリから取得
+ アイコン
+ デフォルトアイコン
+ アイコンを選択
+ クリア
+ リポジトリから
+ アイコンを検索中…
+ デフォルト
+ %1$sを編集
+ 保存
+ フォルダを確認中…
+ フォルダがセッションにリンクされました:%1$s
+ このフォルダにはLinuxプログラムが含まれており、共有ストレージでは実行できないため、DroidDeck(%1$s)にコピーされます。
+ 追加
+ キャンセル
+ 先に「設定」からLinux実行環境をインストールしてください。
+ %1$sが完了するまでお待ちください。
+ キャンセル
+ 自動
+ しない
+ 常に
+ アンインストール
+ 確認
+ 更新
+ 確認中…
+ 処理中…
+ 忘れる
+ 追加…
+ 使用
+ 次回のセッションで有効になります。
+ Steamセッション
+ デスクトップセッション
+ 表示
+ 解像度
+ 最大720p
+ 最大900p
+ 最大1080p
+ ネイティブ
+ %1$s(デフォルト)
+ カスタム · %1$d×%2$d
+ カスタム…
+ 720pにすると、メニューの応答が速くなります。
+ 画面比率
+ カスタム解像度で設定されます。
+ 自動モードでは少なくとも16:9を使用します。
+ フレームレート制限
+ セッション全体のフレームレートを制限します。モニターはこの上限で割り切れるリフレッシュレートに切り替わります。
+ HDR
+ HDR10出力
+ 利用不可:%1$s。
+ アプリの再起動後に有効になります。
+ ドライバー
+ GPUドライバー
+ Steamとデスクトップで共有されます。「コンポーネント」ページで設定してください。
+ タッチとコントロール
+ タッチ
+ トラックパッド
+ ダイレクト
+ 自動:デスクトップではトラックパッド、Steamではダイレクトタッチを使用します。
+ 画面コントローラー
+ Steam + QAM
+ 自動モードでは、コントローラーが接続されていないときに画面コントローラーを表示します。
+ コントローラー
+ Steamがコントローラーを認識する方法。次回のセッションで有効になります。
+ Steam Deckコントローラー
+ Xbox 360コントローラー
+ Deck:クイックアクセスボタンとジャイロを提供します。Xbox 360:Guide+Aでクイックアクセスを開きます。
+ 戻る
+ セッション
+ バックグラウンド動作
+ アプリが非表示または画面オフ時の動作。
+ 手動
+ 自動モードではバックグラウンドで一時停止し、表示時に再開します。手動モードでは「再開」をタップする必要があります。実行したままにはしません。
+ 起動
+ DroidDeck起動時にSteamを起動
+ DroidDeckの起動時にSteamセッションを開きます。
+ Decky
+ リリースを確認中…
+ %1$sをインストールする準備ができました。
+ 互換性のあるバージョンが見つかりません。後でもう一度お試しください。
+ インストール済み · %1$s
+ アップデートあり · %1$s
+ 最新です · %1$s
+ ローダー
+ 最新バージョンをインストール
+ Steamと共に起動します。有効にすると、このデバイス上の他のアプリがSteamを制御できる場合があります。
+ オフ。Steamのリモートデバッグポートは閉じたままになります。
+ Decky Loaderをアンインストールしますか?
+ ローダーを削除します。プラグインと設定は保持されます。
+ クライアント
+ Steam Deckモード
+ Steam DeckのUIとクイックアクセスパフォーマンスコントロール。次回のセッションで有効になります。
+ パフォーマンスオーバーレイ
+ Deckモードでゲームがクラッシュしたり画面が真っ暗になる場合は、これをオフにしてください。次回のセッションで有効になります。
+ クライアントブランチ
+ Steam Deckベータ版(Deckモードに必要)。
+ 次回のセッションで有効になります。Steamが自動的に一度アップデートされる場合があります。
+ ベータ版
+ Steam Deckベータ版
+ Deckモードは常にSteam Deckベータ版を使用します。
+ 追加されたゲーム
+ .exeを含むゲームフォルダが見つかりません
+ ゲームフォルダ
+ 別のゲームフォルダ
+ Steamからの画像
+ フォルダ名に基づいて不足している画像を補完します。ゲームフォルダ内のcover.jpg、hero.jpg、logo.png、またはicon.pngが優先的に使用されます。
+ %1$sを起動
+ %1$sを起動 · %2$s内
+ 別のファイルを選択…
+ デフォルトではフォルダと同じ名前の.exeを使用し、ない場合は最大の.exeを使用します。
+ ゲームを引き伸ばして画面を埋める
+ 自身でサイズ変更できるゲームを全画面に保ちます。ゲームが小さく表示される場合はこれをオフにしてください。次回のセッションで有効になります。
+ 16:9ゲームを引き伸ばす
+ アスペクト比が16:9未満の画面で、黒帯を表示する代わりにゲームを引き伸ばして画面を埋めます。次回のセッションで有効になります。
+ オーディオ
+ ゲームでDirectAudioを使用
+ PulseAudioをバイパスして遅延を減らします。
+ Steamクライアントオーディオ
+ 次回のセッションで有効になります。
+ クラシック
+ DirectAudio
+ マイク
+ ボイスチャットに使用します。
+ ネットワーク
+ Wi-Fi検出
+ SteamにWi-Fi名と付近のネットワークを表示します。
+ 位置情報サービスがオフです。
+ 位置情報の権限がありません。
+ 設定を開く
+ 続行
+ Wi-Fi検出を有効にしますか?
+ AndroidがWi-Fi名を読み取り、付近のネットワークを検出するには位置情報の権限が必要です。DroidDeckはこの権限を使用してSteamにこれらのネットワークを表示します。位置情報を追跡することはありません。この権限がなくてもインターネットにアクセスできます。
+ ゲームストレージ
+ 自動 - SDカードがある場合はSDカードを使用
+ 自動 - SDカードがある場合はSDカードを使用(現在SDカードなし)
+ 内部ストレージのみ
+ フォルダ:%1$s
+ 第2ライブラリ
+ SDカードまたは共有ストレージからリソースを読み取るゲームはカクつく場合があります。
+ フォルダを選択…
+ レンダラー
+ デスクトップレンダラー
+ デスクトップの描画を担当します。
+ vulkan - GPU
+ gles2 - GPU(実験的)
+ pixman - ソフトウェア
+ VulkanはGPUを使用してデスクトッププログラムを実行し、失敗した場合はpixmanにフォールバックします。pixmanを使用する場合でも、ゲームはGPU上で全画面実行されます。
+ カスタム解像度
+ 解像度の上限と画面比率を置き換えます。画面に合わないサイズは黒帯で表示されます。
+ 幅
+ 高さ
+ 範囲:320×240 ~ 3840×2160。
+
+ - %1$d 個のゲーム
+ - %1$d 個のゲーム
+
+ OK
+ 削除
+ 復元
+ ダウンロード
+ %1$sを削除
+ %1$.1f MB
+ ランタイムドライバー
+ Steam、ゲーム、デスクトップで使用されます。次回のセッションで有効になります。
+ Turnip zipをインポート…
+ ディスプレイドライバー
+ どちらのモードでも画面への出力を担当します。アプリの再起動後に有効になります。
+ AdrenoTools zipをインポート…
+ なし
+ Nightliesの確認日時 %1$s
+ コンポーネント
+ コンポーネントについて
+ 新しいドライバーを確認
+ Nightliesの新しいパッケージを確認
+ Proton
+ Steamのアップデート時にValveのProtonが置き換わります。各ビルドの元のファイルは保持されます。
+ %1$s · %2$d個を置き換え
+ %1$s · すべて元のファイル
+ %1$s · ゲーム実行中
+ GPUドライバー
+ %1$s · %2$sの起動時に再適用
+ 次:%1$s · ゲーム終了後
+ %1$sを使用中:%2$s
+ ゲームの終了を待機中
+ 次回のゲーム起動時に有効になります
+ .zipをインポート
+ Protonを読み込み中…
+ Protonがインストールされていません。一度Steamを起動してARM64 Protonをダウンロードするか、「設定」からGE-ProtonまたはCachyOSを追加してください。
+ 元 · %1$s
+ %1$s · 現在のビルド
+ %1$s · 以前のビルド
+ インストール済み · %1$d
+ %1$sにはまだ何も保存されていません。このProtonに同梱されているファイルが元のファイルとして保存されます。
+ 現在このProtonを使用しているゲームがあるため、ゲームが終了するまで待機する必要があります。
+ 次回のゲーム起動時に有効になります。
+ %1$sを置き換えますか?
+ %1$sを%2$sに入れますか?元のファイルは引き続き保存されます。%3$s
+ %1$sを復元しますか?
+ %1$sの元のファイルを%2$sに戻しますか?%3$s
+ アプリからこのパッケージを削除します。後で再度ダウンロードできます。
+ この元のバージョンを削除しますか?
+ この%1$sの元のバージョンは、%2$sの以前のビルドのものです。現在のビルドの元のバージョンは常に保持されます。
+ Nightlies内 · %1$d
+ 更新してNightliesのパッケージを一覧表示します。
+ 前回の確認以降、新しいものはありません。
+ .wcpをインポート
+ このProtonの元のファイルを復元
+ %1$sの元のファイル%2$sを元に戻しますか?
+ 切り替え
+ FEX、DXVK、VKD3D-Proton:Steamがゲームを実行するために使用する各Proton向け。\n\nインストール済みの項目を選択すると、それに差し替えられます。次回のゲーム起動時、または現在実行中のゲームを終了した後に有効になります。\n\n起動のたびに選択内容が再確認され、変更されていれば復元されます。各Protonの元のファイルは保持されるため、Steamのアップデートで失われることはありません。
+ 元
+ 使用中
+ 新規
+ 保存済み
+ パフォーマンス
+ CPUコア、セッション修正、ホスト名。次回のセッションで有効になります。
+ Steamクライアントコア
+ Steamのコア選択を上書き
+ Steam、UI補助、gamescopeを以下で選択したコアに固定します。
+ クライアントコア
+ Steamが使用するコア。
+ 上書きをオンにすると選択できます。
+ ゲームコア
+ ゲームコア
+ ゲームが使用するコア。すべて選択するとAndroidが自由にスケジュールします。
+ クライアントUI
+ GLマルチスレッド
+ Steamメニューの応答が速くなる可能性があります。
+ Zink:遅延ディスクリプタ
+ ディスクリプタバッファのないドライバーに推奨されます。
+ GLエラーチェックをスキップ
+ 呼び出しごとのGL検証をオフにします。
+ gamescope:リアルタイムGPUキュー
+ コンポジタのGPU作業の優先度を上げます。フレームタイムの安定性が向上する場合がありますが、ゲームのパフォーマンスの一部を消費します。
+ GPU
+ GPUを最高クロックに保つ
+ Adrenoのみ。スタッターは減りますが、消費電力と発熱が増えます。
+ セッション修正
+ Turnip:sysmemレンダリング
+ Steamとほとんどのゲームが高速になります。Adreno 710/720/722では必須です。
+ Steamのxalia補助をスキップ
+ Protonのコントローラーナビゲーション補助を無効にします。これはすべてのゲームでCPUを消費します。
+ seccompなしでprootを実行
+ 一部のカーネルでのシステムコール不足エラーを修正する場合がありますが、パフォーマンスが低下する可能性があります。
+ prootファストパス
+ prootのseccompフィルターが必要です。
+ ファイル検索が速くなり、スタッターが減ります。プログラムがファイルを見つけられない場合は、これをオフにしてください。
+ セッションID
+ ホスト名
+ Steamがこのデバイスを認識する名前。空にすると%1$sに戻ります。
+ 英数字と中間のハイフンのみ使用でき、最大63文字です。
+ Androidがこのセッションを終了するように設定されています
+ インストール済み
+ ダウンロード可能
+ 前回の確認以降、新しいものはありません。
+ 内蔵ドライバーを復元
+ アプリ内蔵ドライバー:この操作により、解凍されたファイルが削除され、ドライバーが非表示になります。「内蔵ドライバーを復元」で元に戻せます。
+ Android + Linuxバンドルの半分:両方の部分が削除されます。使用中のドライバーはデフォルトにフォールバックします。
+ ファイルがアプリから削除されます。
+ ファイルが削除されます。使用中のため、デフォルトのドライバーに切り替わります。
+ 表示
+ コントロール
+ コンポーネント
+ 設定
+ %1$sページ
+ Steam
+ デスクトップ
+ Steamメニュー
+ クイックアクセス
+ クイックアクセスメニューを開く
+ 前のページ
+ 次のページ
+ パフォーマンスHUD
+ ゲームを引き伸ばして画面を埋める
+ 自動(%1$s)
+ キーボード
+ PCキーボード
+ Android
+ セカンドスクリーン
+ 表示
+ Androidアプリ
+ アプリを起動
+ 非表示
+ 表示
+ 起動できるアプリがありません
+ セッション動作
+ すぐに適用され、このモードの今後のセッションにも適用されます。
+ 次回のセッション
+ サポート
+ セッションログ
+ バグレポートに添付
+ ログを共有
+ バックグラウンド
+ 停止
+ セッションを停止しますか?
+ 現在実行中
+ 現在Protonで実行中のゲームはありません
+ Protonがインストールされていません。
+ ゲーム実行中
+ %1$sの起動時に再適用しました
+ 元
+ 「コンポーネント」ページでダウンロード、インポート、削除してください。
+ 完了
+ 要対応
+ 処理中
+ ワイヤレスデバッグのIPアドレスとポートを確認してください。Androidがデバイスを削除した場合は、再ペアリングしてください。
+ インストール
+ 管理
+ 概要
+ コントローラー
+ セッション
+ ランチャー
+ 設定
+ ● すべて準備完了
+ %1$d/%2$d 準備完了
+ システムチェック
+ デバイスはサポートされています
+ 未テストのGPU
+ GPUはサポートされていません
+ %1$s · %2$s
+ %1$s:%2$s
+ SteamにはAdrenoドライバーが必要です。%1$sでは画面が真っ暗になる可能性があります。
+ Linux実行環境
+ %1$s · %2$d%%
+ 未インストール · 約3GB、初回ゲーム起動時にインストール
+ インストール済み
+ %1$s · アップデートあり
+ %1$s · 最新です
+ 子プロセス制限
+ オン · AndroidがSteamを閉じる可能性があります。制限を解除するには約1分かかります。
+ 未設定 · AndroidがSteamを閉じる可能性があります。制限を解除するには約1分かかります。
+ 確認できません · 制限を解除するには約1分かかります。
+ 修正
+ 詳細
+ 開発者向けオプション
+ ワイヤレスデバッグを使用
+ 再確認
+ 制限をオンにする
+ Steamアカウント
+ %1$sとしてログイン中 · オフラインモード
+ %1$sとしてログイン中
+ PlayをタップしてSteamにログイン
+ ツール
+ コントローラー
+ コントローラー設定は利用できません。
+ セッション
+ セッションログ
+ 各セッション終了後に保存
+ 最新のセッションログ
+ 保存されたセッションログ
+ 最新の%1$d件を保持
+ ログを消去
+ オフラインモード
+ 先にSteamにログインしてください
+ ランチャー
+ テーマ
+ ランチャーの外観
+ ホーム画面として使用
+ DroidDeckをホームアプリとして使用できます
+ DroidDeckはホームアプリとして提供されません
+ 全画面
+ Androidのステータスバーとナビゲーションバーを非表示
+ Androidのステータスバーとナビゲーションバーを表示
+ デフォルトのホームアプリ
+ ホームアプリを選択
+ 選択
+ Linuxアプリ(ベータ版)
+ Flathubストア
+ メニューに表示されます。一部のアプリは起動できない場合があります。ログはDownload/DroidDeckにあります。
+ FlathubからLinuxアプリとゲームをインストール
+ ファイル
+ ファイルの閲覧と管理
+ Protonバージョン
+ ARM64 Protonビルドをインストール
+ パフォーマンス
+ CPUコアの割り当て
+ ROMフォルダ
+ エミュレーターゲームの保存場所
+ コンポーネント
+ FEX、DXVK、VKD3D
+ コントロール
+ キーマッピング
+ 発見
+ 検索
+ インストール済み
+ %1$s · %2$d
+ ストア
+ Flathub · ARM64
+ ● Flatpakの準備完了
+ 先に「設定」からLinux実行環境をインストールしてください。
+ Flatpakをセットアップ
+ Flatpakを追加し、Flathubに接続します(約20MB)。最初のアプリは実行環境もダウンロードします。
+ セットアップ中…
+ Flatpak
+ アップデート
+ %1$s · %2$s
+ %1$s · %2$s · %3$d%%
+ 起動中…
+ カテゴリ
+ Flathubに接続できません。ネットワーク接続を確認して再試行してください。
+ 再試行
+ Flathubを検索
+ Firefox、ゲーム、エミュレーター…
+ 検索
+ すべて
+ 検索中…
+ 名前で検索するか、カテゴリを選択してください。ここにはARM64アプリのみが表示されます。
+ Flathubに一致するARM64アプリはありません。
+ 結果
+ アップデートを確認
+ すべて更新(%1$d)
+ ● すべて最新バージョンです
+ アプリがまだありません。「発見」または「検索」で探してください。
+ Flatpakをセットアップするとアプリをインストールできます。
+ アップデートあり · %1$s
+ 開く
+ 詳細
+ 削除
+ もう一度タップして削除
+ インストール中…
+ インストール
+ 先にFlatpakをセットアップ
+ ダウンロード %1$s
+ ● インストール済み
+ このアプリのFlathubページを読み込めませんでした。
+ Flathubから読み込み中…
+ FlathubにARM64ビルドがないため、ここにはインストールできません。
+ スクリーンショット
+ 概要
+ アプリID
+ ライセンス
+ 実行環境
+ インストールサイズ
+ %1$s(共有実行環境を除く)
+ ウェブサイト
+ 認証済み
+ アップデート
+ DroidDeck %1$s · %2$s
+ 確認日時 %1$s
+ 未確認
+ DroidDeckの自己更新を許可
+ 次のページで「この提供元を許可」をオンにして戻ってください。アップデートが自動的に続行されます。
+ 設定を開く
+ 後で
+ 署名が異なります
+ インプレース更新できません
+ このコピーはDroidDeckのリリースキーで署名されていないため、直接上書き更新できません。アンインストールしてから切り替えてください。
+ アップデートあり
+ インストールできません
+ 切り替え可能
+ Stableより先行
+ Stableより先行しています
+ このビルドは最新のStableより新しいです。次のStableリリース後、Stableに切り替わります。
+ テスト終了
+ このテストは終了しました
+ この修正はマージされたか、破棄されました。最新の修正についてはPreviewをフォローしてください。
+ 最新です
+ 最新の%1$sを使用しています
+ · %1$s
+ %1$s… %2$d%%
+ %1$s…
+ %1$sを更新
+ %1$sをインストール
+ Stable %1$sをインストールする
+ Previewをフォロー
+ 実行中のセッションを停止してから更新してください。
+ 折りたたむ
+ もっと見る
+ DroidDeck %1$s
+ 新しいPreviewビルド
+ PR #%1$d テストビルド
+ %1$d MB
+ アップデートチャンネル
+ Stable
+ テスト済みのバージョン、ほとんどの人に推奨
+ %1$s · %2$s
+ Preview
+ Stable前の最新の修正
+ 最新です
+ テストビルド
+ 正式リリース前に特定の修正を試す
+ 現在ありません
+ PR #%1$d
+ このDroidDeckコピー用にはビルドされていません
+ %1$sを更新しました
+ PR #%1$d テスト版
+ さっき
+ たった今
+
+ - %1$d 個試せます
+ - %1$d 個試せます
+
+
+ - あなたのビルド以降の変更 · %1$d ビルド遅れています
+ - あなたのビルド以降の変更 · %1$d ビルド遅れています
+
+
+ - 最近の変更 · %1$d ビルド
+ - 最近の変更 · %1$d ビルド
+
+ 変更が必要なAndroid設定が1つあります
+ Steam
+ Androidは多数のバックグラウンドプロセスを起動するアプリを停止しますが、Steamは数十のプロセスを起動します。この設定を変更するまで、ゲームがエラー表示なしで閉じる可能性があります。
+ 自動で修正
+ 「子プロセス制限を無効にする」をオンにして戻ってください。開発者向けオプションをオンのままにしないと、スイッチが再びオフになります。
+ 開発者向けオプションを開く
+ このAndroidバージョンにはこのスイッチがないため、DroidDeckはワイヤレスデバッグを介して変更します。約1分かかり、PCは不要です。
+ ワイヤレスデバッグにはWi-Fiが必要です。ネットワークは何でもよく、インターネットは不要です。
+ ペアリングコードは通知に表示されます。DroidDeckに通知を許可するか、「他の方法」を使用してください。
+ 通知を許可
+ 設定 → 開発者向けオプション → ワイヤレスデバッグを開き、オンにする
+ 「ペアリングコードでデバイスをペア設定」をタップ
+ DroidDeckの通知にペアリングコードを入力
+ ペアリングのポップアップを待機中…
+ ポップアップが見つかりました。表示されたペアリングコードを通知に入力してください。
+ ステータス
+ 2秒ごとに確認します。このスイッチをオフにすると、このページは自動的に閉じます。
+ 他の方法
+ ワイヤレスデバッグ、手動でアドレス入力、PC ADB
+ 手動でアドレス入力、PC ADB、開発者向けオプション
+ 代わりにワイヤレスデバッグを使用
+ 一部のROMではこのスイッチが提供されています。開発者向けオプションで「子プロセス」を検索してください。
+ 通知方法が機能しない場合は、ポップアップのアドレスとペアリングコードを手動で入力してください。
+ 手動でアドレスを入力
+ PCでADBを使用:
+ コマンドをコピー
+ Android設定をどの画面で開くか選択してください。
+ メイン画面
+ ペアリング済み。ワイヤレスデバッグのポートを検索中…
+ ペアリング済み。設定のポートを入力してください。
+ デバイスが見つかりました。設定を適用中…
+ 自動適用できませんでした。以下のアドレスを確認して再試行してください。 %1$s
+ ワイヤレスデバッグ
+ 子プロセス制限を更新しました
+ 子プロセス制限の変更
+ オプションがない場合は、ワイヤレスデバッグでペアリングしてください。
+ ペアリング済み。ワイヤレスデバッグのIPアドレスとポートを確認してください。
+ 子プロセス制限を更新しました。
+ 開発者向けオプションに子プロセス設定がない場合は、手順2を使用してください。開発者向けオプション → ワイヤレスデバッグ → ペアリングコードでデバイスをペア設定を開きます。
+ ペアリング済み。以下のアドレスを使用するか、ワイヤレスデバッグ → IPアドレスとポートで更新してください。
+ ワイヤレスデバッグを介して子プロセス制限を更新しました。
+ Androidは制限がオンであることを確認しました。
+ Androidは制限がオフであることを確認しました。
+ 2 · ワイヤレスデバッグのペアリング
+ ポップアップのIPアドレスとポート
+ ペアリングコード(PIN)
+ 6桁の数字
+ ペアリング
+ 2 · ワイヤレスデバッグで適用
+ IPアドレスとポートを接続
+ 再ペアリング
+ 制限をオフにする
+ その他の変更方法
+ 1 · 開発者向けオプション(最初に試す)
+ 「子プロセスを制限」をオンにします。
+ 「子プロセスを制限」をオフにします。
+ 3 · PC ADB(最終手段)
+ ワイヤレスデバッグが利用できない場合にのみ使用してください。
+ 3 · PC ADB(最終手段)
+ セッション中に画面コントローラーを表示する場合
+ 色
+ 画面ボタンの色調
+ カスタム
+ 不透明度
+ %1$d%%
+ ボタンのサイズ
+ 100% が標準サイズです
+ スティッククリック
+ スティックをダブルタップして長押しすると、L3またはR3がトリガーされます
+ アダプティブスティック
+ ゲームの振動
+ Steamボタン
+ QAMボタン
+ キーボードボタン
+ アニメーション
+ スティックは触れた位置に表示され、離すと非表示になります
+ レイアウト
+ カスタム位置を保存済み
+ この画面に最適化済み
+ 編集
+ リセット
+ キーマッピング
+ 各ボタンは対応する元の入力を送信します
+ %1$d/%2$d 個のボタンを再マッピング済み
+ 設定
+ コントローラーをリセット
+ すべてのコントローラー設定とレイアウトを復元
+ 各画面ボタンがゲームに送信する入力を設定します。「非表示」にするとそのボタンが削除されます。
+ 画面ボタン
+ デフォルト
+ マッピングをリセット
+ Androidアプリ
+ %1$d 個のアプリ
+ 起動可能なAndroidアプリが見つかりませんでした。
+ ● デスクトップインストール済み
+ 初回起動時にインストール
+ インストール可能
+ 未インストール。
+ %1$s · 未インストール
+ %1$sを開く
+ ゲーム
+ ROMフォルダを選択してください。
+ RetroArchで /root/ROMs に移動します。
+ %1$s 個のゲームを ROMs/%2$s に追加しました。
+ %1$sをインストール
+ セッションを停止してインストール
+ 実行環境が必要です
+ インストール詳細を読み込み中…
+ インストール詳細は利用できません。後でもう一度お試しください。
+ 先に「設定」からLinux実行環境をインストールしてください。
+ 実行中のセッションを停止してからデスクトップアプリをインストールしてください。
+ %1$sをLinuxデスクトップにインストールします。
+ %1$s · %2$d%%
+ 非表示にするとデスクトップから削除されます。ファイルはLinux実行環境に残ります。
+ このゲームはROMフォルダにありません。
+ デスクトップ · %1$s
+ %1$sで起動
+ %1$sにもあります
+ このページは存在しません。左側から列を選択してください。
+ デスクトップを開く
+ インストールしてデスクトップを開く
+ Linuxデスクトップ
+ LXQt、Firefox、エミュレーター
+ Steamでインストールされたゲームは、セッション終了後にここに表示されます。
+ Steamを実行
+ 起動設定
+ 起動
+ ゲームファイル
+ Protonプレフィックス
+ セーブデータを検索中…
+ 名前でセーブフォルダが見つかりませんでした。エクスポート時にはユーザーフォルダ全体が含まれます。
+ %1$d 個のセーブフォルダ
+ %1$s · %2$d 個のファイル · %3$s
+ %1$d KB
+ セーブデータの管理
+ ゲームセーブデータ
+ セーブデータをインポート…
+ GameHubまたはWinlatorのアーカイブ。インポート前に現在のセーブデータをバックアップします。
+ GameHubアーカイブとしてエクスポート…
+ GameHubおよびBannerHubに適しています
+ Winlatorアーカイブとしてエクスポート…
+ Winlator、WinNative、Bannerlatorに適しています
+ セーブフォルダを開く
+ 未プレイ
+ 実行環境がビジー · %1$d%%
+ 実行環境がビジー
+ 初回ゲーム起動時に実行環境をインストール
+ 実行環境にアップデートがあります
+ ● 実行環境の準備完了
+ 最終プレイ %1$s
+ 内部ストレージ
+ 追加されたゲーム
+ このGPUに最適なドライバー構成を選択し、最新の状態に保ちます
+ ドライバー構成を自分で選択する
+ ドライバーを確認中…
+ ドライバーがまだ一覧表示されていません。更新してドライバーを検索してください。
+ 他のGPUのドライバーを非表示
+ 他のGPUのドライバーを表示
+ 詳細設定
+ ディスプレイドライバーと一緒に設定:%1$s は両方を含みます。
+ ランタイムドライバーと一緒に設定:%1$s は両方を含みます。
+ ゲームとデスクトップで使用されます。
+ ランタイムデフォルト
+ 画面への出力を担当します。DroidDeckの再起動後に有効になります。
+ 自動 - GPUごとに選択
+ ダウンロード、インポート、削除…
+ 使用中
+ DroidDeck内蔵ドライバー
+ ランタイムドライバーとディスプレイドライバーは一致する組み合わせとして設定されます。
+ このGPUに推奨:%1$s。
+ 更新してこのGPUに適したドライバーを検索してください。
+ 推奨
+ 利用不可
+ Linux実行環境
+ Linux実行環境を準備中
+ セッション
+ ディスプレイとオーディオを起動中
+ Steamクライアント
+ Steamと互換性ツールを確認中
+ Steamを起動中
+ Steamの最初のフレームを待機中
+ デスクトップ
+ デスクトップを準備中
+ 起動中
+ 最初のフレームを待機中
+ Steamを起動中
+ セッションが終了しました
+ ステップ %1$d / %2$d
+ Steam一時停止中
+ グリップ
+ 左トラックパッド
+ 右トラックパッド
+ 両方
+ セカンドスクリーンコントロールを閉じる
+ Steamメニューを開く
+ 左 · 上
+ 左 · 下
+ 右 · 上
+ 右 · 下
+ クリック
+ 右トラックパッド
+ 左トラックパッド
+ トラックパッド
+ キーボードを表示
+ キーボードを隠す
+ Linuxターミナル
+ Linuxセッションの準備ができていないため、ターミナルを使用できません。
+ Steam
+ ゲーム
+ デスクトップ
+ ストア
+ コンポーネント
+ アプリ
+ 設定
+ アップデート
+ %1$d%%
+ %1$sを再開
+ 各セッションで /root/ROMs として表示されます。内部ストレージは /root/Storage にあります。
+ フォルダが選択されていません
+ 次回のセッションで有効になります。SDカードをサポートしています。
+ フォルダを選択
+ フォルダを変更
+ ARM64 Protonビルドをインストールし、Steam → プロパティ → 互換性で各ゲームに選択します。
+ 実行中のセッションを停止してから互換性ツールをインストールまたは削除してください。
+ 利用可能なビルド
+ %1$s インストール済み
+ 前回のリクエストによる保留中の項目
+ 未インストール
+ 今すぐインストール
+ キューをキャンセル
+ Androidキーボード
+ 隠す ✕
+ %1$sを起動
+ 画面を選択してください。セカンダリ画面:%1$s。
+ セカンダリ画面は利用できません。
+ メイン画面
+ セカンダリ画面
+ 前のタブ
+ 次のタブ
+ オン
+ すべて %1$d
+ なし
+ %1$d/%2$d
+ オフ
+ 下部画面
+ 次回のゲーム起動時に有効になります。ゲームのプロファイルが共有設定を上書きします。
+ アプリIDで他のゲームを選択…
+ 完了
+ デフォルト
+ オフ
+ 変更…
+ 変数を変更
+ デフォルトに戻す
+ Protonゲーム
+ ピクチャーインピクチャー
+ 自動でピクチャーインピクチャー
+ 一時停止中
+ セッションの準備ができたらピクチャーインピクチャーを使用できます。
+ Android設定でDroidDeckのピクチャーインピクチャーを許可してください。
+ Androidがピクチャーインピクチャーを開けませんでした。
+ ショートカット
+ ホーム画面に追加
+ ゲームを選択
+ インストール済みゲームをスキャン中…
+ 起動リンクをコピー
+ 起動リンクをコピーしました
+ このランチャーはショートカットを追加できません。「起動リンクをコピー」を使用してください。
+ 無効なゲーム起動リンクです。
+ このゲームはDroidDeckライブラリにありません。
+ Steamゲームを起動する前に現在のセッションを停止してください。
+ Steamにゲームを送信できませんでした。もう一度起動してみてください。
+ 削除を再試行
+ 削除中
+ 削除が完了していません
+ ゲームファイルをエクスポート
+ すべてのゲームファイルをフォルダに同期
+ ゲームファイルの同期を停止
+ フロントエンドゲームファイル用のフォルダを選択
+ ゲームファイルを %1$s に保存しました
+ フロントエンドファイル
+
\ No newline at end of file
diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml
new file mode 100644
index 0000000000..807825b118
--- /dev/null
+++ b/app/src/main/res/values-ko/strings.xml
@@ -0,0 +1,952 @@
+
+
+ DroidDeck
+
+ - 첫 실행 시 Steam을 다운로드합니다. 몇 분 정도 걸릴 수 있습니다.
+ - 기본적으로 앱을 나가면 Steam이 일시 중지되며, 다시 돌아오면 중단된 부분부터 재개됩니다.
+ - 컨트롤러는 Xbox 360 컨트롤러로 표시됩니다. 그렇지 않은 경우 화면 컨트롤을 사용하세요.
+
+
+ - 첫 실행 시 데스크톱을 설정합니다. 몇 분 정도 걸릴 수 있습니다.
+ - 기본적으로 앱을 나가면 세션이 일시 중지되며, 다시 돌아오면 중단된 부분부터 재개됩니다.
+ - 터치는 트랙패드처럼 작동합니다. 드래그하여 포인터를 이동하고, 탭하여 클릭합니다.
+ - 컨트롤러는 Xbox 360 컨트롤러로 표시됩니다. 그렇지 않은 경우 화면 컨트롤을 사용하세요.
+
+ 세션
+ Steam 또는 데스크톱 세션이 실행 중일 때 표시
+ Steam이 실행 중입니다
+ 세션이 일시 중지됨 - 준비되면 탭하여 재개하세요
+ 재개
+ 이 세션 종료
+ 프레임 생성
+ 사용할 프레임 생성 모드를 선택하세요
+ 끔
+ Win-FG %1$d×
+ LSFG %1$d×
+ LSFG 적응형 %1$d
+ Steam에서 Lossless Scaling이 필요합니다
+ Steam에서 Lossless Scaling을 설치하거나 Lossless.dll을 가져오세요
+ Lossless.dll 가져오기…
+ Steam 버전 사용 중
+ 가져온 버전 사용 중
+ Lossless.dll 파일 선택
+ Lossless.dll을 가져왔습니다
+ 이 Lossless.dll은 이미 사용 중입니다
+ 이 Steam 계정에는 Lossless Scaling이 없습니다
+ 이 파일은 Lossless Scaling의 Lossless.dll이 아닙니다
+ 이 Lossless.dll에서 LSFG를 준비할 수 없습니다
+ LSFG에는 Steam의 Lossless Scaling 또는 가져온 Lossless.dll 파일이 필요합니다
+ LSFG가 이 Lossless.dll에서 셰이더를 준비할 수 없습니다
+ %1$s: 지원되지 않음
+ %1$s: 엔진 실패
+ %1$s: Lossless Scaling 필요
+ %1$s %2$s · 시작 중
+ 여러 하위 폴더가 포함된 폴더이며, 각 하위 폴더는 Windows 게임에 해당합니다. Steam에서 소유한 게임은 Steam 재시작 후 해당 Steam 항목을 사용하고, 나머지 게임은 비 Steam 바로 가기가 됩니다.
+ Steam 라이브러리를 추가하고 그 안의 Windows 게임을 검사합니다. 소유한 게임은 해당 Steam 항목을 사용하고, 나머지 게임은 비 Steam 바로 가기가 됩니다.
+ "잊기"를 누르면 다음 세션에서 이 바로 가기가 제거됩니다. 하지만 파일은 디스크에 그대로 남습니다.
+ 게임 환경
+ Proton 게임의 환경 변수입니다.
+ 편집
+ 모든 Proton 게임
+ 프로필
+ Steam 앱 ID
+ 열기
+ 게임 %1$s
+ 변수 추가
+ 변수 이름
+ 값
+ 저장
+ 제거
+ 다시 상속
+ 이 프로필 초기화
+ 이 프로필 설정 해제
+ 설정된 변수가 없습니다.
+ 상속됨
+ 사용자 정의 변수
+ 불러오거나 저장할 수 없습니다. 남은 저장 공간을 확인한 후 다시 시도하세요.
+ 유효한 이름과 값을 입력하세요. 최대 8192자까지 입력할 수 있습니다.
+ 표준 Proton 실행 환경에서는 이 변수를 읽지 않습니다.
+ 불러오는 중…
+ D3D12 기능 수준 재정의. 12_2는 DirectX 12 Ultimate 기능을 보고합니다. 지원되지 않는 기능은 실패할 수 있습니다. 자동 감지하려면 비워 두세요.
+ D3D12 셰이더 모델 재정의. 6_9는 충분히 새로운 VKD3D와 일치하는 GPU 기능이 필요합니다. 자동 감지하려면 비워 두세요.
+ 반복 컴파일을 줄이기 위해 Mesa 셰이더 캐시를 활성화합니다. 비활성화하려면 false로 설정하세요.
+ Mesa 셰이더 캐시의 최대 크기(예: 1G). 캐시가 클수록 더 많은 저장 공간을 차지합니다.
+ D3D12의 VKD3D 옵션. nodxr은 레이 트레이싱을 비활성화합니다. 게임에서 필요할 때만 사용하세요.
+ 1로 설정하면 Proton 진단 로그를 생성합니다. 로깅은 성능을 저하시키고 저장 공간을 차지할 수 있습니다.
+ 1로 설정하면 D3D9–11 호환성 테스트를 위해 DXVK 대신 OpenGL 기반 WineD3D를 사용합니다.
+ 0으로 설정하면 이 게임에 대해 Proton의 컨트롤러 탐색 도우미를 비활성화합니다.
+ D3D9–11의 DXVK 오버레이. fps는 프레임 속도를 표시합니다. 설정을 해제하면 오버레이가 숨겨집니다.
+ 세미콜론으로 구분된 DXVK 설정. 최신 버전은 dxvk.maxFrameRate를 사용하여 프레임 속도를 제한합니다. 일상적인 플레이에는 세션 프레임 속도 제한기를 사용하는 것이 좋습니다.
+ D3D12 프레임 속도 제한. 0은 제한을 비활성화합니다.
+ Mesa OpenGL 멀티스레딩. CPU에 제한된 OpenGL 게임에서 true가 도움이 될 수 있습니다. 게임별로 테스트하세요.
+ FEX 프리셋
+ 다음 게임 실행 시 적용됩니다.
+ 게임
+ FEX 기본
+ FEX 기본 설정을 사용합니다.
+ 안정성
+ 가장 안전하고 느린 설정.
+ 호환성
+ 전체 TSO + multiblock.
+ 중간
+ 균형 잡힌 TSO 설정 및 x87 정밀도 감소.
+ 성능
+ 모든 TSO 비활성화. multiblock 활성화.
+ 성능 + TSO
+ 성능 설정 및 기본 TSO 활성화.
+ 익스트림
+ 자체 수정 코드 검사 비활성화. JIT 게임 및 DRM이 실행되지 않을 수 있습니다.
+ 익스트림 + TSO
+ 익스트림 설정 및 기본 TSO 활성화.
+ 익스트림-gn
+ 성능 설정, TSC 및 메타데이터 힌트 활성화. "익스트림"을 사용하기 전에 이 모드를 먼저 시도해 보세요.
+ Denuvo
+ 성능 설정, 전체 코드 검사 활성화 및 하이퍼바이저 비트 숨기기.
+ 사용자 정의 값
+ 값 선택
+ 에뮬레이터 및 앱
+ 추가
+ 나만의 앱 또는 게임
+ 스크립트
+ AppImage
+ Flatpak
+ %1$s · %2$s
+ %1$s · %2$s · %3$d%%
+ 시작 중…
+ %1$s 추가됨
+ %1$s 제거됨
+ 데스크톱
+ 앱이 더 이상 존재하지 않습니다. 데스크톱에서 다시 선택하세요.
+ %1$s 열기
+ 제거
+ 다시 탭하여 제거
+ 제거하기 전에 세션을 종료하세요
+ 해당 폴더에서 %1$s을(를) 실행하고 해당 폴더를 세션에 연결합니다. 앱을 제거해도 폴더는 영향을 받지 않습니다.
+ DroidDeck 내부로 복사된 폴더에서 %1$s을(를) 실행합니다. 앱을 제거하면 복사본은 삭제되지만 원본 파일은 삭제되지 않습니다.
+ 먼저 Linux 런타임을 설치하세요
+ 파일이 더 이상 존재하지 않습니다
+ 사용 가능한 공간 부족: 이 폴더를 복사하려면 %1$s이(가) 필요합니다
+ %1$s 복사 중
+ 앱 추가 실패
+ %1$s의 릴리스 확인 중
+ %1$s의 릴리스를 읽을 수 없습니다
+ %1$s에 ARM64 AppImage 릴리스가 없습니다
+ %1$s 다운로드 중
+ 다운로드 실패
+ 앱 업데이트 실패
+ 아이콘을 읽을 수 없습니다
+ %1$s 저장됨
+ 편집
+ 업데이트 확인
+ 업데이트 확인 중…
+ %1$s(으)로 업데이트
+ 최신 버전 · %1$s
+ %1$s 업데이트됨
+ %1$s · %2$s
+ 앱 추가
+ 스크립트
+ AppImage
+ GitHub
+ Flatpak
+ .sh 파일입니다. 자체 폴더에서 실행되며 gamescope를 통해 전체 화면으로 표시됩니다.
+ ARM64(aarch64) AppImage입니다. 처음 사용할 때 Linux 런타임에 압축이 풀립니다.
+ 리포지토리의 최신 릴리스에서 ARM64 AppImage를 설치합니다.
+ Flathub 앱 ID 또는 해당 Flathub 페이지입니다. Flatpak이 아직 설정되지 않은 경우 먼저 설정합니다.
+ 파일
+ 선택된 파일 없음
+ 파일 선택
+ 변경
+ 스크립트 선택
+ AppImage 선택
+ 아이콘 선택
+ 리포지토리
+ owner/repo 또는 github.com 링크
+ GitHub 리포지토리가 아닙니다
+ 앱 ID
+ org.ppsspp.PPSSPP
+ 유효한 Flathub 앱 ID가 아닙니다
+ 소스
+ 데스크톱에 표시
+ 새 앱
+ 이름
+ 앱에서 가져옴
+ 아이콘
+ 기본 아이콘
+ 아이콘 선택
+ 지우기
+ 리포지토리에서
+ 아이콘 검색 중…
+ 기본값
+ %1$s 편집
+ 저장
+ 폴더 확인 중…
+ 폴더가 세션에 연결되었습니다: %1$s
+ 이 폴더에는 Linux 프로그램이 포함되어 있어 공유 저장 공간에서 실행할 수 없으므로 DroidDeck(%1$s)으로 복사합니다.
+ 추가
+ 취소
+ 먼저 "설정"에서 Linux 런타임을 설치하세요.
+ %1$s이(가) 완료될 때까지 기다려 주세요.
+ 취소
+ 자동
+ 안 함
+ 항상
+ 제거
+ 확인
+ 업데이트
+ 확인 중…
+ 처리 중…
+ 잊기
+ 추가…
+ 사용
+ 다음 세션에 적용됩니다.
+ Steam 세션
+ 데스크톱 세션
+ 디스플레이
+ 해상도
+ 최대 720p
+ 최대 900p
+ 최대 1080p
+ 기본 해상도
+ %1$s(기본값)
+ 사용자 정의 · %1$d×%2$d
+ 사용자 정의…
+ 720p로 설정하면 메뉴 응답 속도가 빨라집니다.
+ 화면 비율
+ 사용자 정의 해상도로 설정됩니다.
+ 자동 모드에서는 최소 16:9를 사용합니다.
+ 프레임 속도 제한
+ 세션 전체의 프레임 속도를 제한합니다. 모니터는 이 상한으로 나누어떨어지는 주사율로 전환됩니다.
+ HDR
+ HDR10 출력
+ 사용 불가: %1$s.
+ 앱을 다시 시작한 후 적용됩니다.
+ 드라이버
+ GPU 드라이버
+ Steam과 데스크톱에서 공유됩니다. "구성 요소" 페이지에서 설정하세요.
+ 터치 및 컨트롤
+ 터치
+ 터치패드
+ 직접 터치
+ 자동: 데스크톱에서는 터치패드, Steam에서는 직접 터치를 사용합니다.
+ 화면 컨트롤
+ Steam + QAM
+ 자동 모드에서는 컨트롤러가 연결되지 않은 경우 화면 컨트롤을 표시합니다.
+ 컨트롤러
+ Steam이 컨트롤러를 인식하는 방식입니다. 다음 세션에 적용됩니다.
+ Steam Deck 컨트롤러
+ Xbox 360 컨트롤러
+ Deck: 빠른 액세스 버튼과 자이로스코프를 제공합니다. Xbox 360: Guide+A로 빠른 액세스를 엽니다.
+ 뒤로
+ 세션
+ 백그라운드 동작
+ 앱이 숨겨지거나 화면이 꺼졌을 때의 동작입니다.
+ 수동
+ 자동 모드에서는 백그라운드에서 일시 중지되고 표시될 때 재개됩니다. 수동 모드에서는 "재개"를 탭해야 합니다. 절대 실행 상태로 유지하지 않습니다.
+ 시작
+ DroidDeck을 열 때 Steam 시작
+ DroidDeck이 시작될 때 Steam 세션을 엽니다.
+ Decky
+ 릴리스 확인 중…
+ %1$s을(를) 설치할 준비가 되었습니다.
+ 호환되는 버전을 찾을 수 없습니다. 나중에 다시 시도하세요.
+ 설치됨 · %1$s
+ 업데이트 있음 · %1$s
+ 최신 버전 · %1$s
+ 로더
+ 최신 버전 설치
+ Steam과 함께 시작됩니다. 활성화하면 이 기기의 다른 앱이 Steam을 제어할 수 있습니다.
+ 끔. Steam의 원격 디버깅 포트가 닫힌 상태로 유지됩니다.
+ Decky Loader를 제거하시겠습니까?
+ 로더를 제거합니다. 플러그인과 설정은 유지됩니다.
+ 클라이언트
+ Steam Deck 모드
+ Steam Deck UI 및 빠른 액세스 성능 제어. 다음 세션에 적용됩니다.
+ 성능 오버레이
+ Deck 모드에서 게임이 충돌하거나 화면이 검게 변하면 이 옵션을 끄세요. 다음 세션에 적용됩니다.
+ 클라이언트 브랜치
+ Steam Deck 베타(Deck 모드에 필요).
+ 다음 세션에 적용됩니다. Steam이 자체적으로 한 번 업데이트될 수 있습니다.
+ 베타
+ Steam Deck 베타
+ Deck 모드는 항상 Steam Deck 베타를 사용합니다.
+ 추가된 게임
+ .exe가 포함된 게임 폴더를 찾을 수 없습니다
+ 게임 폴더
+ 다른 게임 폴더
+ Steam에서 가져온 이미지
+ 폴더 이름을 기준으로 누락된 이미지를 채웁니다. 게임 폴더의 cover.jpg, hero.jpg, logo.png 또는 icon.png가 우선적으로 사용됩니다.
+ %1$s 실행
+ %1$s 실행 · %2$s에 위치
+ 다른 파일 선택…
+ 기본적으로 폴더와 이름이 같은 .exe를 사용하고, 없으면 가장 큰 .exe를 사용합니다.
+ 게임을 늘려 화면 채우기
+ 자체적으로 크기를 조절하는 게임을 전체 화면으로 유지합니다. 게임이 작게 표시되면 이 옵션을 끄세요. 다음 세션에 적용됩니다.
+ 16:9 게임 늘리기
+ 가로세로 비율이 16:9 미만인 화면에서 검은색 여백 대신 게임을 늘려 화면을 채웁니다. 다음 세션에 적용됩니다.
+ 오디오
+ 게임에서 DirectAudio 사용
+ PulseAudio를 우회하여 지연 시간을 줄입니다.
+ Steam 클라이언트 오디오
+ 다음 세션에 적용됩니다.
+ 클래식
+ DirectAudio
+ 마이크
+ 음성 채팅에 사용됩니다.
+ 네트워크
+ Wi-Fi 검색
+ Steam에 Wi-Fi 이름과 주변 네트워크를 표시합니다.
+ 위치 서비스가 꺼져 있습니다.
+ 위치 권한이 부여되지 않았습니다.
+ 설정 열기
+ 계속
+ Wi-Fi 검색을 활성화하시겠습니까?
+ Android는 Wi-Fi 이름을 읽고 주변 네트워크를 검색하려면 위치 권한이 필요합니다. DroidDeck은 이 권한을 사용하여 Steam에 이러한 네트워크를 표시합니다. 위치를 추적하지 않습니다. 이 권한 없이도 인터넷에 액세스할 수 있습니다.
+ 게임 저장 공간
+ 자동 - SD 카드가 있으면 SD 카드 사용
+ 자동 - SD 카드가 있으면 SD 카드 사용(현재 SD 카드 없음)
+ 내부 저장 공간만
+ 폴더: %1$s
+ 보조 라이브러리
+ SD 카드나 공유 저장 공간에서 리소스를 읽는 게임은 끊길 수 있습니다.
+ 폴더 선택…
+ 렌더러
+ 데스크톱 렌더러
+ 데스크톱을 그리는 역할을 합니다.
+ vulkan - GPU
+ gles2 - GPU(실험적)
+ pixman - 소프트웨어
+ Vulkan은 GPU를 사용하여 데스크톱 프로그램을 실행하고, 실패하면 pixman으로 대체합니다. pixman을 사용할 때도 게임은 GPU에서 전체 화면으로 실행됩니다.
+ 사용자 정의 해상도
+ 해상도 상한과 화면 비율을 대체합니다. 화면과 일치하지 않는 크기는 검은색 여백으로 표시됩니다.
+ 너비
+ 높이
+ 범위: 320×240 ~ 3840×2160.
+
+ - 게임 %1$d개
+ - 게임 %1$d개
+
+ 확인
+ 삭제
+ 복원
+ 다운로드
+ %1$s 삭제
+ %1$.1f MB
+ 런타임 드라이버
+ Steam, 게임 및 데스크톱에서 사용됩니다. 다음 세션에 적용됩니다.
+ Turnip zip 가져오기…
+ 디스플레이 드라이버
+ 두 모드 모두에서 화면 출력을 담당합니다. 앱을 다시 시작한 후 적용됩니다.
+ AdrenoTools zip 가져오기…
+ 없음
+ Nightlies 확인 시각 %1$s
+ 구성 요소
+ 구성 요소 정보
+ 새 드라이버 확인
+ Nightlies의 새 패키지 확인
+ Proton
+ Steam 업데이트 시 Valve의 Proton이 교체됩니다. 각 빌드의 원본 파일은 유지됩니다.
+ %1$s · %2$d개 교체됨
+ %1$s · 모두 원본 파일
+ %1$s · 게임 실행 중
+ GPU 드라이버
+ %1$s · %2$s 시작 시 다시 적용됨
+ 다음: %1$s · 게임 종료 후
+ %1$s 사용 중: %2$s
+ 게임 종료 대기 중
+ 다음 게임 실행 시 적용됩니다
+ .zip 가져오기
+ Proton 읽는 중…
+ Proton이 설치되지 않았습니다. Steam을 한 번 실행하여 ARM64 Proton을 다운로드하거나 "설정"에서 GE-Proton 또는 CachyOS를 추가하세요.
+ 원본 · %1$s
+ %1$s · 현재 빌드
+ %1$s · 이전 빌드
+ 설치됨 · %1$d
+ %1$s에 대해 아직 저장된 내용이 없습니다. 이 Proton에 포함된 파일이 원본 파일로 저장됩니다.
+ 현재 이 Proton을 사용하는 게임이 있으므로 게임이 종료될 때까지 기다려야 합니다.
+ 다음 게임 실행 시 적용됩니다.
+ %1$s을(를) 교체하시겠습니까?
+ %1$s을(를) %2$s에 넣으시겠습니까? 원본 파일은 계속 저장됩니다. %3$s
+ %1$s을(를) 복원하시겠습니까?
+ %1$s의 원본 파일을 %2$s에 다시 넣으시겠습니까? %3$s
+ 앱에서 이 패키지를 제거합니다. 나중에 다시 다운로드할 수 있습니다.
+ 이 원본 버전을 삭제하시겠습니까?
+ 이 %1$s 원본 버전은 %2$s의 이전 빌드에서 가져온 것입니다. 현재 빌드의 원본 버전은 항상 유지됩니다.
+ Nightlies 내 · %1$d
+ 새로 고쳐 Nightlies의 패키지를 나열합니다.
+ 마지막 확인 이후 새로운 내용이 없습니다.
+ .wcp 가져오기
+ 이 Proton의 원본 파일 복원
+ %1$s의 원본 파일 %2$s을(를) 되돌리시겠습니까?
+ 전환
+ FEX, DXVK 및 VKD3D-Proton: Steam이 게임을 실행하는 데 사용하는 각 Proton용입니다.\n\n설치된 항목을 선택하면 해당 항목으로 교체됩니다. 다음 게임 실행 시 또는 현재 실행 중인 게임이 종료된 후에 적용됩니다.\n\n실행할 때마다 선택 사항을 다시 확인하며, 변경된 경우 복원됩니다. 각 Proton의 원본 파일은 유지되므로 Steam 업데이트로 인해 손실되지 않습니다.
+ 원본
+ 사용 중
+ 신규
+ 저장됨
+ 성능
+ CPU 코어, 세션 수정 및 호스트 이름. 다음 세션에 적용됩니다.
+ Steam 클라이언트 코어
+ Steam의 코어 선택 재정의
+ Steam, UI 도우미 및 gamescope를 아래에서 선택한 코어에 고정합니다.
+ 클라이언트 코어
+ Steam에서 사용하는 코어입니다.
+ 재정의를 켜야 선택할 수 있습니다.
+ 게임 코어
+ 게임 코어
+ 게임에서 사용하는 코어입니다. 모두 선택하면 Android가 자유롭게 스케줄링합니다.
+ 클라이언트 UI
+ GL 멀티스레딩
+ Steam 메뉴 응답 속도를 높일 수 있습니다.
+ Zink: 지연 디스크립터
+ 디스크립터 버퍼가 없는 드라이버에 권장됩니다.
+ GL 오류 검사 건너뛰기
+ 호출별 GL 유효성 검사를 끕니다.
+ gamescope: 실시간 GPU 큐
+ 컴포지터 GPU 작업의 우선순위를 높입니다. 프레임 타임 안정성을 개선할 수 있지만 게임 성능의 일부를 소모합니다.
+ GPU
+ GPU를 최고 클럭으로 유지
+ Adreno에만 해당됩니다. 끊김이 줄어들지만 전력 소모와 발열이 증가합니다.
+ 세션 수정
+ Turnip: sysmem 렌더링
+ Steam과 대부분의 게임이 빨라집니다. Adreno 710/720/722에 필수입니다.
+ Steam의 xalia 도우미 건너뛰기
+ 모든 게임에서 CPU를 사용하는 Proton의 컨트롤러 탐색 도우미를 비활성화합니다.
+ seccomp 없이 proot 실행
+ 일부 커널에서 시스템 호출 누락 오류를 수정할 수 있지만 성능이 저하될 수 있습니다.
+ proot 빠른 경로
+ proot의 seccomp 필터가 필요합니다.
+ 파일 검색이 빨라지고 끊김이 줄어듭니다. 프로그램이 파일을 찾지 못하면 이 옵션을 끄세요.
+ 세션 ID
+ 호스트 이름
+ Steam이 이 기기를 인식하는 이름입니다. 비워 두면 %1$s(으)로 복원됩니다.
+ 영문, 숫자 및 중간 하이픈만 사용할 수 있으며 최대 63자입니다.
+ Android가 이 세션을 종료하도록 설정했습니다
+ 설치됨
+ 다운로드 가능
+ 마지막 확인 이후 새로운 내용이 없습니다.
+ 내장 드라이버 복원
+ 앱 내장 드라이버: 이 작업은 압축이 풀린 파일을 제거하고 해당 드라이버를 숨깁니다. "내장 드라이버 복원"을 사용하여 복원할 수 있습니다.
+ Android + Linux 번들의 절반: 두 부분 모두 제거됩니다. 사용 중인 드라이버는 기본 드라이버로 대체됩니다.
+ 파일이 앱에서 제거됩니다.
+ 파일이 제거됩니다. 사용 중이므로 기본 드라이버로 전환됩니다.
+ 디스플레이
+ 컨트롤
+ 구성 요소
+ 설정
+ %1$s 페이지
+ Steam
+ 데스크톱
+ Steam 메뉴
+ 빠른 액세스
+ 빠른 액세스 메뉴 열기
+ 이전 페이지
+ 다음 페이지
+ 성능 HUD
+ 게임을 늘려 화면 채우기
+ 자동(%1$s)
+ 키보드
+ PC 키보드
+ Android
+ 보조 화면
+ 표시
+ Android 앱
+ 앱 실행
+ 숨기기
+ 표시
+ 실행할 수 있는 앱이 없습니다
+ 세션 동작
+ 즉시 적용되며 이 모드의 향후 세션에도 적용됩니다.
+ 다음 세션
+ 지원
+ 세션 로그
+ 버그 리포트에 첨부
+ 로그 공유
+ 백그라운드
+ 중지
+ 세션을 중지하시겠습니까?
+ 현재 실행 중
+ 현재 Proton으로 실행 중인 게임이 없습니다
+ Proton이 설치되지 않았습니다.
+ 게임 실행 중
+ %1$s 시작 시 다시 적용됨
+ 원본
+ "구성 요소" 페이지에서 다운로드, 가져오기 및 삭제하세요.
+ 완료
+ 처리 필요
+ 처리 중
+ 무선 디버깅의 IP 주소와 포트를 확인하세요. Android에서 기기를 제거한 경우 다시 페어링하세요.
+ 설치
+ 관리
+ 개요
+ 컨트롤러
+ 세션
+ 런처
+ 설정
+ ● 모두 준비됨
+ %1$d/%2$d 준비됨
+ 시스템 검사
+ 기기 지원됨
+ 테스트되지 않은 GPU
+ GPU 지원되지 않음
+ %1$s · %2$s
+ %1$s: %2$s
+ Steam에는 Adreno 드라이버가 필요합니다. %1$s에서 화면이 검게 변할 수 있습니다.
+ Linux 런타임
+ %1$s · %2$d%%
+ 설치되지 않음 · 약 3GB, 첫 게임 실행 시 설치
+ 설치됨
+ %1$s · 업데이트 있음
+ %1$s · 최신 버전
+ 하위 프로세스 제한
+ 켜짐 · Android가 Steam을 종료할 수 있습니다. 제한을 해제하는 데 약 1분이 걸립니다.
+ 설정되지 않음 · Android가 Steam을 종료할 수 있습니다. 제한을 해제하는 데 약 1분이 걸립니다.
+ 확인할 수 없음 · 제한을 해제하는 데 약 1분이 걸립니다.
+ 수정
+ 상세 정보
+ 개발자 옵션
+ 무선 디버깅 사용
+ 다시 확인
+ 제한 켜기
+ Steam 계정
+ %1$s(으)로 로그인됨 · 오프라인 모드
+ %1$s(으)로 로그인됨
+ Play를 탭하여 Steam에 로그인
+ 도구
+ 컨트롤러
+ 컨트롤러 설정을 사용할 수 없습니다.
+ 세션
+ 세션 로그
+ 각 세션 종료 후 저장
+ 최신 세션 로그
+ 저장된 세션 로그
+ 최신 %1$d개 유지
+ 로그 지우기
+ 오프라인 모드
+ 먼저 Steam에 로그인하세요
+ 런처
+ 테마
+ 런처 외관
+ 홈 화면으로 사용
+ DroidDeck을 홈 앱으로 사용할 수 있습니다
+ DroidDeck은 홈 앱으로 제공되지 않습니다
+ 전체 화면
+ Android 상태 표시줄 및 탐색 표시줄 숨기기
+ Android 상태 표시줄 및 탐색 표시줄 표시
+ 기본 홈 앱
+ 홈 앱 선택
+ 선택
+ Linux 앱(베타)
+ Flathub 스토어
+ 메뉴에 표시됩니다. 일부 앱은 실행되지 않을 수 있습니다. 로그는 Download/DroidDeck에 있습니다.
+ Flathub에서 Linux 앱 및 게임 설치
+ 파일
+ 파일 탐색 및 관리
+ Proton 버전
+ ARM64 Proton 빌드 설치
+ 성능
+ CPU 코어 할당
+ ROM 폴더
+ 에뮬레이터 게임 저장 위치
+ 구성 요소
+ FEX, DXVK, VKD3D
+ 컨트롤
+ 키 매핑
+ 발견
+ 검색
+ 설치됨
+ %1$s · %2$d
+ 스토어
+ Flathub · ARM64
+ ● Flatpak 준비됨
+ 먼저 "설정"에서 Linux 런타임을 설치하세요.
+ Flatpak 설정
+ Flatpak을 추가하고 Flathub에 연결합니다(약 20MB). 첫 앱은 런타임도 다운로드합니다.
+ 설정 중…
+ Flatpak
+ 업데이트
+ %1$s · %2$s
+ %1$s · %2$s · %3$d%%
+ 시작 중…
+ 카테고리
+ Flathub에 연결할 수 없습니다. 네트워크 연결을 확인한 후 다시 시도하세요.
+ 다시 시도
+ Flathub 검색
+ Firefox, 게임, 에뮬레이터…
+ 검색
+ 전체
+ 검색 중…
+ 이름으로 검색하거나 카테고리를 선택하세요. 여기에는 ARM64 앱만 표시됩니다.
+ Flathub에 일치하는 ARM64 앱이 없습니다.
+ 결과
+ 업데이트 확인
+ 모두 업데이트(%1$d)
+ ● 모두 최신 버전
+ 앱이 아직 없습니다. "발견" 또는 "검색"에서 찾아보세요.
+ Flatpak을 설정해야 앱을 설치할 수 있습니다.
+ 업데이트 있음 · %1$s
+ 열기
+ 상세 정보
+ 제거
+ 다시 탭하여 제거
+ 설치 중…
+ 설치
+ 먼저 Flatpak 설정
+ 다운로드 %1$s
+ ● 설치됨
+ 이 앱의 Flathub 페이지를 불러올 수 없습니다.
+ Flathub에서 불러오는 중…
+ Flathub에 ARM64 빌드가 없으므로 여기에 설치할 수 없습니다.
+ 스크린샷
+ 정보
+ 앱 ID
+ 라이선스
+ 런타임
+ 설치된 크기
+ %1$s(공유 런타임 별도)
+ 웹사이트
+ 인증됨
+ 업데이트
+ DroidDeck %1$s · %2$s
+ 확인 시각 %1$s
+ 확인하지 않음
+ DroidDeck 자체 업데이트 허용
+ 다음 페이지에서 "이 출처 허용"을 켜고 돌아오세요. 업데이트가 자동으로 계속됩니다.
+ 설정 열기
+ 나중에
+ 서명 다름
+ 제자리 업데이트 불가
+ 이 복사본은 DroidDeck 릴리스 키로 서명되지 않아 직접 덮어쓸 수 없습니다. 제거한 후 전환하세요.
+ 업데이트 있음
+ 설치 불가
+ 전환 가능
+ Stable보다 앞섬
+ Stable보다 앞서 있습니다
+ 이 빌드는 최신 Stable보다 최신입니다. 다음 Stable 릴리스 후 Stable로 전환됩니다.
+ 테스트 종료됨
+ 이 테스트가 종료되었습니다
+ 해당 수정 사항이 병합되었거나 취소되었습니다. 최신 수정 사항은 Preview를 팔로우하세요.
+ 최신 버전
+ 최신 %1$s을(를) 사용 중입니다
+ · %1$s
+ %1$s… %2$d%%
+ %1$s…
+ %1$s 업데이트
+ %1$s 설치
+ Stable %1$s 설치하기
+ Preview 팔로우
+ 업데이트하기 전에 실행 중인 세션을 중지하세요.
+ 접기
+ 더보기
+ DroidDeck %1$s
+ 새 Preview 빌드
+ PR #%1$d 테스트 빌드
+ %1$d MB
+ 업데이트 채널
+ Stable
+ 테스트된 버전, 대부분의 사용자에게 권장
+ %1$s · %2$s
+ Preview
+ Stable 이전의 최신 수정 사항
+ 최신 버전
+ 테스트 빌드
+ 정식 출시 전에 특정 수정 사항을 시험해 보기
+ 현재 없음
+ PR #%1$d
+ 이 DroidDeck 복사본용으로 빌드되지 않음
+ %1$s 업데이트됨
+ PR #%1$d 테스트 버전
+ 얼마 전
+ 방금 전
+
+ - %1$d개 시도 가능
+ - %1$d개 시도 가능
+
+
+ - 빌드 이후 변경 사항 · %1$d개 빌드 뒤처짐
+ - 빌드 이후 변경 사항 · %1$d개 빌드 뒤처짐
+
+
+ - 최근 변경 사항 · %1$d개 빌드
+ - 최근 변경 사항 · %1$d개 빌드
+
+ 변경해야 할 Android 설정 한 가지
+ Steam
+ Android는 백그라운드 프로세스를 많이 시작하는 앱을 중지하지만, Steam은 수십 개의 프로세스를 시작합니다. 이 설정을 변경할 때까지 게임이 오류 메시지 없이 종료될 수 있습니다.
+ 자동으로 수정
+ "하위 프로세스 제한 사용 중지"를 켜고 돌아오세요. 개발자 옵션을 켜 둔 상태로 유지하지 않으면 스위치가 다시 꺼집니다.
+ 개발자 옵션 열기
+ 이 Android 버전에는 해당 스위치가 없으므로 DroidDeck이 무선 디버깅을 통해 수정합니다. 약 1분이 걸리며 PC가 필요하지 않습니다.
+ 무선 디버깅에는 Wi-Fi가 필요합니다. 네트워크는 아무거나 괜찮으며 인터넷은 필요하지 않습니다.
+ 페어링 코드가 알림에 표시됩니다. DroidDeck에 알림을 허용하거나 "다른 방법"을 사용하세요.
+ 알림 허용
+ 설정 → 개발자 옵션 → 무선 디버깅을 열고 켜기
+ "페어링 코드로 기기 페어링" 탭
+ DroidDeck 알림에 페어링 코드 입력
+ 페어링 팝업을 기다리는 중…
+ 팝업을 찾았습니다. 표시된 페어링 코드를 알림에 입력하세요.
+ 상태
+ 2초마다 확인합니다. 이 스위치를 끄면 이 페이지가 자동으로 닫힙니다.
+ 다른 방법
+ 무선 디버깅, 수동 주소 입력, PC ADB
+ 수동 주소 입력, PC ADB, 개발자 옵션
+ 대신 무선 디버깅 사용
+ 일부 ROM에서는 이 스위치를 제공합니다. 개발자 옵션에서 "하위 프로세스"를 검색하세요.
+ 알림 방법이 작동하지 않으면 팝업의 주소와 페어링 코드를 수동으로 입력하세요.
+ 수동으로 주소 입력
+ PC에서 ADB 사용:
+ 명령 복사
+ Android 설정을 어느 화면에서 열지 선택하세요.
+ 메인 화면
+ 페어링됨. 무선 디버깅 포트를 찾는 중…
+ 페어링됨. 설정의 포트를 입력하세요.
+ 기기를 찾았습니다. 설정을 적용하는 중…
+ 자동으로 적용할 수 없습니다. 아래 주소를 확인한 후 다시 시도하세요. %1$s
+ 무선 디버깅
+ 하위 프로세스 제한 업데이트됨
+ 하위 프로세스 제한 변경
+ 옵션이 없으면 무선 디버깅으로 페어링하세요.
+ 페어링됨. 무선 디버깅의 IP 주소와 포트를 확인하세요.
+ 하위 프로세스 제한이 업데이트되었습니다.
+ 개발자 옵션에 하위 프로세스 설정이 없으면 2단계를 사용하세요. 개발자 옵션 → 무선 디버깅 → 페어링 코드로 기기 페어링을 엽니다.
+ 페어링됨. 아래 주소를 사용하거나 무선 디버깅 → IP 주소 및 포트에서 업데이트하세요.
+ 무선 디버깅을 통해 하위 프로세스 제한을 업데이트했습니다.
+ Android에서 제한이 켜져 있음을 확인했습니다.
+ Android에서 제한이 꺼져 있음을 확인했습니다.
+ 2 · 무선 디버깅 페어링
+ 페어링 팝업의 IP 주소 및 포트
+ 페어링 코드(PIN)
+ 6자리 숫자
+ 페어링
+ 2 · 무선 디버깅으로 적용
+ IP 주소 및 포트 연결
+ 다시 페어링
+ 제한 끄기
+ 기타 변경 방법
+ 1 · 개발자 옵션(먼저 시도)
+ "하위 프로세스 제한"을 켭니다.
+ "하위 프로세스 제한"을 끕니다.
+ 3 · PC ADB(최후의 수단)
+ 무선 디버깅을 사용할 수 없을 때만 사용하세요.
+ 3 · PC ADB(최후의 수단)
+ 세션에서 화면 컨트롤을 표시할 때
+ 색상
+ 화면 버튼의 색조
+ 사용자 정의
+ 불투명도
+ %1$d%%
+ 버튼 크기
+ 100%가 표준 크기입니다
+ 스틱 클릭
+ 스틱을 두 번 탭한 후 길게 누르면 L3 또는 R3이 실행됩니다
+ 적응형 스틱
+ 게임 진동
+ Steam 버튼
+ QAM 버튼
+ 키보드 버튼
+ 애니메이션
+ 스틱이 터치한 위치에 나타나며 손을 떼면 숨겨집니다
+ 레이아웃
+ 사용자 정의 위치 저장됨
+ 이 화면에 맞게 조정됨
+ 편집
+ 초기화
+ 키 매핑
+ 각 버튼은 해당하는 원본 입력을 전송합니다
+ %1$d/%2$d개 버튼 다시 매핑됨
+ 구성
+ 컨트롤러 초기화
+ 모든 컨트롤러 설정 및 레이아웃 복원
+ 각 화면 버튼이 게임에 전송할 입력을 설정합니다. "숨기기"를 선택하면 해당 버튼이 제거됩니다.
+ 화면 버튼
+ 기본값
+ 매핑 초기화
+ Android 앱
+ %1$d개 앱
+ 실행 가능한 Android 앱을 찾을 수 없습니다.
+ ● 데스크톱 설치됨
+ 처음 열 때 설치
+ 설치 가능
+ 설치되지 않음.
+ %1$s · 설치되지 않음
+ %1$s 열기
+ 게임
+ ROM 폴더를 선택하세요.
+ RetroArch에서 /root/ROMs로 이동합니다.
+ %1$s개 게임을 ROMs/%2$s에 추가했습니다.
+ %1$s 설치
+ 세션 중지 후 설치
+ 런타임 필요
+ 설치 세부 정보 불러오는 중…
+ 설치 세부 정보를 사용할 수 없습니다. 나중에 다시 시도하세요.
+ 먼저 "설정"에서 Linux 런타임을 설치하세요.
+ 실행 중인 세션을 중지한 후 데스크톱 앱을 설치하세요.
+ %1$s을(를) Linux 데스크톱에 설치합니다.
+ %1$s · %2$d%%
+ 숨기면 데스크톱에서 제거됩니다. 파일은 Linux 런타임에 남아 있습니다.
+ 해당 게임이 더 이상 ROM 폴더에 없습니다.
+ 데스크톱 · %1$s
+ %1$s에서 실행
+ %1$s에도 있음
+ 해당 페이지가 더 이상 존재하지 않습니다. 왼쪽에서 항목을 선택하세요.
+ 데스크톱 열기
+ 설치 및 데스크톱 열기
+ Linux 데스크톱
+ LXQt, Firefox 및 에뮬레이터
+ Steam에서 설치한 게임은 세션 종료 후 여기에 표시됩니다.
+ Steam 실행
+ 실행 설정
+ 실행
+ 게임 파일
+ Proton 접두사
+ 저장 데이터 검색 중…
+ 이름으로 저장 폴더를 찾을 수 없습니다. 내보낼 때 전체 사용자 폴더가 포함됩니다.
+ %1$d개 저장 폴더
+ %1$s · %2$d개 파일 · %3$s
+ %1$d KB
+ 저장 데이터 관리
+ 게임 저장 데이터
+ 저장 데이터 가져오기…
+ GameHub 또는 Winlator 아카이브. 가져오기 전에 현재 저장 데이터를 백업합니다.
+ GameHub 아카이브로 내보내기…
+ GameHub 및 BannerHub에 적합
+ Winlator 아카이브로 내보내기…
+ Winlator, WinNative 및 Bannerlator에 적합
+ 저장 폴더 열기
+ 플레이한 적 없음
+ 런타임 사용 중 · %1$d%%
+ 런타임 사용 중
+ 첫 게임 실행 시 런타임 설치
+ 런타임 업데이트 있음
+ ● 런타임 준비됨
+ 마지막 실행 %1$s
+ 내부 저장 공간
+ 추가된 게임
+ 이 GPU에 가장 적합한 드라이버 조합을 선택하고 최신 상태로 유지합니다
+ 드라이버 조합을 직접 선택
+ 드라이버 확인 중…
+ 아직 나열된 드라이버가 없습니다. 새로 고쳐 드라이버를 찾으세요.
+ 다른 GPU의 드라이버 숨기기
+ 다른 GPU의 드라이버 표시
+ 고급
+ 디스플레이 드라이버와 함께 설정: %1$s에 둘 다 포함됩니다.
+ 런타임 드라이버와 함께 설정: %1$s에 둘 다 포함됩니다.
+ 게임 및 데스크톱에서 사용됩니다.
+ 런타임 기본값
+ 화면 출력을 담당합니다. DroidDeck을 다시 시작한 후 적용됩니다.
+ 자동 - GPU별 선택
+ 다운로드, 가져오기 또는 삭제…
+ 사용 중
+ DroidDeck 내장 드라이버
+ 런타임 드라이버와 디스플레이 드라이버는 일치하는 조합으로 함께 설정됩니다.
+ 이 GPU에 권장: %1$s.
+ 새로 고쳐 이 GPU에 적합한 드라이버를 찾으세요.
+ 권장
+ 사용 불가
+ Linux 런타임
+ Linux 런타임 준비 중
+ 세션
+ 디스플레이 및 오디오 시작 중
+ Steam 클라이언트
+ Steam 및 호환성 도구 확인 중
+ Steam 여는 중
+ Steam의 첫 프레임을 기다리는 중
+ 데스크톱
+ 데스크톱 준비 중
+ 여는 중
+ 첫 프레임을 기다리는 중
+ Steam 시작 중
+ 세션 종료됨
+ %1$d / %2$d 단계
+ Steam 일시 중지됨
+ 그립
+ 왼쪽 터치패드
+ 오른쪽 터치패드
+ 양쪽
+ 보조 화면 컨트롤 닫기
+ Steam 메뉴 열기
+ 왼쪽 · 위
+ 왼쪽 · 아래
+ 오른쪽 · 위
+ 오른쪽 · 아래
+ 클릭
+ 오른쪽 터치패드
+ 왼쪽 터치패드
+ 터치패드
+ 키보드 표시
+ 키보드 숨기기
+ Linux 터미널
+ Linux 세션이 준비되지 않아 터미널을 사용할 수 없습니다.
+ Steam
+ 게임
+ 데스크톱
+ 스토어
+ 구성 요소
+ 앱
+ 설정
+ 업데이트
+ %1$d%%
+ %1$s 재개
+ 각 세션에서 /root/ROMs로 표시됩니다. 내부 저장 공간은 /root/Storage에 있습니다.
+ 선택된 폴더 없음
+ 다음 세션에 적용됩니다. SD 카드를 지원합니다.
+ 폴더 선택
+ 폴더 변경
+ ARM64 Proton 빌드를 설치한 다음 Steam → 속성 → 호환성에서 각 게임에 선택하세요.
+ 실행 중인 세션을 중지한 후 호환성 도구를 설치하거나 제거하세요.
+ 사용 가능한 빌드
+ %1$s 설치됨
+ 이전 요청으로 인한 대기 항목
+ 설치되지 않음
+ 지금 설치
+ 대기 취소
+ Android 키보드
+ 숨기기 ✕
+ %1$s 실행
+ 화면을 선택하세요. 보조 화면: %1$s.
+ 보조 화면을 사용할 수 없습니다.
+ 메인 화면
+ 보조 화면
+ 이전 탭
+ 다음 탭
+ 켜기
+ 전체 %1$d
+ 없음
+ %1$d/%2$d
+ 끄기
+ 하단 화면
+ 다음 게임 실행 시 적용됩니다. 게임의 프로필이 공유 설정을 덮어씁니다.
+ 앱 ID로 다른 게임 선택…
+ 완료
+ 기본값
+ 끔
+ 변경…
+ 변수 변경
+ 기본값으로 복원
+ Proton 게임
+ PIP (픽처 인 픽처)
+ 자동으로 PIP 시작
+ 일시 중지됨
+ 세션이 준비되면 PIP를 사용할 수 있습니다.
+ Android 설정에서 DroidDeck의 PIP 사용을 허용하세요.
+ Android에서 PIP를 열 수 없습니다.
+ 바로 가기
+ 홈 화면에 추가
+ 게임 선택
+ 설치된 게임 스캔 중…
+ 실행 링크 복사
+ 실행 링크 복사됨
+ 이 런처는 바로 가기를 추가할 수 없습니다. "실행 링크 복사"를 대신 사용하세요.
+ 잘못된 게임 실행 링크입니다.
+ 이 게임은 DroidDeck 라이브러리에 없습니다.
+ Steam 게임을 실행하기 전에 현재 세션을 중지하세요.
+ Steam으로 게임을 보낼 수 없습니다. 다시 실행해 보세요.
+ 제거 다시 시도
+ 제거 중
+ 제거 미완료
+ 게임 파일 내보내기
+ 모든 게임 파일을 폴더에 동기화
+ 게임 파일 동기화 중지
+ 프론트엔드 게임 파일용 폴더 선택
+ 게임 파일이 %1$s에 저장되었습니다
+ 프론트엔드 파일
+
diff --git a/app/src/main/res/values-zh/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml
similarity index 100%
rename from app/src/main/res/values-zh/strings.xml
rename to app/src/main/res/values-zh-rCN/strings.xml
diff --git a/app/src/main/res/values-zh-rHK/strings.xml b/app/src/main/res/values-zh-rHK/strings.xml
new file mode 100644
index 0000000000..2ee9ffce31
--- /dev/null
+++ b/app/src/main/res/values-zh-rHK/strings.xml
@@ -0,0 +1,952 @@
+
+
+ DroidDeck
+
+ - 首次運行會下載 Steam。這可能需要幾分鐘。
+ - 默認情況下,離開應用會暫停 Steam;返回時會從上次中斷處繼續。
+ - 你的控制器會顯示為 Xbox 360 手掣。否則,請使用屏幕控制。
+
+
+ - 首次運行會設置桌面。這可能需要幾分鐘。
+ - 默認情況下,離開應用會暫停會話;返回時會從上次中斷處繼續。
+ - 觸摸會像觸控板一樣工作:拖動移動指針,輕點即點擊。
+ - 你的控制器會顯示為 Xbox 360 手掣。否則,請使用屏幕控制。
+
+ 會話
+ 在 Steam 或桌面會話開啟時顯示
+ Steam 正在運行
+ 會話已暫停 - 準備好後點擊繼續
+ 繼續
+ 結束此會話
+ 幀生成
+ 請選擇你要使用的幀生成模式
+ 關閉
+ Win-FG %1$d×
+ LSFG %1$d×
+ LSFG 自適應 %1$d
+ 需要 Steam 上的 Lossless Scaling
+ 在 Steam 中安裝 Lossless Scaling,或導入 Lossless.dll
+ 導入 Lossless.dll…
+ 正在使用 Steam 上的版本
+ 正在使用導入的版本
+ 選擇 Lossless.dll 檔案
+ 已導入 Lossless.dll
+ 這個 Lossless.dll 已經在使用中了
+ 此 Steam 帳號沒有 Lossless Scaling
+ 此檔案不是 Lossless Scaling 的 Lossless.dll
+ 無法從此 Lossless.dll 準備 LSFG
+ LSFG 需要來自 Steam 的 Lossless Scaling,或是導入的 Lossless.dll 檔案
+ LSFG 無法從此 Lossless.dll 準備其着色器
+ %1$s:不支援
+ %1$s:引擎失敗
+ %1$s:需要 Lossless Scaling
+ %1$s %2$s · 正在啟動
+ 一個包含多個子文件夾的文件夾,每個子文件夾對應一個 Windows 遊戲。你在 Steam 上擁有的遊戲會在 Steam 重啟後使用對應的 Steam 項目,其餘遊戲會成為非 Steam 捷徑。
+ 添加一個 Steam 庫,並掃描其中的 Windows 遊戲。已擁有的遊戲會使用對應的 Steam 項目,其餘遊戲會成為非 Steam 捷徑。
+ 「忘記」會在下次會話中移除這些捷徑。但檔案仍保留在磁盤上。
+ 遊戲環境
+ Proton 遊戲的環境變量。
+ 編輯
+ 所有 Proton 遊戲
+ 配置文件
+ Steam 應用 ID
+ 打開
+ 遊戲 %1$s
+ 添加變量
+ 變量名稱
+ 值
+ 儲存
+ 移除
+ 重新繼承
+ 重置此配置文件
+ 對此配置文件取消設置
+ 未設置任何變量。
+ 已繼承
+ 自定義變量
+ 無法加載或儲存。請檢查剩餘儲存空間後重試。
+ 請輸入有效的名稱和值,最多輸入 8192 個字符。
+ 標準 Proton 運行環境不會讀取此變量。
+ 正在加載…
+ D3D12 功能級別覆蓋。12_2 會報告 DirectX 12 Ultimate 能力;不受支援的功能可能會導致失敗。留空以自動檢測。
+ D3D12 着色器模型覆蓋。6_9 需要足夠新的 VKD3D 以及匹配的 GPU 功能。留空以自動檢測。
+ 保持啟用 Mesa 着色器緩存,以減少重複編譯。設置為 false 可啟用緩存。
+ Mesa 着色器緩存的最大大小,例如 1G。緩存越大,佔用的儲存空間越多。
+ D3D12 的 VKD3D 選項。nodxr 會禁用光線追蹤;僅在遊戲需要時使用。
+ 設置為 1 以生成 Proton 診斷日誌。記錄日誌可能降低性能並佔用儲存空間。
+ 設置為 1,使用基於 OpenGL 的 WineD3D 代替 DXVK,用於 D3D9–11 兼容性測試。
+ 設置為 0,為此遊戲禁用 Proton 的手掣導航輔助程序。
+ D3D9–11 的 DXVK 疊加層。fps 顯示幀率;取消設置則隱藏疊加層。
+ 以分號分隔的 DXVK 設置。近期版本使用 dxvk.maxFrameRate 限制幀率;日常遊玩建議使用會話幀率限制器。
+ D3D12 幀率限制。0 表示禁用限制。
+ Mesa OpenGL 多線程。對於 CPU 受限的 OpenGL 遊戲,true 可能有所幫助;請按遊戲分別測試。
+ FEX 預設
+ 下次啟動遊戲時生效。
+ 遊戲
+ FEX 默認
+ 使用 FEX 默認設置。
+ 穩定
+ 最安全、最慢的設置。
+ 兼容
+ 完整 TSO + multiblock。
+ 中等
+ 均衡的 TSO 設置,並降低 x87 精度。
+ 性能
+ 禁用全部 TSO;啟用 multiblock。
+ 性能 + TSO
+ 性能設置,並啟用主 TSO。
+ 極致
+ 禁用自修改代碼檢查。JIT 遊戲和 DRM 可能無法運行。
+ 極致 + TSO
+ 極致設置,並啟用主 TSO。
+ 極致-gn
+ 性能設置,啟用 TSC 和元數據提示。建議先嘗試此模式,再使用「極致」。
+ Denuvo
+ 性能設置,啟用完整代碼檢查並隱藏虛擬機監控程序位。
+ 自定義值
+ 選擇值
+ 模擬器和應用
+ 添加
+ 你自己的應用或遊戲
+ 腳本
+ AppImage
+ Flatpak
+ %1$s · %2$s
+ %1$s · %2$s · %3$d%%
+ 正在啟動…
+ 已添加 %1$s
+ 已移除 %1$s
+ 桌面
+ 該應用已不存在。請從桌面重新選擇。
+ 打開 %1$s
+ 移除
+ 再次點擊以移除
+ 請先結束會話再移除
+ 從其所在文件夾運行 %1$s,並將該文件夾鏈接到所在的會話中。移除應用不會影響該文件夾。
+ 從複製到 DroidDeck 內部的文件夾中運行 %1$s。移除應用會刪除副本,不會刪除原檔案。
+ 請先安裝 Linux 運行環境
+ 檔案已不存在
+ 可用空間不足:複製該文件夾需要 %1$s
+ 正在複製 %1$s
+ 添加應用失敗
+ 正在查找 %1$s 的發行版本
+ 無法讀取 %1$s 的發行版本
+ %1$s 沒有提供 ARM64 AppImage 的發行版本
+ 正在下載 %1$s
+ 下載失敗
+ 更新應用失敗
+ 無法讀取該圖標
+ 已儲存 %1$s
+ 編輯
+ 檢查更新
+ 正在檢查更新…
+ 更新到 %1$s
+ 已是最新 · %1$s
+ %1$s 已更新
+ %1$s · %2$s
+ 添加應用
+ 腳本
+ AppImage
+ GitHub
+ Flatpak
+ 一個 .sh 檔案。它會從自己的文件夾運行,並通過 gamescope 全屏幕顯示。
+ 一個 ARM64(aarch64)AppImage。首次使用時會將其解包到 Linux 運行環境中。
+ 從倉庫的最新發行版本安裝 ARM64 AppImage。
+ Flathub 應用 ID 或其 Flathub 頁面。如果尚未設置 Flatpak,會先進行設置。
+ 檔案
+ 未選擇檔案
+ 選擇檔案
+ 更改
+ 選擇腳本
+ 選擇 AppImage
+ 選擇圖標
+ 倉庫
+ owner/repo 或 github.com 鏈接
+ 不是 GitHub 倉庫
+ 應用 ID
+ org.ppsspp.PPSSPP
+ 不是有效的 Flathub 應用 ID
+ 來源
+ 顯示在桌面
+ 新應用
+ 名稱
+ 來自應用
+ 圖標
+ 默認圖標
+ 選擇圖標
+ 清除
+ 來自倉庫
+ 正在查找圖標…
+ 默認
+ 編輯 %1$s
+ 儲存
+ 正在檢查文件夾…
+ 其文件夾已鏈接到會話中:%1$s
+ 該文件夾包含 Linux 程序,共享儲存無法運行這些程序,因此會將其複製到 DroidDeck(%1$s)。
+ 添加
+ 取消
+ 請先從「設定」中安裝 Linux 運行環境。
+ 請等待 %1$s 完成。
+ 取消
+ 自動
+ 從不
+ 始終
+ 卸載
+ 檢查
+ 更新
+ 正在檢查…
+ 處理中…
+ 忘記
+ 添加…
+ 使用
+ 下次會話生效。
+ Steam 會話
+ 桌面會話
+ 顯示
+ 分辨率
+ 最高 720p
+ 最高 900p
+ 最高 1080p
+ 原生
+ %1$s(默認)
+ 自定義 · %1$d×%2$d
+ 自定義…
+ 720p 可以讓菜單響應更快。
+ 屏幕比例
+ 由自定義分辨率設置。
+ 自動模式至少使用 16:9。
+ 幀率限制
+ 限制整個會話的幀率。顯示器會切換到能夠被該上限整除的刷新率。
+ HDR
+ HDR10 輸出
+ 不可用:%1$s。
+ 重啟應用後生效。
+ 驅動
+ GPU 驅動
+ Steam 和桌面共用。請在「組件」頁面設置。
+ 觸控與控制
+ 觸控
+ 觸控板
+ 直接
+ 自動:桌面使用觸控板,Steam 使用直接觸控。
+ 屏幕控制
+ Steam + QAM
+ 自動模式會在未連接控制器時顯示屏幕控制。
+ 控制器
+ Steam 識別你的控制器的方式。下次會話生效。
+ Steam Deck 控制器
+ Xbox 360 控制器
+ Deck:提供快速訪問按鈕和陀螺儀。Xbox 360:使用 Guide+A 打開快速訪問。
+ 返回
+ 會話
+ 後台行為
+ 應用隱藏或屏幕關閉時的行為。
+ 手動
+ 自動模式會在後台暫停,並在顯示時恢復。手動模式需點擊「繼續」。從不保持運行。
+ 啟動
+ 在 DroidDeck 打開時啟動 Steam
+ DroidDeck 啟動時打開 Steam 會話。
+ Decky
+ 正在檢查發行版本…
+ 已準備好安裝 %1$s。
+ 未找到兼容版本。請稍後再試。
+ 已安裝 · %1$s
+ 有可用更新 · %1$s
+ 已是最新 · %1$s
+ 加載器
+ 安裝最新版本
+ 隨 Steam 啟動。啟用後,此設備上的其他應用可能可以控制 Steam。
+ 關閉。Steam 的遠程調試端口保持關閉。
+ 卸載 Decky Loader?
+ 移除加載器。你的插件和設置會保留。
+ 客戶端
+ Steam Deck 模式
+ Steam Deck 界面和快速訪問性能控制。下次會話生效。
+ 性能疊加層
+ 如果 Deck 模式下遊戲崩潰或黑屏,請關閉此項。下次會話生效。
+ 客戶端分支
+ Steam Deck 公測版(Deck 模式所需)。
+ 下次會話生效。Steam 可能會自行更新一次。
+ 公測版
+ Steam Deck 公測版
+ Deck 模式始終使用 Steam Deck 公測版。
+ 已添加的遊戲
+ 未找到包含 .exe 的遊戲文件夾
+ 遊戲文件夾
+ 另一個遊戲文件夾
+ 來自 Steam 的圖片
+ 按文件夾名稱補全缺失的圖片。遊戲文件夾中的 cover.jpg、hero.jpg、logo.png 或 icon.png 優先使用。
+ 啟動 %1$s
+ 啟動 %1$s · 位於 %2$s
+ 選擇其他檔案…
+ 默認使用與文件夾同名的 .exe,否則使用最大的 .exe。
+ 拉伸遊戲以填滿屏幕
+ 讓支持自行調整大小的遊戲保持全屏幕。如果遊戲顯示得很小,請關閉此項。下次會話生效。
+ 拉伸 16:9 遊戲
+ 在寬高比小於 16:9 的屏幕上,將遊戲拉伸以填滿屏幕,而不是顯示黑邊。下次會話生效。
+ 音頻
+ 遊戲使用 DirectAudio
+ 繞過 PulseAudio 以降低延遲。
+ Steam 客戶端音頻
+ 下次會話生效。
+ 經典
+ DirectAudio
+ 麥克風
+ 用於語音聊天。
+ 網絡
+ Wi-Fi 發現
+ 在 Steam 中顯示 Wi-Fi 名稱和附近的網絡。
+ 位置信息服務已關閉。
+ 未授予位置信息權限。
+ 打開設定
+ 繼續
+ 啟用 Wi-Fi 發現?
+ Android 需要位置信息權限才能讀取 Wi-Fi 名稱並發現附近網絡。DroidDeck 使用此權限在 Steam 中顯示這些網絡。我們不會追蹤你的位置。沒有此權限也可以訪問互聯網。
+ 遊戲儲存
+ 自動 - 有 SD 卡時使用 SD 卡
+ 自動 - 有 SD 卡時使用 SD 卡(當前無 SD 卡)
+ 僅內部儲存
+ 文件夾:%1$s
+ 第二庫
+ 從 SD 卡或共享儲存讀取資源的遊戲可能會卡頓。
+ 選擇文件夾…
+ 渲染器
+ 桌面渲染器
+ 負責繪製桌面。
+ vulkan - GPU
+ gles2 - GPU(實驗性)
+ pixman - 軟件
+ Vulkan 使用 GPU 運行桌面程序,失敗時回退到 pixman。使用 pixman 時,遊戲仍會在 GPU 上全屏幕運行。
+ 自定義分辨率
+ 替換分辨率上限和屏幕比例。不匹配屏幕的尺寸會顯示黑邊。
+ 寬度
+ 高度
+ 範圍:320×240 至 3840×2160。
+
+ - %1$d 個遊戲
+ - %1$d 個遊戲
+
+ 確定
+ 刪除
+ 恢復
+ 下載
+ 刪除 %1$s
+ %1$.1f MB
+ 運行環境驅動
+ 供 Steam、遊戲和桌面使用。下次會話生效。
+ 導入 Turnip zip…
+ 顯示驅動
+ 在兩種模式下都負責將畫面輸出到屏幕。重啟應用後生效。
+ 導入 AdrenoTools zip…
+ 從未
+ Nightlies 已檢查於 %1$s
+ 組件
+ 關於組件
+ 檢查新驅動
+ 檢查 Nightlies 中的新軟件包
+ Proton
+ Steam 更新時會替換 Valve 的 Proton;每個構建版本的原始檔案都會保留。
+ %1$s · 已替換 %2$d 個
+ %1$s · 全部為原始檔案
+ %1$s · 遊戲運行中
+ GPU 驅動
+ %1$s · 已在啟動 %2$s 時重新應用
+ 下一項:%1$s · 遊戲關閉後
+ 正在使用 %1$s:%2$s
+ 等待遊戲關閉
+ 下次啟動遊戲時生效
+ 導入 .zip
+ 正在讀取 Proton…
+ 尚未安裝 Proton。啟動一次 Steam 以下載其 ARM64 Proton,或從「設定」中添加 GE-Proton 或 CachyOS。
+ 原始 · %1$s
+ %1$s · 當前構建
+ %1$s · 較早構建
+ 已安裝 · %1$d
+ 尚未為 %1$s 儲存任何內容。此 Proton 自帶的檔案會作為其原始檔案儲存。
+ 當前有遊戲正在使用此 Proton,因此需要等遊戲關閉。
+ 下次啟動遊戲時生效。
+ 替換 %1$s?
+ 將 %1$s 放入 %2$s?其原始檔案會繼續儲存。%3$s
+ 恢復 %1$s?
+ 將 %1$s 的原始檔案放回 %2$s?%3$s
+ 從應用中移除該軟件包。之後可以再次下載。
+ 刪除這個原始版本?
+ 這個 %1$s 原始版本來自 %2$s 的較早構建。當前構建的原始版本始終會保留。
+ Nightlies 中 · %1$d
+ 刷新以列出 Nightlies 中的軟件包。
+ 自上次檢查以來沒有新內容。
+ 導入 .wcp
+ 恢復此 Proton 的原始檔案
+ 將 %1$s 的原始檔案 %2$s 放回?
+ 切換
+ FEX、DXVK 和 VKD3D-Proton:針對 Steam 用來運行遊戲的每個 Proton。\n\n選擇一個已安裝項即可將其換入。它會在下次遊戲啟動時生效,或在當前運行的遊戲關閉後生效。\n\n每次啟動前都會重新檢查你的選擇;如果它們被改動過,就會恢復。每個 Proton 的原始檔案都會保留,因此 Steam 更新絕不會丟失它們。
+ 原始
+ 使用中
+ 新
+ 已儲存
+ 性能
+ CPU 核心、會話修復和主機名。下次會話生效。
+ Steam 客戶端核心
+ 覆蓋 Steam 的核心選擇
+ 將 Steam、界面輔助程序和 gamescope 固定到下面選擇的核心。
+ 客戶端核心
+ 供 Steam 使用的核心。
+ 開啟覆蓋後才能選擇。
+ 遊戲核心
+ 遊戲核心
+ 供遊戲使用的核心。全選時由 Android 自由調度。
+ 客戶端界面
+ GL 多線程
+ 可能讓 Steam 菜單響應更快。
+ Zink:延遲描述符
+ 推薦用於沒有描述符緩衝區的驅動。
+ 跳過 GL 錯誤檢查
+ 關閉逐調用 GL 驗證。
+ gamescope:實時 GPU 隊列
+ 提高合成器 GPU 工作的優先級。可能改善幀時間穩定性,但會佔用一部分遊戲性能。
+ GPU
+ 讓 GPU 保持最高頻率
+ 僅適用於 Adreno。卡頓更少,但耗電和發熱更多。
+ 會話修復
+ Turnip:sysmem 渲染
+ Steam 和大多數遊戲會更快。Adreno 710/720/722 必需。
+ 跳過 Steam 的 xalia 輔助程序
+ 禁用 Proton 的手掣導航輔助程序,該程序會在每個遊戲中佔用 CPU。
+ 在不使用 seccomp 的情況下運行 proot
+ 可能修復某些內核上的系統調用缺失錯誤,但可能降低性能。
+ proot 快速路徑
+ 需要 proot 的 seccomp 過濾器。
+ 檔案查找更快、卡頓更少。如果程序找不到檔案,請關閉此項。
+ 會話身份
+ 主機名
+ Steam 為此設備看到的名稱。留空可恢復為 %1$s。
+ 只能包含字母、數字和中間的連字符,最多 63 個字符。
+ Android 已設置為結束此會話
+ 已安裝
+ 可下載
+ 自上次檢查以來沒有新內容。
+ 恢復內置驅動
+ 應用內置驅動:此操作會移除已解包的文件並隱藏該驅動。使用「恢復內置驅動」可將其恢復。
+ Android + Linux 捆綁包的一半:兩部分都會被移除。正在使用的驅動會回退到默認驅動。
+ 其檔案會從應用中移除。
+ 其檔案會被移除。由於正在使用中,因此會改用默認驅動。
+ 顯示
+ 控制
+ 組件
+ 設定
+ %1$s 頁面
+ Steam
+ 桌面
+ Steam 菜單
+ 快速訪問
+ 打開快速訪問菜單
+ 上一頁
+ 下一頁
+ 性能 HUD
+ 拉伸遊戲以填滿屏幕
+ 自動(%1$s)
+ 鍵盤
+ 電腦鍵盤
+ Android
+ 第二屏幕
+ 顯示
+ Android 應用
+ 啟動應用
+ 隱藏
+ 顯示
+ 沒有可啟動的應用
+ 會話行為
+ 立即應用,並對該模式未來的會話生效。
+ 下次會話
+ 支援
+ 會話日誌
+ 附加到錯誤報告
+ 分享日誌
+ 後台
+ 停止
+ 停止會話?
+ 當前正在運行
+ 當前沒有使用 Proton 運行的遊戲
+ 尚未安裝 Proton。
+ 遊戲運行中
+ 已在啟動 %1$s 時重新應用
+ 原始
+ 請在「組件」頁面下載、導入和刪除。
+ 完成
+ 需要處理
+ 處理中
+ 請檢查無線調試的 IP 地址和端口;如果 Android 已移除該設備,請重新配對。
+ 安裝
+ 管理
+ 概覽
+ 控制器
+ 會話
+ 啟動器
+ 設定
+ ● 全部就緒
+ %1$d/%2$d 已就緒
+ 系統檢查
+ 設備受支援
+ 未經測試的 GPU
+ GPU 不受支援
+ %1$s · %2$s
+ %1$s:%2$s
+ Steam 需要 Adreno 驅動;%1$s 可能出現黑屏。
+ Linux 運行環境
+ %1$s · %2$d%%
+ 未安裝 · 約 3 GB,首次運行遊戲時安裝
+ 已安裝
+ %1$s · 有可用更新
+ %1$s · 已是最新
+ 子進程限制
+ 已開啟 · Android 可能會關閉 Steam。關閉該限制需要約一分鐘。
+ 未設置 · Android 可能會關閉 Steam。關閉該限制需要約一分鐘。
+ 無法檢查 · 關閉該限制需要約一分鐘。
+ 修復
+ 詳情
+ 開發者選項
+ 使用無線調試
+ 重新檢查
+ 開啟限制
+ Steam 帳號
+ 已登錄為 %1$s · 離線模式
+ 已登錄為 %1$s
+ 點擊 Play 並登錄 Steam
+ 工具
+ 控制器
+ 控制器設定不可用。
+ 會話
+ 會話日誌
+ 每次會話結束後儲存
+ 最新會話日誌
+ 已儲存的會話日誌
+ 保留最新的 %1$d 個
+ 清除日誌
+ 離線模式
+ 請先登錄 Steam
+ 啟動器
+ 主題
+ 啟動器外觀
+ 用作主屏幕
+ DroidDeck 可以作為主屏幕應用
+ DroidDeck 不會作為主屏幕應用提供
+ 全屏幕
+ 隱藏 Android 狀態欄和導航欄
+ 顯示 Android 狀態欄和導航欄
+ 默認主屏幕應用
+ 選擇主屏幕應用
+ 選擇
+ Linux 應用(測試版)
+ Flathub 商店
+ 顯示在菜單中。部分應用可能無法啟動;日誌位於 Download/DroidDeck。
+ 從 Flathub 安裝 Linux 應用和遊戲
+ 檔案
+ 瀏覽和管理檔案
+ Proton 版本
+ 安裝 ARM64 Proton 構建版本
+ 性能
+ CPU 核心分配
+ ROM 文件夾
+ 模擬器遊戲的儲存位置
+ 組件
+ FEX、DXVK、VKD3D
+ 控制
+ 按鍵映射
+ 發現
+ 搜索
+ 已安裝
+ %1$s · %2$d
+ 商店
+ Flathub · ARM64
+ ● Flatpak 已就緒
+ 請先從「設定」中安裝 Linux 運行環境。
+ 設置 Flatpak
+ 添加 Flatpak 並連接到 Flathub(約 20 MB)。第一個應用還會下載其運行環境。
+ 正在設置…
+ Flatpak
+ 更新
+ %1$s · %2$s
+ %1$s · %2$s · %3$d%%
+ 正在啟動…
+ 分類
+ 無法連接到 Flathub。請檢查網絡連接後重試。
+ 重試
+ 搜索 Flathub
+ Firefox、遊戲、模擬器…
+ 搜索
+ 全部
+ 正在搜索…
+ 按名稱搜索或選擇分類。這裡只列出 ARM64 應用。
+ Flathub 上沒有匹配的 ARM64 應用。
+ 結果
+ 檢查更新
+ 全部更新(%1$d)
+ ● 全部已是最新版本
+ 還沒有應用。請在「發現」或「搜索」中查找。
+ 設置 Flatpak 後才能安裝應用。
+ 有可用更新 · %1$s
+ 打開
+ 詳情
+ 移除
+ 再次點擊以移除
+ 正在安裝…
+ 安裝
+ 先設置 Flatpak
+ 下載 %1$s
+ ● 已安裝
+ 無法加載此應用的 Flathub 頁面。
+ 正在從 Flathub 加載…
+ Flathub 沒有 ARM64 構建版本,因此無法在此安裝。
+ 截圖
+ 關於
+ 應用 ID
+ 許可證
+ 運行環境
+ 已安裝大小
+ %1$s(另加共享運行環境)
+ 網站
+ 已驗證
+ 更新
+ DroidDeck %1$s · %2$s
+ 已檢查 %1$s
+ 尚未檢查
+ 允許 DroidDeck 自行更新
+ 在下一頁開啟「允許來自此來源」,然後返回。更新會自動繼續。
+ 打開設定
+ 暫時不要
+ 簽名不同
+ 無法原地更新
+ 此副本使用的不是 DroidDeck 發佈密鑰簽名,因此無法直接覆蓋更新。請卸載後切換。
+ 有可用更新
+ 無法安裝
+ 可以切換
+ 領先 Stable
+ 你領先於 Stable
+ 此構建版本比最新 Stable 更新。下一個 Stable 版本發佈後,你將切換到 Stable。
+ 測試已結束
+ 此測試已結束
+ 該修復已合併或被放棄。請關注 Preview 以獲取最新修復。
+ 已是最新
+ 你已擁有最新的 %1$s
+ · %1$s
+ %1$s… %2$d%%
+ %1$s…
+ 更新 %1$s
+ 安裝 %1$s
+ 仍要安裝 Stable %1$s
+ 關注 Preview
+ 請停止正在運行的會話後再更新。
+ 收起
+ 更多
+ DroidDeck %1$s
+ 新的 Preview 構建版本
+ PR #%1$d 測試構建版本
+ %1$d MB
+ 更新頻道
+ Stable
+ 經過測試的版本,適合大多數人
+ %1$s · %2$s
+ Preview
+ Stable 之前的最新修復
+ 已是最新
+ 測試構建版本
+ 在正式發佈前嘗試某個修復
+ 目前沒有
+ PR #%1$d
+ 未為此 DroidDeck 副本構建
+ 已更新 %1$s
+ PR #%1$d 測試版
+ 不久前
+ 剛剛
+
+ - %1$d 個可嘗試
+ - %1$d 個可嘗試
+
+
+ - 自你的構建版本以來的更改 · 落後 %1$d 個構建
+ - 自你的構建版本以來的更改 · 落後 %1$d 個構建
+
+
+ - 近期更改 · %1$d 個構建
+ - 近期更改 · %1$d 個構建
+
+ 需要更改的一項 Android 設置
+ Steam
+ Android 會停止那些啟動大量後台程序的應用,而 Steam 會啟動幾十個程序。在更改此設置前,遊戲可能會在沒有錯誤提示的情況下關閉。
+ 幫我修復
+ 開啟「停用子進程限制」,然後返回。請保持開發者選項開啟,否則該開關會再次關閉。
+ 打開開發者選項
+ 此 Android 版本沒有該開關,因此 DroidDeck 會通過無線調試進行修改。大約需要一分鐘,無需電腦。
+ 無線調試需要 Wi-Fi。任何網絡都可以,不需要互聯網。
+ 配對碼會顯示在通知中。請允許 DroidDeck 發送通知,或使用「其他方式」。
+ 允許通知
+ 打開設定 → 開發者選項 → 無線調試,並將其開啟
+ 點擊「使用配對碼配對設備」
+ 將配對碼輸入 DroidDeck 通知中
+ 正在等待配對彈窗…
+ 已找到彈窗。請將其上的配對碼輸入通知。
+ 狀態
+ 每 2 秒檢查一次。關閉此開關後此頁面會自動關閉。
+ 其他方式
+ 無線調試、手動輸入地址、電腦 ADB
+ 手動輸入地址、電腦 ADB、開發者選項
+ 改用無線調試
+ 部分 ROM 仍會提供此開關。請在開發者選項中搜索「子進程」。
+ 如果通知方式不起作用,請手動輸入彈窗中的地址和配對碼。
+ 手動輸入地址
+ 使用電腦上的 ADB:
+ 複製命令
+ 選擇在哪個屏幕上打開 Android 設定。
+ 主屏幕
+ 已配對。正在查找無線調試端口…
+ 已配對。請輸入設定中的端口。
+ 已找到設備。正在應用設置…
+ 無法自動應用。請檢查下面的地址後重試。 %1$s
+ 無線調試
+ 子進程限制已更新
+ 更改子進程限制
+ 如果沒有該選項,請通過無線調試進行配對。
+ 已配對。請檢查無線調試中的 IP 地址和端口。
+ 子進程限制已更新。
+ 如果開發者選項中沒有子進程設置,請使用步驟 2。打開開發者選項 → 無線調試 → 使用配對碼配對設備。
+ 已配對。請使用下面的地址,或在無線調試 → IP 地址和端口 中更新它。
+ 已通過無線調試更新子進程限制。
+ Android 已確認限制處於開啟狀態。
+ Android 已確認限制處於關閉狀態。
+ 2 · 配對無線調試
+ 配對彈窗中的 IP 地址和端口
+ 配對碼(PIN)
+ 6 位數字
+ 配對
+ 2 · 通過無線調試應用
+ 連接 IP 地址和端口
+ 重新配對
+ 關閉限制
+ 其他更改方式
+ 1 · 開發者選項(優先嘗試)
+ 開啟「限制子進程」。
+ 關閉「限制子進程」。
+ 3 · 電腦 ADB(最後手段)
+ 僅在無線調試不可用時使用。
+ 3 · 電腦 ADB(最後手段)
+ 會話中顯示屏幕控制時
+ 顏色
+ 屏幕按鍵的色調
+ 自定義
+ 不透明度
+ %1$d%%
+ 按鍵大小
+ 100% 為標準大小
+ 搖桿點擊
+ 雙擊並長按搖桿可觸發 L3 或 R3
+ 自適應搖桿
+ 遊戲振動
+ Steam 按鈕
+ QAM 按鈕
+ 鍵盤按鈕
+ 動畫
+ 搖桿會出現在你觸摸的位置,並在鬆開後隱藏
+ 佈局
+ 已儲存自定義位置
+ 已適配此屏幕
+ 編輯
+ 重置
+ 按鍵映射
+ 每個按鍵發送對應的原始輸入
+ %1$d/%2$d 個按鍵已重新映射
+ 配置
+ 重置控制器
+ 恢復所有控制器設定和佈局
+ 設置每個屏幕按鍵向遊戲發送的輸入。「隱藏」會移除該按鍵。
+ 屏幕按鍵
+ 默認值
+ 重置映射
+ Android 應用
+ %1$d 個應用
+ 沒有找到可啟動的 Android 應用。
+ ● 桌面已安裝
+ 首次打開時安裝
+ 可安裝
+ 未安裝。
+ %1$s · 未安裝
+ 打開 %1$s
+ 遊戲
+ 選擇 ROM 文件夾。
+ 在 RetroArch 中瀏覽到 /root/ROMs。
+ 將 %1$s 個遊戲添加到 ROMs/%2$s。
+ 安裝 %1$s
+ 停止會話後安裝
+ 需要運行環境
+ 正在加載安裝詳情…
+ 安裝詳情不可用。請稍後重試。
+ 請先從「設定」中安裝 Linux 運行環境。
+ 請停止正在運行的會話後再安裝桌面應用。
+ 將 %1$s 安裝到 Linux 桌面。
+ %1$s · %2$d%%
+ 隱藏後會從桌面移除。檔案仍保留在 Linux 運行環境中。
+ 該遊戲已不在 ROM 文件夾中。
+ 桌面 · %1$s
+ 在 %1$s 中啟動
+ 也位於 %1$s
+ 該頁面已不存在。請從左側選擇一個欄目。
+ 打開桌面
+ 安裝並打開桌面
+ Linux 桌面
+ LXQt、Firefox 和你的模擬器
+ 在 Steam 中安裝的遊戲會在會話結束後顯示在這裡。
+ 運行 Steam
+ 啟動設置
+ 啟動
+ 遊戲檔案
+ Proton 前綴
+ 正在查找存檔…
+ 未按名稱找到存檔文件夾。導出時會包含整個用戶文件夾。
+ %1$d 個存檔文件夾
+ %1$s · %2$d 個檔案 · %3$s
+ %1$d KB
+ 管理存檔
+ 遊戲存檔
+ 導入存檔…
+ GameHub 或 Winlator 壓縮包。導入前會先備份當前存檔。
+ 導出為 GameHub 壓縮包…
+ 適用於 GameHub 和 BannerHub
+ 導出為 Winlator 壓縮包…
+ 適用於 Winlator、WinNative 和 Bannerlator
+ 打開存檔文件夾
+ 從未運行
+ 運行環境繁忙 · %1$d%%
+ 運行環境繁忙
+ 首次運行遊戲時安裝運行環境
+ 運行環境有可用更新
+ ● 運行環境已就緒
+ 上次運行 %1$s
+ 內部儲存
+ 已添加的遊戲
+ 為此 GPU 選擇最佳驅動組合,並保持最新
+ 自行選擇驅動組合
+ 正在檢查驅動…
+ 尚未列出驅動。刷新以查找驅動。
+ 隱藏其他 GPU 的驅動
+ 顯示其他 GPU 的驅動
+ 高級
+ 與顯示驅動一起設置:%1$s 同時包含兩者。
+ 與運行環境驅動一起設置:%1$s 同時包含兩者。
+ 供遊戲和桌面使用。
+ 運行環境默認
+ 負責將畫面輸出到屏幕。重啟 DroidDeck 後生效。
+ 自動 - 按 GPU 選擇
+ 下載、導入或刪除…
+ 正在使用
+ DroidDeck 內置驅動
+ 運行環境驅動和顯示驅動作為匹配組合一起設置。
+ 推薦用於此 GPU:%1$s。
+ 刷新以查找適用於此 GPU 的驅動。
+ 推薦
+ 不可用
+ Linux 運行環境
+ 正在準備 Linux 運行環境
+ 會話
+ 正在啟動顯示和音頻
+ Steam 客戶端
+ 正在檢查 Steam 及其兼容工具
+ 正在打開 Steam
+ 正在等待 Steam 的第一幀畫面
+ 桌面
+ 正在準備桌面
+ 正在打開
+ 正在等待第一幀畫面
+ 正在啟動 Steam
+ 會話已結束
+ 第 %1$d 步,共 %2$d 步
+ Steam 已暫停
+ 握把
+ 左側觸控板
+ 右側觸控板
+ 兩側
+ 關閉第二屏幕控制
+ 打開 Steam 菜單
+ 左側 · 上方
+ 左側 · 下方
+ 右側 · 上方
+ 右側 · 下方
+ 點擊
+ 右側觸控板
+ 左側觸控板
+ 觸控板
+ 顯示鍵盤
+ 隱藏鍵盤
+ Linux 終端
+ Linux 會話尚未準備好,無法使用終端。
+ Steam
+ 遊戲
+ 桌面
+ 商店
+ 組件
+ 應用
+ 設定
+ 更新
+ %1$d%%
+ 繼續 %1$s
+ 每個會話中顯示為 /root/ROMs。內部儲存位於 /root/Storage。
+ 未選擇文件夾
+ 下次會話生效。支援 SD 卡。
+ 選擇文件夾
+ 更改文件夾
+ 安裝 ARM64 Proton 構建版本,然後在 Steam → 屬性 → 兼容性中為每個遊戲選擇。
+ 請停止正在運行的會話後再安裝或移除兼容工具。
+ 可用構建版本
+ 已安裝 %1$s
+ 上一次請求留下的待處理項
+ 未安裝
+ 立即安裝
+ 取消排隊
+ Android 鍵盤
+ 隱藏 ✕
+ 啟動 %1$s
+ 選擇屏幕。副屏:%1$s。
+ 副屏已不可用。
+ 主屏幕
+ 副屏
+ 上一個標籤頁
+ 下一個標籤頁
+ 開啟
+ 全部 %1$d
+ 無
+ %1$d/%2$d
+ 關閉
+ 底部屏幕
+ 下次啟動遊戲時生效。遊戲的配置文件會覆蓋共享配置。
+ 按應用 ID 選擇其他遊戲…
+ 完成
+ 默認
+ 關閉
+ 更改…
+ 更改變量
+ 恢復默認
+ Proton 遊戲
+ 畫中畫
+ 自動進入畫中畫
+ 已暫停
+ 會話準備就緒後即可使用畫中畫。
+ 請在 Android 設定中允許 DroidDeck 使用畫中畫。
+ Android 無法打開畫中畫。
+ 捷徑
+ 添加到主屏幕
+ 選擇遊戲
+ 正在掃描已安裝的遊戲…
+ 複製啟動鏈接
+ 已複製啟動鏈接
+ 此啟動器無法添加捷徑。請改用「複製啟動鏈接」。
+ 無效的遊戲啟動鏈接。
+ 此遊戲已不在你的 DroidDeck 遊戲庫中。
+ 啟動 Steam 遊戲前請停止當前會話。
+ 無法將遊戲發送到 Steam。請再次嘗試啟動。
+ 重試移除
+ 正在移除
+ 移除未完成
+ 導出遊戲檔案
+ 將所有遊戲檔案同步到文件夾
+ 停止同步遊戲檔案
+ 為前端遊戲檔案選擇文件夾
+ 遊戲檔案已儲存到 %1$s
+ 前端檔案
+
\ No newline at end of file
diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml
new file mode 100644
index 0000000000..0f5df100ed
--- /dev/null
+++ b/app/src/main/res/values-zh-rTW/strings.xml
@@ -0,0 +1,952 @@
+
+
+ DroidDeck
+
+ - 首次執行會下載 Steam。這可能需要幾分鐘。
+ - 預設情況下,離開應用程式會暫停 Steam;返回時會從上次中斷處繼續。
+ - 你的控制器會顯示為 Xbox 360 手把。否則,請使用螢幕控制。
+
+
+ - 首次執行會設定桌面。這可能需要幾分鐘。
+ - 預設情況下,離開應用程式會暫停工作階段;返回時會從上次中斷處繼續。
+ - 觸控會像觸控板一樣運作:拖曳移動指標,輕觸即點擊。
+ - 你的控制器會顯示為 Xbox 360 手把。否則,請使用螢幕控制。
+
+ 工作階段
+ 在 Steam 或桌面工作階段開啟時顯示
+ Steam 正在執行
+ 工作階段已暫停 - 準備好後點擊繼續
+ 繼續
+ 結束此工作階段
+ 影格生成
+ 請選擇你要使用的影格生成模式
+ 關閉
+ Win-FG %1$d×
+ LSFG %1$d×
+ LSFG 自適應 %1$d
+ 需要 Steam 上的 Lossless Scaling
+ 在 Steam 中安裝 Lossless Scaling,或匯入 Lossless.dll
+ 匯入 Lossless.dll…
+ 正在使用 Steam 上的版本
+ 正在使用匯入的版本
+ 選擇 Lossless.dll 檔案
+ 已匯入 Lossless.dll
+ 這個 Lossless.dll 已經在使用中了
+ 此 Steam 帳號沒有 Lossless Scaling
+ 此檔案不是 Lossless Scaling 的 Lossless.dll
+ 無法從此 Lossless.dll 準備 LSFG
+ LSFG 需要來自 Steam 的 Lossless Scaling,或是匯入的 Lossless.dll 檔案
+ LSFG 無法從此 Lossless.dll 準備其著色器
+ %1$s:不支援
+ %1$s:引擎失敗
+ %1$s:需要 Lossless Scaling
+ %1$s %2$s · 正在啟動
+ 一個包含多個子資料夾的資料夾,每個子資料夾對應一個 Windows 遊戲。你在 Steam 上擁有的遊戲會在 Steam 重啟後使用對應的 Steam 項目,其餘遊戲會成為非 Steam 捷徑。
+ 新增一個 Steam 媒體庫,並掃描其中的 Windows 遊戲。已擁有的遊戲會使用對應的 Steam 項目,其餘遊戲會成為非 Steam 捷徑。
+ 「忘記」會在下次工作階段中移除這些捷徑。但檔案仍保留在磁碟上。
+ 遊戲環境
+ Proton 遊戲的環境變數。
+ 編輯
+ 所有 Proton 遊戲
+ 設定檔
+ Steam 應用程式 ID
+ 開啟
+ 遊戲 %1$s
+ 新增變數
+ 變數名稱
+ 值
+ 儲存
+ 移除
+ 重新繼承
+ 重設此設定檔
+ 對此設定檔取消設定
+ 未設定任何變數。
+ 已繼承
+ 自訂變數
+ 無法載入或儲存。請檢查剩餘儲存空間後重試。
+ 請輸入有效的名稱和值,最多輸入 8192 個字元。
+ 標準 Proton 執行環境不會讀取此變數。
+ 正在載入…
+ D3D12 功能層級覆寫。12_2 會回報 DirectX 12 Ultimate 能力;不受支援的功能可能會導致失敗。留空以自動偵測。
+ D3D12 著色器模型覆寫。6_9 需要足夠新的 VKD3D 以及符合的 GPU 功能。留空以自動偵測。
+ 保持啟用 Mesa 著色器快取,以減少重複編譯。設定為 false 可啟用快取。
+ Mesa 著色器快取的大小上限,例如 1G。快取越大,佔用的儲存空間越多。
+ D3D12 的 VKD3D 選項。nodxr 會停用光線追蹤;僅在遊戲需要時使用。
+ 設定為 1 以產生 Proton 診斷日誌。記錄日誌可能降低效能並佔用儲存空間。
+ 設定為 1,使用基於 OpenGL 的 WineD3D 代替 DXVK,用於 D3D9–11 相容性測試。
+ 設定為 0,為此遊戲停用 Proton 的手把導覽輔助程式。
+ D3D9–11 的 DXVK 重疊層。fps 顯示影格率;取消設定則隱藏重疊層。
+ 以分號分隔的 DXVK 設定。近期版本使用 dxvk.maxFrameRate 限制影格率;日常遊玩建議使用工作階段影格率限制器。
+ D3D12 影格率限制。0 表示停用限制。
+ Mesa OpenGL 多執行緒。對於 CPU 受限的 OpenGL 遊戲,true 可能有所幫助;請按遊戲分別測試。
+ FEX 預設
+ 下次啟動遊戲時生效。
+ 遊戲
+ FEX 預設
+ 使用 FEX 預設設定。
+ 穩定
+ 最安全、最慢的設定。
+ 相容
+ 完整 TSO + multiblock。
+ 中等
+ 均衡的 TSO 設定,並降低 x87 精確度。
+ 效能
+ 停用全部 TSO;啟用 multiblock。
+ 效能 + TSO
+ 效能設定,並啟用主 TSO。
+ 極致
+ 停用自我修改程式碼檢查。JIT 遊戲和 DRM 可能無法執行。
+ 極致 + TSO
+ 極致設定,並啟用主 TSO。
+ 極致-gn
+ 效能設定,啟用 TSC 和中介資料提示。建議先嘗試此模式,再使用「極致」。
+ Denuvo
+ 效能設定,啟用完整程式碼檢查並隱藏虛擬機監控程式位。
+ 自訂值
+ 選擇值
+ 模擬器和應用程式
+ 新增
+ 你自己的應用程式或遊戲
+ 指令碼
+ AppImage
+ Flatpak
+ %1$s · %2$s
+ %1$s · %2$s · %3$d%%
+ 正在啟動…
+ 已新增 %1$s
+ 已移除 %1$s
+ 桌面
+ 該應用程式已不存在。請從桌面重新選擇。
+ 開啟 %1$s
+ 移除
+ 再次點擊以移除
+ 請先結束工作階段再移除
+ 從其所在資料夾執行 %1$s,並將該資料夾連結到所在的工作階段中。移除應用程式不會影響該資料夾。
+ 從複製到 DroidDeck 內部的資料夾中執行 %1$s。移除應用程式會刪除複本,不會刪除原始檔案。
+ 請先安裝 Linux 執行環境
+ 檔案已不存在
+ 可用空間不足:複製該資料夾需要 %1$s
+ 正在複製 %1$s
+ 新增應用程式失敗
+ 正在尋找 %1$s 的發行版本
+ 無法讀取 %1$s 的發行版本
+ %1$s 沒有提供 ARM64 AppImage 的發行版本
+ 正在下載 %1$s
+ 下載失敗
+ 更新應用程式失敗
+ 無法讀取該圖示
+ 已儲存 %1$s
+ 編輯
+ 檢查更新
+ 正在檢查更新…
+ 更新到 %1$s
+ 已是最新 · %1$s
+ %1$s 已更新
+ %1$s · %2$s
+ 新增應用程式
+ 指令碼
+ AppImage
+ GitHub
+ Flatpak
+ 一個 .sh 檔案。它會從自己的資料夾執行,並透過 gamescope 全螢幕顯示。
+ 一個 ARM64(aarch64)AppImage。首次使用時會將其解壓縮到 Linux 執行環境中。
+ 從儲存庫的最新發行版本安裝 ARM64 AppImage。
+ Flathub 應用程式 ID 或其 Flathub 頁面。如果尚未設定 Flatpak,會先進行設定。
+ 檔案
+ 未選擇檔案
+ 選擇檔案
+ 變更
+ 選擇指令碼
+ 選擇 AppImage
+ 選擇圖示
+ 儲存庫
+ owner/repo 或 github.com 連結
+ 不是 GitHub 儲存庫
+ 應用程式 ID
+ org.ppsspp.PPSSPP
+ 不是有效的 Flathub 應用程式 ID
+ 來源
+ 顯示在桌面
+ 新應用程式
+ 名稱
+ 來自應用程式
+ 圖示
+ 預設圖示
+ 選擇圖示
+ 清除
+ 來自儲存庫
+ 正在尋找圖示…
+ 預設
+ 編輯 %1$s
+ 儲存
+ 正在檢查資料夾…
+ 其資料夾已連結到工作階段中:%1$s
+ 該資料夾包含 Linux 程式,共用儲存空間無法執行這些程式,因此會將其複製到 DroidDeck(%1$s)。
+ 新增
+ 取消
+ 請先從「設定」中安裝 Linux 執行環境。
+ 請等待 %1$s 完成。
+ 取消
+ 自動
+ 從不
+ 一律
+ 解除安裝
+ 檢查
+ 更新
+ 正在檢查…
+ 處理中…
+ 忘記
+ 新增…
+ 使用
+ 下次工作階段生效。
+ Steam 工作階段
+ 桌面工作階段
+ 顯示
+ 解析度
+ 最高 720p
+ 最高 900p
+ 最高 1080p
+ 原生
+ %1$s(預設)
+ 自訂 · %1$d×%2$d
+ 自訂…
+ 720p 可以讓選單回應更快。
+ 螢幕比例
+ 由自訂解析度設定。
+ 自動模式至少使用 16:9。
+ 影格率限制
+ 限制整個工作階段的影格率。顯示器會切換到能夠被該上限整除的重新整理率。
+ HDR
+ HDR10 輸出
+ 無法使用:%1$s。
+ 重新啟動應用程式後生效。
+ 驅動程式
+ GPU 驅動程式
+ Steam 和桌面共用。請在「元件」頁面設定。
+ 觸控與控制
+ 觸控
+ 觸控板
+ 直接
+ 自動:桌面使用觸控板,Steam 使用直接觸控。
+ 螢幕控制
+ Steam + QAM
+ 自動模式會在未連接控制器時顯示螢幕控制。
+ 控制器
+ Steam 辨識你的控制器的方式。下次工作階段生效。
+ Steam Deck 控制器
+ Xbox 360 控制器
+ Deck:提供快速存取按鈕和陀螺儀。Xbox 360:使用 Guide+A 開啟快速存取。
+ 返回
+ 工作階段
+ 背景行為
+ 應用程式隱藏或螢幕關閉時的行為。
+ 手動
+ 自動模式會在背景暫停,並在顯示時恢復。手動模式需點擊「繼續」。從不保持執行。
+ 啟動
+ 在 DroidDeck 開啟時啟動 Steam
+ DroidDeck 啟動時開啟 Steam 工作階段。
+ Decky
+ 正在檢查發行版本…
+ 已準備好安裝 %1$s。
+ 未找到相容版本。請稍後再試。
+ 已安裝 · %1$s
+ 有可用更新 · %1$s
+ 已是最新 · %1$s
+ 載入器
+ 安裝最新版本
+ 隨 Steam 啟動。啟用後,此裝置上的其他應用程式可能可以控制 Steam。
+ 關閉。Steam 的遠端偵錯連接埠保持關閉。
+ 解除安裝 Decky Loader?
+ 移除載入器。你的外掛程式和設定會保留。
+ 用戶端
+ Steam Deck 模式
+ Steam Deck 介面和快速存取效能控制。下次工作階段生效。
+ 效能重疊層
+ 如果 Deck 模式下遊戲崩潰或黑畫面,請關閉此項。下次工作階段生效。
+ 用戶端分支
+ Steam Deck 公開測試版(Deck 模式所需)。
+ 下次工作階段生效。Steam 可能會自行更新一次。
+ 公開測試版
+ Steam Deck 公開測試版
+ Deck 模式一律使用 Steam Deck 公開測試版。
+ 已新增的遊戲
+ 未找到包含 .exe 的遊戲資料夾
+ 遊戲資料夾
+ 另一個遊戲資料夾
+ 來自 Steam 的圖片
+ 按資料夾名稱補全缺少的圖片。遊戲資料夾中的 cover.jpg、hero.jpg、logo.png 或 icon.png 優先使用。
+ 啟動 %1$s
+ 啟動 %1$s · 位於 %2$s
+ 選擇其他檔案…
+ 預設使用與資料夾同名的 .exe,否則使用最大的 .exe。
+ 拉伸遊戲以填滿螢幕
+ 讓支援自行調整大小的遊戲保持全螢幕。如果遊戲顯示得很小,請關閉此項。下次工作階段生效。
+ 拉伸 16:9 遊戲
+ 在長寬比小於 16:9 的螢幕上,將遊戲拉伸以填滿螢幕,而不是顯示黑邊。下次工作階段生效。
+ 音訊
+ 遊戲使用 DirectAudio
+ 繞過 PulseAudio 以降低延遲。
+ Steam 用戶端音訊
+ 下次工作階段生效。
+ 傳統
+ DirectAudio
+ 麥克風
+ 用於語音聊天。
+ 網路
+ Wi-Fi 探索
+ 在 Steam 中顯示 Wi-Fi 名稱和附近的網路。
+ 定位服務已關閉。
+ 未授予定位權限。
+ 開啟設定
+ 繼續
+ 啟用 Wi-Fi 探索?
+ Android 需要定位權限才能讀取 Wi-Fi 名稱並探索附近網路。DroidDeck 使用此權限在 Steam 中顯示這些網路。我們不會追蹤你的位置。沒有此權限也可以存取網際網路。
+ 遊戲儲存空間
+ 自動 - 有 SD 卡時使用 SD 卡
+ 自動 - 有 SD 卡時使用 SD 卡(目前無 SD 卡)
+ 僅內部儲存空間
+ 資料夾:%1$s
+ 第二媒體庫
+ 從 SD 卡或共用儲存空間讀取資源的遊戲可能會卡頓。
+ 選擇資料夾…
+ 渲染器
+ 桌面渲染器
+ 負責繪製桌面。
+ vulkan - GPU
+ gles2 - GPU(實驗性)
+ pixman - 軟體
+ Vulkan 使用 GPU 執行桌面程式,失敗時退回 pixman。使用 pixman 時,遊戲仍會在 GPU 上全螢幕執行。
+ 自訂解析度
+ 取代解析度上限和螢幕比例。不符合螢幕的尺寸會顯示黑邊。
+ 寬度
+ 高度
+ 範圍:320×240 至 3840×2160。
+
+ - %1$d 個遊戲
+ - %1$d 個遊戲
+
+ 確定
+ 刪除
+ 恢復
+ 下載
+ 刪除 %1$s
+ %1$.1f MB
+ 執行環境驅動程式
+ 供 Steam、遊戲和桌面使用。下次工作階段生效。
+ 匯入 Turnip zip…
+ 顯示驅動程式
+ 在兩種模式下都負責將畫面輸出到螢幕。重新啟動應用程式後生效。
+ 匯入 AdrenoTools zip…
+ 從未
+ Nightlies 已檢查於 %1$s
+ 元件
+ 關於元件
+ 檢查新驅動程式
+ 檢查 Nightlies 中的新軟體包
+ Proton
+ Steam 更新時會取代 Valve 的 Proton;每個組建版本的原始檔案都會保留。
+ %1$s · 已取代 %2$d 個
+ %1$s · 全部為原始檔案
+ %1$s · 遊戲執行中
+ GPU 驅動程式
+ %1$s · 已在啟動 %2$s 時重新套用
+ 下一項:%1$s · 遊戲關閉後
+ 正在使用 %1$s:%2$s
+ 等待遊戲關閉
+ 下次啟動遊戲時生效
+ 匯入 .zip
+ 正在讀取 Proton…
+ 尚未安裝 Proton。啟動一次 Steam 以至於其 ARM64 Proton,或從「設定」中新增 GE-Proton 或 CachyOS。
+ 原始 · %1$s
+ %1$s · 目前組建
+ %1$s · 較早組建
+ 已安裝 · %1$d
+ 尚未為 %1$s 儲存任何內容。此 Proton 內建的檔案會作為其原始檔案儲存。
+ 目前有遊戲正在使用此 Proton,因此需要等遊戲關閉。
+ 下次啟動遊戲時生效。
+ 取代 %1$s?
+ 將 %1$s 放入 %2$s?其原始檔案會繼續儲存。%3$s
+ 恢復 %1$s?
+ 將 %1$s 的原始檔案放回 %2$s?%3$s
+ 從應用程式中移除該軟體包。之後可以再次下載。
+ 刪除這個原始版本?
+ 這個 %1$s 原始版本來自 %2$s 的較早組建。目前組建的原始版本一律會保留。
+ Nightlies 中 · %1$d
+ 重新整理以列出 Nightlies 中的軟體包。
+ 自上次檢查以來沒有新內容。
+ 匯入 .wcp
+ 恢復此 Proton 的原始檔案
+ 將 %1$s 的原始檔案 %2$s 放回?
+ 切換
+ FEX、DXVK 和 VKD3D-Proton:針對 Steam 用來執行遊戲的每個 Proton。\n\n選擇一個已安裝項即可將其換入。它會在下次遊戲啟動時生效,或在目前執行的遊戲關閉後生效。\n\n每次啟動前都會重新檢查你的選擇;如果它們被改動過,就會恢復。每個 Proton 的原始檔案都會保留,因此 Steam 更新絕不會遺失它們。
+ 原始
+ 使用中
+ 新
+ 已儲存
+ 效能
+ CPU 核心、工作階段修復和主機名稱。下次工作階段生效。
+ Steam 用戶端核心
+ 覆寫 Steam 的核心選擇
+ 將 Steam、介面輔助程式和 gamescope 固定到下面選擇的核心。
+ 用戶端核心
+ 供 Steam 使用的核心。
+ 開啟覆寫後才能選擇。
+ 遊戲核心
+ 遊戲核心
+ 供遊戲使用的核心。全選時由 Android 自由排程。
+ 用戶端介面
+ GL 多執行緒
+ 可能讓 Steam 選單回應更快。
+ Zink:延遲描述元
+ 推薦用於沒有描述元緩衝區的驅動程式。
+ 跳過 GL 錯誤檢查
+ 關閉逐呼叫 GL 驗證。
+ gamescope:即時 GPU 佇列
+ 提高合成器 GPU 工作的優先順序。可能改善影格時間穩定性,但會佔用一部分遊戲效能。
+ GPU
+ 讓 GPU 保持最高頻率
+ 僅適用於 Adreno。卡頓更少,但耗電和發熱更多。
+ 工作階段修復
+ Turnip:sysmem 渲染
+ Steam 和大多數遊戲會更快。Adreno 710/720/722 必需。
+ 跳過 Steam 的 xalia 輔助程式
+ 停用 Proton 的手把導覽輔助程式,該程式會在每個遊戲中佔用 CPU。
+ 在不使用 seccomp 的情況下執行 proot
+ 可能修復某些核心上的系統呼叫缺少錯誤,但可能降低效能。
+ proot 快速路徑
+ 需要 proot 的 seccomp 篩選器。
+ 檔案尋找更快、卡頓更少。如果程式找不到檔案,請關閉此項。
+ 工作階段身分
+ 主機名稱
+ Steam 為此裝置看到的名稱。留空可恢復為 %1$s。
+ 只能包含字母、數字和中間的連字號,最多 63 個字元。
+ Android 已設定為結束此工作階段
+ 已安裝
+ 可下載
+ 自上次檢查以來沒有新內容。
+ 恢復內建驅動程式
+ 應用程式內建驅動程式:此操作會移除已解壓縮的檔案並隱藏該驅動程式。使用「恢復內建驅動程式」可將其恢復。
+ Android + Linux 套件組合的一半:兩部分都會被移除。正在使用的驅動程式會退回預設驅動程式。
+ 其檔案會從應用程式中移除。
+ 其檔案會被移除。由於正在使用中,因此會改用預設驅動程式。
+ 顯示
+ 控制
+ 元件
+ 設定
+ %1$s 頁面
+ Steam
+ 桌面
+ Steam 選單
+ 快速存取
+ 開啟快速存取選單
+ 上一頁
+ 下一頁
+ 效能 HUD
+ 拉伸遊戲以填滿螢幕
+ 自動(%1$s)
+ 鍵盤
+ 電腦鍵盤
+ Android
+ 第二螢幕
+ 顯示
+ Android 應用程式
+ 啟動應用程式
+ 隱藏
+ 顯示
+ 沒有可啟動的應用程式
+ 工作階段行為
+ 立即套用,並對該模式未來的工作階段生效。
+ 下次工作階段
+ 支援
+ 工作階段日誌
+ 附加到錯誤報告
+ 分享日誌
+ 背景
+ 停止
+ 停止工作階段?
+ 目前正在執行
+ 目前沒有使用 Proton 執行的遊戲
+ 尚未安裝 Proton。
+ 遊戲執行中
+ 已在啟動 %1$s 時重新套用
+ 原始
+ 請在「元件」頁面下載、匯入和刪除。
+ 完成
+ 需要處理
+ 處理中
+ 請檢查無線偵錯的 IP 位址和連接埠;如果 Android 已移除該裝置,請重新配對。
+ 安裝
+ 管理
+ 概觀
+ 控制器
+ 工作階段
+ 啟動器
+ 設定
+ ● 全部就緒
+ %1$d/%2$d 已就緒
+ 系統檢查
+ 裝置受支援
+ 未經測試的 GPU
+ GPU 不受支援
+ %1$s · %2$s
+ %1$s:%2$s
+ Steam 需要 Adreno 驅動程式;%1$s 可能出現黑畫面。
+ Linux 執行環境
+ %1$s · %2$d%%
+ 未安裝 · 約 3 GB,首次執行遊戲時安裝
+ 已安裝
+ %1$s · 有可用更新
+ %1$s · 已是最新
+ 子處理程序限制
+ 已開啟 · Android 可能會關閉 Steam。關閉該限制需要約一分鐘。
+ 未設定 · Android 可能會關閉 Steam。關閉該限制需要約一分鐘。
+ 無法檢查 · 關閉該限制需要約一分鐘。
+ 修復
+ 詳細資料
+ 開發人員選項
+ 使用無線偵錯
+ 重新檢查
+ 開啟限制
+ Steam 帳號
+ 已登入為 %1$s · 離線模式
+ 已登入為 %1$s
+ 點擊 Play 並登入 Steam
+ 工具
+ 控制器
+ 控制器設定無法使用。
+ 工作階段
+ 工作階段日誌
+ 每次工作階段結束後儲存
+ 最新工作階段日誌
+ 已儲存的工作階段日誌
+ 保留最新的 %1$d 個
+ 清除日誌
+ 離線模式
+ 請先登入 Steam
+ 啟動器
+ 佈景主題
+ 啟動器外觀
+ 用作主螢幕
+ DroidDeck 可以作為主螢幕應用程式
+ DroidDeck 不會作為主螢幕應用程式提供
+ 全螢幕
+ 隱藏 Android 狀態列和導覽列
+ 顯示 Android 狀態列和導覽列
+ 預設主螢幕應用程式
+ 選擇主螢幕應用程式
+ 選擇
+ Linux 應用程式(測試版)
+ Flathub 商店
+ 顯示在選單中。部分應用程式可能無法啟動;日誌位於 Download/DroidDeck。
+ 從 Flathub 安裝 Linux 應用程式和遊戲
+ 檔案
+ 瀏覽和管理檔案
+ Proton 版本
+ 安裝 ARM64 Proton 組建版本
+ 效能
+ CPU 核心分配
+ ROM 資料夾
+ 模擬器遊戲的儲存位置
+ 元件
+ FEX、DXVK、VKD3D
+ 控制
+ 按鍵映射
+ 探索
+ 搜尋
+ 已安裝
+ %1$s · %2$d
+ 商店
+ Flathub · ARM64
+ ● Flatpak 已就緒
+ 請先從「設定」中安裝 Linux 執行環境。
+ 設定 Flatpak
+ 新增 Flatpak 並連線到 Flathub(約 20 MB)。第一個應用程式還會下載其執行環境。
+ 正在設定…
+ Flatpak
+ 更新
+ %1$s · %2$s
+ %1$s · %2$s · %3$d%%
+ 正在啟動…
+ 分類
+ 無法連線到 Flathub。請檢查網路連線後重試。
+ 重試
+ 搜尋 Flathub
+ Firefox、遊戲、模擬器…
+ 搜尋
+ 全部
+ 正在搜尋…
+ 按名稱搜尋或選擇分類。這裡只列出 ARM64 應用程式。
+ Flathub 上沒有符合的 ARM64 應用程式。
+ 結果
+ 檢查更新
+ 全部更新(%1$d)
+ ● 全部已是最新版本
+ 還沒有應用程式。請在「探索」或「搜尋」中尋找。
+ 設定 Flatpak 後才能安裝應用程式。
+ 有可用更新 · %1$s
+ 開啟
+ 詳細資料
+ 移除
+ 再次點擊以移除
+ 正在安裝…
+ 安裝
+ 先設定 Flatpak
+ 下載 %1$s
+ ● 已安裝
+ 無法載入此應用程式的 Flathub 頁面。
+ 正在從 Flathub 載入…
+ Flathub 沒有 ARM64 組建版本,因此無法在此安裝。
+ 螢幕擷取畫面
+ 關於
+ 應用程式 ID
+ 授權條款
+ 執行環境
+ 已安裝大小
+ %1$s(另加共用執行環境)
+ 網站
+ 已驗證
+ 更新
+ DroidDeck %1$s · %2$s
+ 已檢查 %1$s
+ 尚未檢查
+ 允許 DroidDeck 自行更新
+ 在下一頁開啟「允許來自此來源」,然後返回。更新會自動繼續。
+ 開啟設定
+ 暫時不要
+ 簽章不同
+ 無法原地更新
+ 此複本使用的不是 DroidDeck 發行金鑰簽章,因此無法直接覆寫更新。請解除安裝後切換。
+ 有可用更新
+ 無法安裝
+ 可以切換
+ 領先 Stable
+ 你領先於 Stable
+ 此組建版本比最新 Stable 更新。下一個 Stable 版本發佈後,你將切換到 Stable。
+ 測試已結束
+ 此測試已結束
+ 該修復已合併或被放棄。請關注 Preview 以取得最新修復。
+ 已是最新
+ 你已擁有最新的 %1$s
+ · %1$s
+ %1$s… %2$d%%
+ %1$s…
+ 更新 %1$s
+ 安裝 %1$s
+ 仍要安裝 Stable %1$s
+ 關注 Preview
+ 請停止正在執行的工作階段後再更新。
+ 收合
+ 更多
+ DroidDeck %1$s
+ 新的 Preview 組建版本
+ PR #%1$d 測試組建版本
+ %1$d MB
+ 更新頻道
+ Stable
+ 經過測試的版本,適合大多數人
+ %1$s · %2$s
+ Preview
+ Stable 之前的最新修復
+ 已是最新
+ 測試組建版本
+ 在正式發佈前嘗試某個修復
+ 目前沒有
+ PR #%1$d
+ 未為此 DroidDeck 複本組建
+ 已更新 %1$s
+ PR #%1$d 測試版
+ 不久前
+ 剛剛
+
+ - %1$d 個可嘗試
+ - %1$d 個可嘗試
+
+
+ - 自你的組建版本以來的變更 · 落後 %1$d 個組建
+ - 自你的組建版本以來的變更 · 落後 %1$d 個組建
+
+
+ - 近期變更 · %1$d 個組建
+ - 近期變更 · %1$d 個組建
+
+ 需要變更的一項 Android 設定
+ Steam
+ Android 會停止那些啟動大量背景處理程序的應用程式,而 Steam 會啟動數十個處理程序。在變更此設定前,遊戲可能會在沒有錯誤提示的情況下關閉。
+ 幫我修復
+ 開啟「停用子處理程序限制」,然後返回。請保持開發人員選項開啟,否則該開關會再次關閉。
+ 開啟開發人員選項
+ 此 Android 版本沒有該開關,因此 DroidDeck 會透過無線偵錯進行修改。大約需要一分鐘,無需電腦。
+ 無線偵錯需要 Wi-Fi。任何網路都可以,不需要網際網路。
+ 配對碼會顯示在通知中。請允許 DroidDeck 傳送通知,或使用「其他方式」。
+ 允許通知
+ 開啟設定 → 開發人員選項 → 無線偵錯,並將其開啟
+ 點擊「使用配對碼配對裝置」
+ 將配對碼輸入 DroidDeck 通知中
+ 正在等待配對彈出視窗…
+ 已找到彈出視窗。請將其中的配對碼輸入通知。
+ 狀態
+ 每 2 秒檢查一次。關閉此開關後此頁面會自動關閉。
+ 其他方式
+ 無線偵錯、手動輸入位址、電腦 ADB
+ 手動輸入位址、電腦 ADB、開發人員選項
+ 改用無線偵錯
+ 部分 ROM 仍會提供此開關。請在開發人員選項中搜尋「子處理程序」。
+ 如果通知方式沒有作用,請手動輸入彈出視窗中的位址和配對碼。
+ 手動輸入位址
+ 使用電腦上的 ADB:
+ 複製命令
+ 選擇在哪個螢幕上開啟 Android 設定。
+ 主螢幕
+ 已配對。正在尋找無線偵錯連接埠…
+ 已配對。請輸入設定中的連接埠。
+ 已找到裝置。正在套用設定…
+ 無法自動套用。請檢查下面的位址後重試。 %1$s
+ 無線偵錯
+ 子處理程序限制已更新
+ 變更子處理程序限制
+ 如果沒有該選項,請透過無線偵錯進行配對。
+ 已配對。請檢查無線偵錯中的 IP 位址和連接埠。
+ 子處理程序限制已更新。
+ 如果開發人員選項中沒有子處理程序設定,請使用步驟 2。開啟開發人員選項 → 無線偵錯 → 使用配對碼配對裝置。
+ 已配對。請使用下面的位址,或在無線偵錯 → IP 位址和連接埠 中更新它。
+ 已透過無線偵錯更新子處理程序限制。
+ Android 已確認限制處於開啟狀態。
+ Android 已確認限制處於關閉狀態。
+ 2 · 配對無線偵錯
+ 配對彈出視窗中的 IP 位址和連接埠
+ 配對碼(PIN)
+ 6 位數字
+ 配對
+ 2 · 透過無線偵錯套用
+ 連線 IP 位址和連接埠
+ 重新配對
+ 關閉限制
+ 其他變更方式
+ 1 · 開發人員選項(優先嘗試)
+ 開啟「限制子處理程序」。
+ 關閉「限制子處理程序」。
+ 3 · 電腦 ADB(最後手段)
+ 僅在無線偵錯無法使用時使用。
+ 3 · 電腦 ADB(最後手段)
+ 工作階段中顯示螢幕控制時
+ 顏色
+ 螢幕按鍵的色調
+ 自訂
+ 不透明度
+ %1$d%%
+ 按鍵大小
+ 100% 為標準大小
+ 搖桿點擊
+ 按兩下並長按搖桿可觸發 L3 或 R3
+ 自適應搖桿
+ 遊戲震動
+ Steam 按鈕
+ QAM 按鈕
+ 鍵盤按鈕
+ 動畫
+ 搖桿會出現在你觸控的位置,並在放開後隱藏
+ 版面配置
+ 已儲存自訂位置
+ 已適應此螢幕
+ 編輯
+ 重設
+ 按鍵映射
+ 每個按鍵傳送對應的原始輸入
+ %1$d/%2$d 個按鍵已重新映射
+ 設定
+ 重設控制器
+ 恢復所有控制器設定和版面配置
+ 設定每個螢幕按鍵向遊戲傳送的輸入。「隱藏」會移除該按鍵。
+ 螢幕按鍵
+ 預設值
+ 重設映射
+ Android 應用程式
+ %1$d 個應用程式
+ 沒有找到可啟動的 Android 應用程式。
+ ● 桌面已安裝
+ 首次開啟時安裝
+ 可安裝
+ 未安裝。
+ %1$s · 未安裝
+ 開啟 %1$s
+ 遊戲
+ 選擇 ROM 資料夾。
+ 在 RetroArch 中瀏覽到 /root/ROMs。
+ 將 %1$s 個遊戲新增到 ROMs/%2$s。
+ 安裝 %1$s
+ 停止工作階段後安裝
+ 需要執行環境
+ 正在載入安裝詳細資料…
+ 安裝詳細資料無法使用。請稍後重試。
+ 請先從「設定」中安裝 Linux 執行環境。
+ 請停止正在執行的工作階段後再安裝桌面應用程式。
+ 將 %1$s 安裝到 Linux 桌面。
+ %1$s · %2$d%%
+ 隱藏後會從桌面移除。檔案仍保留在 Linux 執行環境中。
+ 該遊戲已不在 ROM 資料夾中。
+ 桌面 · %1$s
+ 在 %1$s 中啟動
+ 也位於 %1$s
+ 該頁面已不存在。請從左側選擇一個欄目。
+ 開啟桌面
+ 安裝並開啟桌面
+ Linux 桌面
+ LXQt、Firefox 和你的模擬器
+ 在 Steam 中安裝的遊戲會在工作階段結束後顯示在這裡。
+ 執行 Steam
+ 啟動設定
+ 啟動
+ 遊戲檔案
+ Proton 前置字元
+ 正在尋找存檔…
+ 未按名稱找到存檔資料夾。匯出時會包含整個使用者資料夾。
+ %1$d 個存檔資料夾
+ %1$s · %2$d 個檔案 · %3$s
+ %1$d KB
+ 管理存檔
+ 遊戲存檔
+ 匯入存檔…
+ GameHub 或 Winlator 壓縮檔。匯入前會先備份目前存檔。
+ 匯出為 GameHub 壓縮檔…
+ 適用於 GameHub 和 BannerHub
+ 匯出為 Winlator 壓縮檔…
+ 適用於 Winlator、WinNative 和 Bannerlator
+ 開啟存檔資料夾
+ 從未執行
+ 執行環境繁忙 · %1$d%%
+ 執行環境繁忙
+ 首次執行遊戲時安裝執行環境
+ 執行環境有可用更新
+ ● 執行環境已就緒
+ 上次執行 %1$s
+ 內部儲存空間
+ 已新增的遊戲
+ 為此 GPU 選擇最佳驅動程式組合,並保持最新
+ 自行選擇驅動程式組合
+ 正在檢查驅動程式…
+ 尚未列出驅動程式。重新整理以尋找驅動程式。
+ 隱藏其他 GPU 的驅動程式
+ 顯示其他 GPU 的驅動程式
+ 進階
+ 與顯示驅動程式一起設定:%1$s 同時包含兩者。
+ 與執行環境驅動程式一起設定:%1$s 同時包含兩者。
+ 供遊戲和桌面使用。
+ 執行環境預設
+ 負責將畫面輸出到螢幕。重新啟動 DroidDeck 後生效。
+ 自動 - 按 GPU 選擇
+ 下載、匯入或刪除…
+ 正在使用
+ DroidDeck 內建驅動程式
+ 執行環境驅動程式和顯示驅動程式作為符合組合一起設定。
+ 推薦用於此 GPU:%1$s。
+ 重新整理以尋找適用於此 GPU 的驅動程式。
+ 推薦
+ 無法使用
+ Linux 執行環境
+ 正在準備 Linux 執行環境
+ 工作階段
+ 正在啟動顯示和音訊
+ Steam 用戶端
+ 正在檢查 Steam 及其相容工具
+ 正在開啟 Steam
+ 正在等待 Steam 的第一個畫面
+ 桌面
+ 正在準備桌面
+ 正在開啟
+ 正在等待第一個畫面
+ 正在啟動 Steam
+ 工作階段已結束
+ 第 %1$d 步,共 %2$d 步
+ Steam 已暫停
+ 握把
+ 左側觸控板
+ 右側觸控板
+ 兩側
+ 關閉第二螢幕控制
+ 開啟 Steam 選單
+ 左側 · 上方
+ 左側 · 下方
+ 右側 · 上方
+ 右側 · 下方
+ 點擊
+ 右側觸控板
+ 左側觸控板
+ 觸控板
+ 顯示鍵盤
+ 隱藏鍵盤
+ Linux 終端機
+ Linux 工作階段尚未準備好,無法使用終端機。
+ Steam
+ 遊戲
+ 桌面
+ 商店
+ 元件
+ 應用程式
+ 設定
+ 更新
+ %1$d%%
+ 繼續 %1$s
+ 每個工作階段中顯示為 /root/ROMs。內部儲存空間位於 /root/Storage。
+ 未選擇資料夾
+ 下次工作階段生效。支援 SD 卡。
+ 選擇資料夾
+ 變更資料夾
+ 安裝 ARM64 Proton 組建版本,然後在 Steam → 內容 → 相容性中為每個遊戲選擇。
+ 請停止正在執行的工作階段後再安裝或移除相容性工具。
+ 可用組建版本
+ 已安裝 %1$s
+ 上一次要求留下的待處理項
+ 未安裝
+ 立即安裝
+ 取消排隊
+ Android 鍵盤
+ 隱藏 ✕
+ 啟動 %1$s
+ 選擇螢幕。副螢幕:%1$s。
+ 副螢幕已無法使用。
+ 主螢幕
+ 副螢幕
+ 上一個標籤頁
+ 下一個標籤頁
+ 開啟
+ 全部 %1$d
+ 無
+ %1$d/%2$d
+ 關閉
+ 底部螢幕
+ 下次啟動遊戲時生效。遊戲的設定檔會覆寫共用設定。
+ 按應用程式 ID 選擇其他遊戲…
+ 完成
+ 預設
+ 關閉
+ 變更…
+ 變更變數
+ 恢復預設
+ Proton 遊戲
+ 子母畫面
+ 自動進入子母畫面
+ 已暫停
+ 工作階段準備就緒後即可使用子母畫面。
+ 請在 Android 設定中允許 DroidDeck 使用子母畫面。
+ Android 無法開啟子母畫面。
+ 捷徑
+ 新增至主螢幕
+ 選擇遊戲
+ 正在掃描已安裝的遊戲…
+ 複製啟動連結
+ 已複製啟動連結
+ 此啟動器無法新增捷徑。請改用「複製啟動連結」。
+ 無效的遊戲啟動連結。
+ 此遊戲已不在你的 DroidDeck 遊戲庫中。
+ 啟動 Steam 遊戲前請停止目前工作階段。
+ 無法將遊戲傳送到 Steam。請再次嘗試啟動。
+ 重試移除
+ 正在移除
+ 移除未完成
+ 匯出遊戲檔案
+ 將所有遊戲檔案同步到資料夾
+ 停止同步遊戲檔案
+ 為前端遊戲檔案選擇資料夾
+ 遊戲檔案已儲存到 %1$s
+ 前端檔案
+
\ No newline at end of file
From 49a5f4aa944fc948954491c52545302877cfd809 Mon Sep 17 00:00:00 2001
From: MaxsTechReview
Date: Sun, 4 Oct 2026 12:43:57 -0400
Subject: [PATCH 2/5] ESync, FSync, NTSync + OpenNow + FEX for Desktop Apps
(#197)
* Make the Compatible Proton ARM64 the default and label compatible builds
The CompatToolMapping "0" default always points at DroidDeck's Proton
ARM64 tool, and per-game picks of adopted GE/CachyOS builds are kept,
including when the shortcuts writer remaps.
The tool is named after the Proton build it runs, Proton Experimental
ARM64 (Compatible), or Proton 11.0 ARM64 (Compatible) once that newer build
is installed. Adopted builds carry the same Compatible mark, read from a
string resource the app stages into the runtime, and the Proton page
explains which builds have the prefix fixes.
The registrar is renamed steam-compatibility and the tool
droiddeck-proton-arm64. Existing installs migrate on the next session: the
old tool directory is removed, every mapping that named it moves to the new
tool, and the retired bannerlator-steam-compat script is removed from the
runtime. CI and local packaging include the renamed script.
* Drop the duplicate R import left by merging main
* Add userspace ntsync for Proton on Android
Android kernels have no /dev/ntsync and its app policy refuses futex_waitv,
so every Proton 11 build here fell back to wineserver for every wait.
libblsession now serves /dev/ntsync itself: wineserver opens a memfd region,
each sync object is a timerfd that carries its slot, and the kernel ntsync
ioctls are answered in shared memory with futexes, following the kernel
driver's wake order. Valve's Proton Experimental ARM64, GE-Proton and
proton-cachyos use it unchanged.
Locks record their owner so a killed process cannot wedge the others,
signals are held off inside each critical section, dead processes and
exiting threads are swept, and object lifetimes follow close, dup2, dup3,
close_range and received descriptors.
Fast sync is on by default under Performance > Session fixes, and
PROTON_NO_NTSYNC=1 turns it off per game.
* Add droiddeck-esync as the default sync for Proton on Android
Without a kernel ntsync driver, Proton 11 builds here fell back to
wineserver for every wait. droiddeck-esync brings eventfd and shared-memory
sync to the exact Proton build a game runs on: a pack holds that build's
ntdll.so and wineserver with the patch series in tools/droiddeck-esync
applied, and the guest runs Proton from a shadow tree that links the stock
tool and swaps in those two files. A wineserver from a pack still prefers
/dev/ntsync when a kernel driver or droiddeck-ntsync is there.
Packs are built in Valve's SDK image from each release's own wine source
(Proton Experimental ARM64 tags, GE-Proton and proton-cachyos releases); the
control build must reproduce the release binaries byte for byte, and a
signed index lists the packs. The APK bundles the packs pinned in
release.env, the app fetches newer ones, and Steam's compatibility tool
picks the pack for each Proton build, so new Proton releases get packs
without an app update.
The ntdll side reads, writes and polls its eventfds with raw system calls,
so the guest's LD_PRELOAD wrappers stay out of the sync path. The server
abandons a mutex once a thread killed by TerminateThread has really exited
and when its process dies, and a mutex's owner and recursion count change
in one atomic step, so a killed owner cannot touch the next owner's count.
droiddeck-esync is on by default and PROTON_NO_ESYNC=1 turns it off per
game; droiddeck-ntsync, the userspace ntsync, is now an opt-in toggle.
* Watch Valve's Proton releases and build droiddeck-esync packs for them
A scheduled workflow reads the Proton ARM64 builds Steam ships (anonymous
steamcmd app info) and the upstream source tags, compares them with the
previous watch state and starts the pack build for any build that has no
pack yet. The pack build applies the patch series with --fuzz=0 and runs a
smoke test of each new pack against the esstress suite before it is
published.
* Add droiddeck-fsync, keep Steam and the app on one Proton, fix DirectAudio
droiddeck-fsync: libblsession answers futex_waitv(2), which the app
sandbox refuses, in userspace, so Proton's own fsync runs on the stock
Proton files with no pack. Waiters register the words they wait on in a
table beside the fsync shared memory and sleep on a futex of their own;
FUTEX_WAKE on the fsync memory wakes the registered waiters. Slots carry
one owner word that the sweeper and the owner claim with a CAS, and the
mapping table is rebuilt under a lock held across the real munmap, so a
reused address or a recycled slot cannot lose a waiter. It stands in for
a Proton build without a pack (droiddeck-ntsync where fsync is off), takes
over for games with esync off, and the "droiddeck-fsync first" toggle
(BL_FSYNC_FIRST, also per game) puts it ahead of the packs. The games
Proton keeps off fsync and esync never get it. A launch into a prefix
whose wineserver is still running keeps that server's sync choice.
One Proton for Steam and the app: the Components page's Proton is the
default Steam uses, applied live through the client while Steam runs
(droiddeck-steam-compat) and at the next start otherwise; a choice made in
Steam's menu comes back to the app. Requests are ordered by a sequence that
never goes backwards, and the page no longer jumps back to the default
after a swap or restore.
DirectAudio: the wrapper wrote the driver key with its backslashes
stripped, so no game ever used DirectAudio. Wine 11 also loads a builtin
only from the prefix, so the driver is now linked into system32 and
syswow64 before "directaudio,pulse" is selected; mmdevapi falls back to
winepulse whenever DirectAudio cannot start.
* Pick esync, ntsync or fsync from the Steam settings' Games group
A three-way tab row above the FEX preset sets the sync Proton games use. It
writes the existing switches together (droiddeck-ntsync, droiddeck-fsync
first, droiddeck-esync), so the Performance toggles and the tabs always agree,
starts on esync and keeps the choice until it is changed again.
* Make droiddeck-fsync the default sync for Proton games
A fresh install, or one that never picked a sync, starts on fsync; a choice made
in the Steam settings' Games group still sticks. Games Proton keeps off fsync
still fall back to droiddeck-esync.
* Add wineserver to the Wine sync tabs and order them ntsync, fsync, esync, wineserver
wineserver turns every in-process sync off so games wait through wineserver;
picking any other tab turns sync back on. The tabs shrink to fit a narrow pane.
* Shorten the Wine sync description
* Answer openat2 and execveat for FEX in the session preload
FEX opens every file of its x86 rootfs with openat2(RESOLVE_IN_ROOT) and
only falls back to the host path on EXDEV. Under proot on Android openat2
answers ENOSYS, so each lookup of an x86 library silently went to the host
and missed. The exported syscall() now turns openat2 into openat once the
real call reports ENOSYS: RESOLVE_IN_ROOT paths are taken relative to the
root fd (FEX has already resolved the links inside the rootfs), and an
absolute path under RESOLVE_BENEATH fails with EXDEV as the kernel would.
execveat with an absolute path, or relative to AT_FDCWD, and without
AT_EMPTY_PATH or AT_SYMLINK_NOFOLLOW, is plain execve; it is sent as such
because proot refuses execveat with a directory fd, which FEX uses when it
re-executes itself for a child x86 program.
* Run x86 Linux games and programs through FEX
Steam: Linux-only titles that have no ARM64 build (from the client's
appinfo cache: type game, demo, application or beta) are mapped to a new
compatibility tool, droiddeck-fex ("Linux x86 (FEX)", linux to linux,
no required runtime). Valve's own "fex" tool needs pressure-vessel, which
cannot run under proot, so a mapping to it or to a Steam Linux Runtime is
replaced; any other pick the user made stays. Titles that also ship for
Windows stay on Proton. When such a title is installed and FEX or the
sniper runtime is missing, the client is asked to install them.
droiddeck-fex runs the program under the FEX that Steam installs (app
3127680), with Steam Linux Runtime 3.0 (sniper, app 1628350) as the x86
rootfs:
- the sniper platform is linked in place from its usr-mtree (relative
links only, files/usr -> .), once per runtime version;
- the x86_64 and i386 builds of libblsession and libfakeinput go into the
runtime's lib//droiddeck and its etc/ld.so.preload, mirroring
the session's own list, so x86 programs get the pads and the session
fixes (FEX passes their system calls straight to the kernel, so the
ARM64 preloads cannot reach them);
- Config.json sets RootFS and the GL and Vulkan thunks, so x86 games draw
with the device's Turnip and Mesa;
- the FEX preset and the game's own environment from the Steam settings
apply, and ARM64 entries are dropped from LD_PRELOAD/LD_LIBRARY_PATH.
It also links ~/.steam/sdk64 and sdk32 to the client's x86 steamclient
when the client has one and nothing is there yet.
Desktop: x86_64 and i386 AppImages can be imported now; they unpack
through FEX (or unsquashfs) and record their architecture. Scripts,
AppImages and programs started in a run session use FEX automatically
when they are x86, and each added app has a "Use FEX" Auto/On/Off choice
in its edit dialog. The launchers' "still running" checks also look at
FEX processes, whose exe is FEX rather than the program. A GitHub release
without an ARM64 AppImage falls back to its x86_64 one. Decky's x86
loader starts through droiddeck-fex instead of the fex-mesa rootfs path,
which no runtime ships.
The x86 preloads are built against glibc 2.31 (Debian 11) so they load
in sniper: tools/linuxfs/build-x86-preloads.sh, run in CI and by
build_local.sh. fakeinput's stat hooks fall back to __xstat on a glibc
without a stat export, and mmap64 takes off64_t for the i386 build.
* Keep a FEX unixlib from outliving its DLL
A FEX package or original bundle without the aarch64-unix helpers left
the previous version's libarm64ecfex.so / libwow64fex.so in the Proton,
so the new DLLs loaded a unixlib built for another FEX. A swap now removes
the helpers the package does not carry; FEX then runs DLL-only, which it
already falls back to when Wine cannot load the unixlib.
* Fix the Wine sync choices an audit found
- wineserver tab: it passed Proton's environment through, so a build with
esync built in (GE, cachyos) still ran esync and a kernel ntsync would
still be used. It now sets PROTON_NO_ESYNC, PROTON_NO_FSYNC and
PROTON_NO_NTSYNC (unless the game's own environment sets them).
- ntsync tab: a Proton whose wineserver has no /dev/ntsync client got
wineserver-only sync although fsync would work. The hash cache records
whether the wineserver has one; without it the launch goes to
droiddeck-fsync, and no stand-in or pack turns droiddeck-ntsync on.
- A build with esync built in returned before the per-game fallbacks, so
a game that turns esync off ran with no in-process sync. It now gets
droiddeck-fsync, or droiddeck-ntsync where fsync is off too.
- When a pack's proton cannot start and the stock one is used, or the
selection fails, the prefix's record now says stock, so a second
launch into the same running prefix no longer picks the pack's ntdll.
- droiddeck-fsync: its mutex is held across fork and re-made in the
child, a closed or replaced shm fd is forgotten (close, dup2, dup3,
close_range, closefrom), and a waiter woken while it was leaving on a
timeout or signal reports the wake instead of losing it.
- BL_SYNC_MIN_NOFILE applies per game to every verb, debug logs carry
prefixes.json, the device report names the chosen sync instead of the
three raw switches, and PATCHES.md and the proot notes describe the
selector, the fsync default and droiddeck-fsync's futex_waitv.
* Name the runtime's scripts and files droiddeck, migrating old installs
The guest scripts are droiddeck-* now (droiddeck-session and the other 19),
as are the files the app and scripts generate (etc/droiddeck, the network
state files, the components dir, the Steam install stamp, the redist marker,
the extra-Proton wrapper and backups) and the compositor's own names
(libdroiddeckwayland, droiddeck_* sources, DROIDDECK_* switches, the
wl_output and seat names).
Installed runtimes carry on: LegacyNames moves etc/bannerlator and
share/bannerlator over and leaves relative links at the old paths before
every proot command, turns any old script into a link to its new name,
moves the generated files and points menu entries at the new scripts.
The session scripts and steam-compatibility move their markers on first
use, the components dir's desired.tsv is rewritten with it, and the
runtime counts as installed under either session script.
Kept: the banner_ahb_v1/banner_desktop_v1 wire names and BANNER_AUDIO_DIRECT
(read by prebuilt Turnip and Wine builds), Banners-Turnip and other
third-party names, BL_* switches, libblsession, and credits to Bannerlator.
* Unpack x86 AppImages without FEX, then ask Steam for FEX
Importing an x86 AppImage failed when FEX was not installed yet ("needs FEX
to unpack and no unsquashfs is installed"). AppImages now unpack with
uruntime (VHSgunzo, MIT, v0.8.1 aarch64, pinned by sha256 and shipped
unmodified with its licence), which reads SquashFS and DwarFS images of any
architecture natively. FEX's own --appimage-extract and unsquashfs stay as
fallbacks, and an ARM64 image whose own runtime cannot unpack it goes the
same way.
An x86 import with FEX missing records that FEX is wanted, so the next
Steam session requests FEX and the Steam Linux Runtime, and the program's
page says FEX is not set up yet and how to get it.
* Run Vulkan Qt Quick AppImages on Wayland
OpenNOW (Qt 6.8, Qt Quick on Vulkan) closed within two seconds in a run
mode. The session sends toolkits to gamescope's Xwayland, and Qt's xcb
backend only presents with Vulkan when Mesa's X11 WSI does, which needs
DRI3; Xwayland on KGSL has none, so Qt found no queue that can present and
aborted ("Failed to create RHI").
An AppImage that bundles Qt Quick, the Vulkan loader and Qt's Wayland
plugin now runs on gamescope's Wayland socket (the desktop's, outside
gamescope), where Turnip presents as it does for games, with Qt's xcb
backend as the fallback. SDL_VIDEODRIVER and XDG_SESSION_TYPE follow, so
helpers that pick their window system from them (OpenNOW's streamer) agree
with Qt. Everything else stays on X11; a qt file in the app's directory
(wayland or xcb) overrides the choice.
* Keep gamescope's WSI layer away from Qt apps on its Wayland socket
OpenNOW still closed at once: its FFmpeg (the Raspberry Pi fork, libavutil
61) creates its Vulkan queues internally synchronized whenever the driver
offers VK_KHR_internally_synchronized_queues, which DD-Turnip does. The
gamescope WSI layer registers every queue of a new device through
vkGetDeviceQueue, which only returns queues created without flags, so it
got VK_NULL_HANDLE and vkroots aborted on assert(obj) before Qt opened a
window.
Programs that draw on gamescope's Wayland socket do not need the layer,
which only carries X11 windows past Xwayland, so it is turned off for
them. OpenNOW bundles no Vulkan loader (it reaches Vulkan through Qt and
dlopen), so a binary that uses QVulkanInstance counts as a Vulkan app too,
and a Qt Quick app left on X11 says why in the session log.
* Keep the end of the session log, and say when FEX is missing
The session sends its output through head -c into session.log. head
writes through stdio, so it held up to 4 KB that proot's --kill-on-exit
threw away when the guest ended: every log stopped mid-line at a 4096-byte
boundary, losing exactly the lines that say why a program quit (an x86
AppImage's "x86 Linux programs need FEX" among them). dd writes each read
as it comes and keeps the same cap.
A run mode always ends with status 0 (gamescope does not pass its child's
on), so a program that could not start just closed. When the log says FEX
is missing, the ended screen now says so and how to get it.
The app reads FEX's readiness from status.json, which only a launch or an
import wrote, so it still said "not set up" after Steam installed FEX.
droiddeck-fex status rewrites it, and a Steam session ends with it while
FEX is wanted. FEX is also looked for at the tool's root and under files/,
and a tool folder without it lists what it holds.
* Let FEX and its runtime install runnable on an SD card library
A Steam library on shared storage loses the executable bits, so native
tools are staged in private directories bound over it; only Proton and
SteamLinuxRuntime folders were. FEX (3127680) installed there could never
run, droiddeck-fex saw no FEX and kept asking Steam for it. FEX and the
sniper runtime (1628350) now get private directories from their first
download, whatever their install folder is called.
* Keep fsync off in the pack smoke test
A runner whose kernel allows futex_waitv started stock Proton with fsync,
so the server-side baseline never said what the test waits for and every
pack was waved through as untestable; the esync run would have measured
fsync too.
* Judge a pack against stock's own esstress failures
Stock Proton fails esstress's dup wait all under server-side sync as well
(a Wine bug, seen on the phone too), and any stock failure made the test
call the runner unusable. A pack now fails only when it crashes, hangs or
fails a check stock passes.
* Ask Steam for FEX and its runtime one at a time
Both steam://install requests were started together, and the running client
took only the first: FEX installed, the sniper runtime FEX needs never did.
Each request now waits for the client to take it before the next.
* Bundle the first published droiddeck-esync packs in the apk
* Log how an x86 program under FEX ends
FEX keeps its own errors quiet unless asked, so a program it could not run
left nothing in the session log. Its log now goes to stderr, and the AppImage
launcher records the program's exit status or the signal that ended it.
* Show the log a failed AppImage program wrote
Programs like Eden stop themselves on a failed check and say why only in
their own log under the home folder. When the program ends badly, the end of
any log it wrote during the run is copied into the session log.
* Report where an x86 program under FEX hit an illegal instruction
A tiny x86_64 preload, built without libc, catches SIGILL and writes the
address, the instruction bytes and the mapping they belong to before the
program dies as it would have. droiddeck-fex preloads it into x86_64 programs.
* Load the fault reporter from the x86 runtime
Programs under FEX look libraries up in the x86 runtime, so the reporter is
copied there with the other preloads and named by its path inside it.
* Hand FEX its x86 runtime and thunks through the environment
Valve's FEX runs portable and reads its config beside itself, so the
Config.json droiddeck-fex writes was not seen: programs ran without the
runtime. The runtime, thunk libraries and thunk list now also go in FEX's
own environment variables, and each launch says what it was given.
* Use the sync pack built for the installed Proton release
Some Proton releases ship byte-identical ntdll.so and wineserver (Valve
11.0-2b/2c, CachyOS 0702/0703), so a pack built for a newer release
matched an older install exactly and the older install never fetched its
own pack. A pack from a newer release no longer counts as an exact match;
among matches the one built for the installed version wins, then rev.
The app ranks the pack a tool already uses the same way and only fetches
a pack that ranks higher, reads the release epoch from tools.tsv and
refetches when tools.tsv changes. A prefix whose server is still running
re-checks its recorded pack on waitforexitandrun and starts fresh when a
better one now applies.
* Keep published sync packs and revocations consistent
The publish step never replaces a pack that has an entry beside it; a
pack left without its entry by an interrupted run is replaced so the
build stops repeating. Discovery counts revocations the signed index does
not show yet, including superseded packs only the flavor releases list,
so the index is signed again. The release watch always builds every
flavor.
* Fetch the droiddeck-esync packs from DroidDeck-Components
The packs, the signed index and the apk bundle now live in the releases
of Droid-Deck/DroidDeck-Components, together with the pipeline that
builds them, so this repository keeps only the app and the guest code
that consumes them. The app's index and asset URLs point there,
release.env names the repository its bundle comes from, and the apk
builds drop bundled packs that the published index revokes.
* Stop the apk build when the published sync index cannot be read
* Ask Steam for one FEX dependency at a time
The client shows a confirmation dialog for each steam://install, and a
second request replaces the first dialog, so FEX was never installed
when the runtime was requested right after it. The next dependency is
now requested once the previous one has an app manifest.
* Use generic names in the AppImage test fixtures
* Give x86-64 apps under FEX the Vulkan thunk
Apps that bring their own glibc and Vulkan loader skipped FEX's thunk
overlay and loaded their bundled desktop Mesa drivers, which crash on the
phone's GPU during Vulkan setup. droiddeck-fex now adds an x86-64 audit
module when a program's bundled glibc and libstdc++ meet the thunk's
version needs. The module sends libvulkan.so.1 lookups to a nodelete stub
that needs FEX's thunk path. That keeps the thunk mapped when an app
unloads Vulkan and loads it again, since FEX keeps its first trampoline
links and the old addresses get reused.
The fault reporter now restores the default action before re-raising,
because FEX ignores SA_RESETHAND and the handler looped.
---
.../workflows/build-droiddeck-esync-packs.yml | 449 ---
.github/workflows/build.yml | 58 +-
.github/workflows/watch-proton-releases.yml | 112 -
.gitignore | 1 +
README.md | 2 +-
app/build.gradle | 2 +-
app/src/main/cpp/fakeinput_steam.cpp | 95 +-
app/src/main/cpp/waylandcomp/CMakeLists.txt | 74 +-
.../main/cpp/waylandcomp/ZERO_COPY_SPIKE.md | 12 +-
.../main/cpp/waylandcomp/src/ahb_swapchain.c | 90 +-
.../main/cpp/waylandcomp/src/ahb_swapchain.h | 26 +-
app/src/main/cpp/waylandcomp/src/banner_ext.h | 50 -
app/src/main/cpp/waylandcomp/src/blend_pass.c | 6 +-
app/src/main/cpp/waylandcomp/src/compositor.c | 260 +-
.../cpp/waylandcomp/src/compositor_internal.h | 8 +-
.../src/{banner_color.h => droiddeck_color.h} | 94 +-
.../src/{banner_ext.c => droiddeck_ext.c} | 26 +-
.../main/cpp/waylandcomp/src/droiddeck_ext.h | 50 +
.../main/cpp/waylandcomp/src/effects_chain.c | 22 +-
.../cpp/waylandcomp/src/framegen_bridge.c | 6 +-
.../cpp/waylandcomp/src/framegen_engine.cpp | 4 +-
.../main/cpp/waylandcomp/src/hdr_compose.c | 6 +-
app/src/main/cpp/waylandcomp/src/sc_layer.c | 148 +-
app/src/main/cpp/waylandcomp/src/sc_layer.h | 16 +-
app/src/main/cpp/waylandcomp/src/vk_loader.c | 2 +-
app/src/main/cpp/waylandcomp/src/vk_present.c | 98 +-
app/src/main/cpp/waylandcomp/src/vk_present.h | 6 +-
.../cpp/waylandcomp/src/waylandcomp_jni.c | 126 +-
.../main/cpp/waylandcomp/src/wl_clipboard.c | 30 +-
.../main/cpp/waylandcomp/src/wl_color_mgmt.c | 204 +-
app/src/main/cpp/waylandcomp/src/wl_dmabuf.c | 24 +-
.../main/cpp/waylandcomp/src/wl_text_input.c | 36 +-
.../cpp/waylandcomp/src/wl_toplevel_icon.c | 2 +-
.../com/droiddeck/launcher/ComponentsMenu.kt | 25 +-
.../com/droiddeck/launcher/MainActivity.kt | 27 +-
.../com/droiddeck/launcher/SessionActivity.kt | 24 +-
.../droiddeck/launcher/core/DeviceReport.kt | 4 +
.../launcher/core/GameEnvironment.kt | 2 +-
.../launcher/core/GameEnvironmentOptions.kt | 4 +
.../droiddeck/launcher/core/LogRedactor.kt | 4 +-
.../droiddeck/launcher/core/NetworkReport.kt | 4 +-
.../droiddeck/launcher/frontend/Library.kt | 8 +-
.../droiddeck/launcher/gpu/LsfgNative.java | 2 +-
.../launcher/runtime/AppImageManager.kt | 17 +-
.../launcher/runtime/BwrapSpawner.kt | 2 +-
.../launcher/runtime/DeckyManager.kt | 3 +-
.../launcher/runtime/FlatpakManager.kt | 12 +-
.../droiddeck/launcher/runtime/LegacyNames.kt | 109 +
.../droiddeck/launcher/runtime/LinuxFex.kt | 62 +
.../runtime/LinuxNetworkLinkComponent.kt | 8 +-
.../launcher/runtime/LinuxRuntime.java | 12 +-
.../droiddeck/launcher/runtime/UserApps.kt | 16 +-
.../launcher/session/ComponentsManager.kt | 44 +-
.../droiddeck/launcher/session/EsyncPacks.kt | 941 +++++++
.../launcher/session/GameEnvironmentStore.kt | 2 +-
.../launcher/session/OverlayShown.kt | 2 +-
.../launcher/session/ProtonDefault.kt | 86 +
.../launcher/session/ProtonExtras.kt | 10 +-
.../launcher/session/SecondaryLibrary.kt | 4 +-
.../launcher/session/SessionFiles.kt | 65 +-
.../launcher/session/SessionPrefs.kt | 46 +
.../launcher/session/SessionService.kt | 39 +-
.../droiddeck/launcher/store/UserAppsState.kt | 4 +-
.../com/droiddeck/launcher/ui/AddAppDialog.kt | 21 +-
.../droiddeck/launcher/ui/ComponentsPage.kt | 8 +
.../droiddeck/launcher/ui/FrontEndContent.kt | 13 +-
.../launcher/ui/ModeSettingsDialog.kt | 17 +
.../launcher/ui/PerformanceDialog.kt | 21 +
.../com/droiddeck/launcher/ui/ProtonPage.kt | 7 +-
.../droiddeck/launcher/ui/SettingsWidgets.kt | 65 +
.../droiddeck/launcher/wayland/HdrSupport.kt | 2 +-
.../launcher/wayland/WaylandCompositor.java | 28 +-
app/src/main/res/values-es/strings.xml | 40 +-
app/src/main/res/values/strings.xml | 43 +-
.../launcher/runtime/AppImageManagerTest.kt | 6 +-
.../launcher/runtime/BwrapSpawnerTest.kt | 4 +-
.../launcher/runtime/LegacyNamesTest.kt | 82 +
.../launcher/runtime/LinuxFexTest.kt | 67 +
.../launcher/session/EsyncPacksTest.kt | 843 ++++++
.../launcher/session/ProtonDefaultTest.kt | 62 +
.../launcher/session/SecondaryLibraryTest.kt | 13 +
.../launcher/session/SyncBackendTest.kt | 62 +
docs/development/flatpak.md | 10 +-
docs/development/game-environment.md | 2 +-
docs/development/proot-performance.md | 13 +-
docs/development/steam-game-imports.md | 2 +-
tools/build_local.sh | 52 +-
tools/droiddeck-esync/PATCHES.md | 170 --
tools/droiddeck-esync/build-local.sh | 27 -
tools/droiddeck-esync/build-pack.sh | 125 -
tools/droiddeck-esync/discover.py | 654 -----
tools/droiddeck-esync/flavors.json | 84 -
tools/droiddeck-esync/index-key.pub | 4 -
tools/droiddeck-esync/make_index.py | 285 --
tools/droiddeck-esync/make_pack.py | 367 ---
.../cachyos-11/0001-droiddeck-esync.patch | 2436 -----------------
.../valve-11/0001-droiddeck-esync.patch | 2436 -----------------
tools/droiddeck-esync/release.env | 4 +
tools/droiddeck-esync/revoked.txt | 0
tools/droiddeck-esync/smoke-test.sh | 62 -
tools/droiddeck-esync/tests/esstress.c | 618 -----
tools/linuxfs/build-x86-preloads.sh | 48 +
tools/linuxfs/desktop/autostart | 2 +-
tools/linuxfs/desktop/droiddeck-desktop | 14 +-
tools/linuxfs/desktop/droiddeck-desktop-gpu | 4 +-
tools/linuxfs/desktop/rc.xml | 2 +-
tools/linuxfs/fex/faultreport.c | 144 +
tools/linuxfs/fex/thunkaudit.c | 40 +
tools/linuxfs/licenses/uruntime-LICENSE | 21 +
.../overlay/usr/bin/steamos-session-select | 2 +-
.../usr/local/bin/bannerlator-appimage-run | 69 -
.../usr/local/bin/bannerlator-script-run | 37 -
.../usr/local/bin/bannerlator-steam-compat | 641 -----
.../usr/local/bin/droiddeck-appimage-run | 122 +
.../{bannerlator-bwrap => droiddeck-bwrap} | 0
...-bookmarks => droiddeck-desktop-bookmarks} | 0
...-desktop-games => droiddeck-desktop-games} | 6 +-
.../overlay/usr/local/bin/droiddeck-esync | 24 +-
.../overlay/usr/local/bin/droiddeck-fex | 659 +++++
...{bannerlator-flatpak => droiddeck-flatpak} | 14 +-
...ator-flatpak-run => droiddeck-flatpak-run} | 4 +-
...-flatpak-setup => droiddeck-flatpak-setup} | 6 +-
...annerlator-game-env => droiddeck-game-env} | 87 +-
.../{bannerlator-login1 => droiddeck-login1} | 2 +-
...rlator-netmanager => droiddeck-netmanager} | 4 +-
...or-pad-defaults => droiddeck-pad-defaults} | 44 +-
...or-proton-extra => droiddeck-proton-extra} | 41 +-
.../usr/local/bin/droiddeck-script-run | 51 +
...or-seed-redists => droiddeck-seed-redists} | 6 +-
...{bannerlator-session => droiddeck-session} | 122 +-
.../usr/local/bin/droiddeck-steam-compat | 495 ++++
...ator-steam-games => droiddeck-steam-games} | 8 +-
...-steam-install => droiddeck-steam-install} | 10 +-
...or-steam-launch => droiddeck-steam-launch} | 18 +-
...-steam-library => droiddeck-steam-library} | 12 +-
...rlator-steam-shim => droiddeck-steam-shim} | 4 +-
...am-shortcuts => droiddeck-steam-shortcuts} | 27 +-
...team-ui-scale => droiddeck-steam-ui-scale} | 0
.../overlay/usr/local/bin/steam-compatibility | 1112 ++++++++
tools/linuxfs/preload/fsync.c | 653 +++++
tools/linuxfs/preload/inputudev.c | 4 +-
tools/linuxfs/preload/net.c | 82 +-
tools/linuxfs/preload/netif.c | 10 +-
tools/linuxfs/preload/ntsync.c | 1333 +++++++++
tools/linuxfs/preload/opens.c | 3 +
tools/linuxfs/preload/robust.c | 63 +
tools/linuxfs/uruntime.env | 3 +
tools/proot/bench/equiv.py | 2 +-
tools/proot/bench/run-device.sh | 2 +-
tools/release/check_session_assets.py | 3 +-
tools/tests/test_appimage_run.py | 132 +
tools/tests/test_desktop_bookmarks.py | 2 +-
tools/tests/test_droiddeck_fex.py | 515 ++++
tools/tests/test_esync_packs.py | 1161 ++++++++
tools/tests/test_fsync_preload.py | 346 +++
tools/tests/test_game_environment.py | 337 ++-
tools/tests/test_login1.py | 2 +-
tools/tests/test_netmanager.py | 2 +-
tools/tests/test_request_fex.py | 52 +
tools/tests/test_session_assets.py | 4 +-
tools/tests/test_session_log.py | 39 +
tools/tests/test_steam_compat_live.py | 218 ++
tools/tests/test_steam_games.py | 10 +-
tools/tests/test_steam_install.py | 6 +-
tools/tests/test_steam_ui_scale.py | 2 +-
165 files changed, 11709 insertions(+), 9667 deletions(-)
delete mode 100644 .github/workflows/build-droiddeck-esync-packs.yml
delete mode 100644 .github/workflows/watch-proton-releases.yml
delete mode 100644 app/src/main/cpp/waylandcomp/src/banner_ext.h
rename app/src/main/cpp/waylandcomp/src/{banner_color.h => droiddeck_color.h} (70%)
rename app/src/main/cpp/waylandcomp/src/{banner_ext.c => droiddeck_ext.c} (82%)
create mode 100644 app/src/main/cpp/waylandcomp/src/droiddeck_ext.h
create mode 100644 app/src/main/java/com/droiddeck/launcher/runtime/LegacyNames.kt
create mode 100644 app/src/main/java/com/droiddeck/launcher/runtime/LinuxFex.kt
create mode 100644 app/src/main/java/com/droiddeck/launcher/session/EsyncPacks.kt
create mode 100644 app/src/main/java/com/droiddeck/launcher/session/ProtonDefault.kt
create mode 100644 app/src/test/java/com/droiddeck/launcher/runtime/LegacyNamesTest.kt
create mode 100644 app/src/test/java/com/droiddeck/launcher/runtime/LinuxFexTest.kt
create mode 100644 app/src/test/java/com/droiddeck/launcher/session/EsyncPacksTest.kt
create mode 100644 app/src/test/java/com/droiddeck/launcher/session/ProtonDefaultTest.kt
create mode 100644 app/src/test/java/com/droiddeck/launcher/session/SyncBackendTest.kt
delete mode 100644 tools/droiddeck-esync/PATCHES.md
delete mode 100755 tools/droiddeck-esync/build-local.sh
delete mode 100755 tools/droiddeck-esync/build-pack.sh
delete mode 100755 tools/droiddeck-esync/discover.py
delete mode 100644 tools/droiddeck-esync/flavors.json
delete mode 100644 tools/droiddeck-esync/index-key.pub
delete mode 100755 tools/droiddeck-esync/make_index.py
delete mode 100755 tools/droiddeck-esync/make_pack.py
delete mode 100644 tools/droiddeck-esync/patches/cachyos-11/0001-droiddeck-esync.patch
delete mode 100644 tools/droiddeck-esync/patches/valve-11/0001-droiddeck-esync.patch
create mode 100644 tools/droiddeck-esync/release.env
delete mode 100644 tools/droiddeck-esync/revoked.txt
delete mode 100755 tools/droiddeck-esync/smoke-test.sh
delete mode 100644 tools/droiddeck-esync/tests/esstress.c
create mode 100755 tools/linuxfs/build-x86-preloads.sh
create mode 100644 tools/linuxfs/fex/faultreport.c
create mode 100644 tools/linuxfs/fex/thunkaudit.c
create mode 100644 tools/linuxfs/licenses/uruntime-LICENSE
delete mode 100755 tools/linuxfs/overlay/usr/local/bin/bannerlator-appimage-run
delete mode 100755 tools/linuxfs/overlay/usr/local/bin/bannerlator-script-run
delete mode 100755 tools/linuxfs/overlay/usr/local/bin/bannerlator-steam-compat
create mode 100755 tools/linuxfs/overlay/usr/local/bin/droiddeck-appimage-run
rename tools/linuxfs/overlay/usr/local/bin/{bannerlator-bwrap => droiddeck-bwrap} (100%)
rename tools/linuxfs/overlay/usr/local/bin/{bannerlator-desktop-bookmarks => droiddeck-desktop-bookmarks} (100%)
rename tools/linuxfs/overlay/usr/local/bin/{bannerlator-desktop-games => droiddeck-desktop-games} (95%)
create mode 100755 tools/linuxfs/overlay/usr/local/bin/droiddeck-fex
rename tools/linuxfs/overlay/usr/local/bin/{bannerlator-flatpak => droiddeck-flatpak} (92%)
rename tools/linuxfs/overlay/usr/local/bin/{bannerlator-flatpak-run => droiddeck-flatpak-run} (93%)
rename tools/linuxfs/overlay/usr/local/bin/{bannerlator-flatpak-setup => droiddeck-flatpak-setup} (97%)
rename tools/linuxfs/overlay/usr/local/bin/{bannerlator-game-env => droiddeck-game-env} (62%)
rename tools/linuxfs/overlay/usr/local/bin/{bannerlator-login1 => droiddeck-login1} (98%)
rename tools/linuxfs/overlay/usr/local/bin/{bannerlator-netmanager => droiddeck-netmanager} (99%)
rename tools/linuxfs/overlay/usr/local/bin/{bannerlator-pad-defaults => droiddeck-pad-defaults} (95%)
rename tools/linuxfs/overlay/usr/local/bin/{bannerlator-proton-extra => droiddeck-proton-extra} (82%)
create mode 100755 tools/linuxfs/overlay/usr/local/bin/droiddeck-script-run
rename tools/linuxfs/overlay/usr/local/bin/{bannerlator-seed-redists => droiddeck-seed-redists} (95%)
rename tools/linuxfs/overlay/usr/local/bin/{bannerlator-session => droiddeck-session} (89%)
create mode 100755 tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat
rename tools/linuxfs/overlay/usr/local/bin/{bannerlator-steam-games => droiddeck-steam-games} (97%)
rename tools/linuxfs/overlay/usr/local/bin/{bannerlator-steam-install => droiddeck-steam-install} (87%)
rename tools/linuxfs/overlay/usr/local/bin/{bannerlator-steam-launch => droiddeck-steam-launch} (75%)
rename tools/linuxfs/overlay/usr/local/bin/{bannerlator-steam-library => droiddeck-steam-library} (94%)
rename tools/linuxfs/overlay/usr/local/bin/{bannerlator-steam-shim => droiddeck-steam-shim} (78%)
rename tools/linuxfs/overlay/usr/local/bin/{bannerlator-steam-shortcuts => droiddeck-steam-shortcuts} (89%)
rename tools/linuxfs/overlay/usr/local/bin/{bannerlator-steam-ui-scale => droiddeck-steam-ui-scale} (100%)
create mode 100755 tools/linuxfs/overlay/usr/local/bin/steam-compatibility
create mode 100644 tools/linuxfs/preload/fsync.c
create mode 100644 tools/linuxfs/preload/ntsync.c
create mode 100644 tools/linuxfs/uruntime.env
create mode 100644 tools/tests/test_appimage_run.py
create mode 100644 tools/tests/test_droiddeck_fex.py
create mode 100644 tools/tests/test_esync_packs.py
create mode 100644 tools/tests/test_fsync_preload.py
create mode 100644 tools/tests/test_request_fex.py
create mode 100644 tools/tests/test_session_log.py
create mode 100644 tools/tests/test_steam_compat_live.py
diff --git a/.github/workflows/build-droiddeck-esync-packs.yml b/.github/workflows/build-droiddeck-esync-packs.yml
deleted file mode 100644
index a98ae23ab6..0000000000
--- a/.github/workflows/build-droiddeck-esync-packs.yml
+++ /dev/null
@@ -1,449 +0,0 @@
-name: Build droiddeck-esync packs
-
-on:
- schedule:
- - cron: '17 5 * * *'
- push:
- branches: [ main ]
- paths:
- - 'tools/droiddeck-esync/**'
- - '.github/workflows/build-droiddeck-esync-packs.yml'
- workflow_dispatch:
- inputs:
- flavor:
- description: 'Proton flavor to look at'
- type: choice
- options: [ all, valve, ge, cachyos ]
- default: all
- ref:
- description: 'One release tag to build (e.g. GE-Proton11-7); empty = the newest builds of each family'
- required: false
- default: ''
- publish:
- description: 'Publish the packs and sign a new index'
- type: boolean
- default: false
-
-permissions:
- contents: write
-
-concurrency:
- group: droiddeck-esync-packs-${{ (github.repository == 'Droid-Deck/DroidDeck' && github.ref == 'refs/heads/main' && (github.event_name != 'workflow_dispatch' || inputs.publish)) && 'publish' || format('build-{0}', github.run_id) }}
- cancel-in-progress: false
-
-env:
- SYNC_BASE_URL: https://github.com/Droid-Deck/DroidDeck/releases/download
-
-jobs:
- discover:
- if: ${{ github.repository == 'Droid-Deck/DroidDeck' || github.event_name == 'workflow_dispatch' }}
- runs-on: ubuntu-24.04
- timeout-minutes: 15
- permissions:
- contents: read
- outputs:
- matrix: ${{ steps.discover.outputs.matrix }}
- count: ${{ steps.discover.outputs.count }}
- unindexed: ${{ steps.discover.outputs.unindexed }}
- publish: ${{ steps.discover.outputs.publish }}
- steps:
- - uses: actions/checkout@v4
-
- - name: Find the Proton builds without a pack
- id: discover
- env:
- GH_TOKEN: ${{ github.token }}
- FLAVOR: ${{ inputs.flavor || 'all' }}
- REF: ${{ inputs.ref }}
- ASKED: ${{ github.event_name != 'workflow_dispatch' || inputs.publish }}
- PUBLISH: ${{ github.repository == 'Droid-Deck/DroidDeck' && github.ref == 'refs/heads/main' && (github.event_name != 'workflow_dispatch' || inputs.publish) }}
- run: |
- set -euo pipefail
- if [ "$ASKED" = true ] && [ "$PUBLISH" != true ]; then
- echo "::notice::packs are published only from main of Droid-Deck/DroidDeck; this run only builds them"
- fi
- echo "publish=$PUBLISH" >> "$GITHUB_OUTPUT"
- python3 tools/droiddeck-esync/discover.py matrix --flavor "$FLAVOR" --ref "$REF" \
- --index-release droiddeck-esync-index --repo "$GITHUB_REPOSITORY" --revoked tools/droiddeck-esync/revoked.txt
-
- build:
- name: ${{ matrix.flavor }} ${{ matrix.tag }}
- needs: discover
- if: needs.discover.outputs.count != '0'
- runs-on: ubuntu-24.04-arm
- timeout-minutes: 360
- permissions:
- contents: read
- strategy:
- fail-fast: false
- max-parallel: 2
- matrix: ${{ fromJSON(needs.discover.outputs.matrix) }}
- env:
- FLAVOR: ${{ matrix.flavor }}
- REPO: ${{ matrix.repo }}
- TAG: ${{ matrix.tag }}
- ASSET: ${{ matrix.asset }}
- VERSION_TOKEN: ${{ matrix.token }}
- DEPOT_APP: ${{ matrix.depot_app }}
- REV: ${{ matrix.rev }}
- SERIES: ${{ matrix.series }}
- PROFILE: ${{ matrix.profile }}
- SOURCE_MATCH: ${{ matrix.source_match }}
- SUBMODULES: ${{ matrix.submodules }}
- CLONE: ${{ matrix.clone }}
- PREP: ${{ matrix.prep }}
- BUILD_DIR: ${{ matrix.build_dir }}
- HAVE_DEPOT_LOGIN: ${{ secrets.STEAM_DEPOT_USER != '' && secrets.STEAM_DEPOT_TOKEN != '' }}
- steps:
- - uses: actions/checkout@v4
- with:
- persist-credentials: false
-
- - name: Check the build script and the patch series
- run: |
- set -euo pipefail
- test -f tools/droiddeck-esync/build-pack.sh
- ls "tools/droiddeck-esync/patches/$SERIES"/*.patch
-
- - name: Install the host tools
- run: |
- set -euo pipefail
- sudo apt-get update -qq
- sudo apt-get install -y -qq autoconf automake git patch perl python3 rsync unzip wget xz-utils zstd >/dev/null
-
- - name: Fetch the stock binaries
- if: matrix.asset != ''
- env:
- GH_TOKEN: ${{ github.token }}
- run: |
- set -euo pipefail
- rm -rf stock-download stock
- mkdir -p stock-download stock
- gh release download "$TAG" -R "$REPO" -p "$ASSET" -D stock-download
- tar -xf "stock-download/$ASSET" -C stock
- rm -rf stock-download
- mapfile -t tops < <(find stock -mindepth 1 -maxdepth 1 -type d)
- if [ "${#tops[@]}" != 1 ]; then
- echo "::error::$ASSET does not hold exactly one Proton directory"
- exit 1
- fi
- dir=$(realpath "${tops[0]}")
- test -f "$dir/files/lib/wine/aarch64-unix/ntdll.so"
- test -f "$dir/files/bin-arm64/wineserver"
- line=$(head -n1 "$dir/version" | tr -d '\r')
- if ! grep -qE '^[0-9]+[[:space:]]+[[:graph:]]+' <<<"$line"; then
- echo "::error::$ASSET has no usable version file"
- exit 1
- fi
- echo "Stock $line"
- {
- echo "STOCK_DIR=$dir"
- echo "VERSION_LINE=$line"
- } >> "$GITHUB_ENV"
-
- - name: Fetch the stock depot (optional, Valve only, needs STEAM_DEPOT_USER, STEAM_DEPOT_TOKEN and DEPOT_DOWNLOADER_SHA256)
- if: matrix.flavor == 'valve' && env.HAVE_DEPOT_LOGIN == 'true'
- continue-on-error: true
- env:
- GH_TOKEN: ${{ github.token }}
- DEPOT_DOWNLOADER_TAG: DepotDownloader_3.4.0
- DEPOT_DOWNLOADER_SHA256: ${{ vars.DEPOT_DOWNLOADER_SHA256 }}
- STEAM_DEPOT_USER: ${{ secrets.STEAM_DEPOT_USER }}
- STEAM_DEPOT_TOKEN: ${{ secrets.STEAM_DEPOT_TOKEN }}
- run: |
- set -euo pipefail
- if ! grep -qxE '[0-9a-f]{64}' <<<"$DEPOT_DOWNLOADER_SHA256"; then
- echo "::warning::set the repository variable DEPOT_DOWNLOADER_SHA256 to the sha256 of DepotDownloader-linux-arm64.zip from $DEPOT_DOWNLOADER_TAG to fetch the depot"
- exit 0
- fi
- rm -rf depotdownloader depot
- gh release download "$DEPOT_DOWNLOADER_TAG" -R SteamRE/DepotDownloader -p 'DepotDownloader-linux-arm64.zip' -D depotdownloader
- echo "$DEPOT_DOWNLOADER_SHA256 depotdownloader/DepotDownloader-linux-arm64.zip" | sha256sum -c -
- unzip -q depotdownloader/DepotDownloader-linux-arm64.zip -d depotdownloader
- chmod +x depotdownloader/DepotDownloader
- printf '%s\n' version files/lib/wine/aarch64-unix/ntdll.so files/bin-arm64/wineserver > depot-files.txt
- timeout 30m depotdownloader/DepotDownloader -app "$DEPOT_APP" -os linux -all-archs \
- -username "$STEAM_DEPOT_USER" -password "$STEAM_DEPOT_TOKEN" \
- -filelist depot-files.txt -dir depot > "$GITHUB_ENV"
-
- - name: Prepare the wine source
- run: |
- set -euo pipefail
- git config --global user.name "ci"
- git config --global user.email "ci@users.noreply.github.com"
- rm -rf src
- git init -q src
- git -C src remote add origin "https://github.com/$REPO.git"
- git -C src fetch -q --depth 1 origin "refs/tags/$TAG:refs/tags/$TAG"
- git -C src checkout -q "refs/tags/$TAG"
- read -r -a modules <<<"$SUBMODULES"
- case "$CLONE" in
- shallow) history=(--depth 1) ;;
- treeless) history=(--filter=tree:0) ;;
- *) echo "::error::unknown clone mode $CLONE"; exit 1 ;;
- esac
- git -C src submodule update -q --init "${history[@]}" -- "${modules[@]}"
- if [ -n "$PREP" ]; then
- if ! (cd src && bash "$PREP") > prep.log 2>&1; then
- tail -n 200 prep.log
- echo "::error::$PREP failed"
- exit 1
- fi
- fi
- test -f src/wine/server/protocol.def
- image=$(python3 tools/droiddeck-esync/discover.py sdk-image src/Makefile.in)
- commit=$(git -C src rev-parse HEAD)
- wine_commit=$(git -C src rev-parse HEAD:wine)
- line=${VERSION_LINE:-}
- if [ -z "$line" ]; then
- if [ -z "$VERSION_TOKEN" ]; then
- echo "::error::no stock version file and no version token for $TAG"
- exit 1
- fi
- line="$(git -C src log -1 --format=%ct HEAD) $VERSION_TOKEN"
- fi
- echo "SDK image $image, $REPO $commit, wine $wine_commit, version $line"
- {
- echo "SDK_IMAGE=$image"
- echo "SOURCE_COMMIT=$commit"
- echo "WINE_COMMIT=$wine_commit"
- echo "VERSION_LINE=$line"
- echo "SOURCE_DATE_EPOCH=${line%%[[:space:]]*}"
- } >> "$GITHUB_ENV"
-
- - name: Build the control and the patched binaries
- run: |
- set -euo pipefail
- docker pull -q "$SDK_IMAGE"
- for kind in control patched; do
- work=$PWD/build/work-$kind
- out=$PWD/build/$kind
- sudo rm -rf "$work" "$out"
- mkdir -p "$work" "$out"
- if [ "$kind" = patched ]; then
- bash tools/droiddeck-esync/build-pack.sh prepare "$PWD/src/wine" "$work" "$PWD/tools/droiddeck-esync/patches/$SERIES"
- else
- bash tools/droiddeck-esync/build-pack.sh prepare "$PWD/src/wine" "$work"
- fi
- docker run --rm \
- -v "$work:$BUILD_DIR" -v "$out:/out" -v "$PWD/tools/droiddeck-esync/build-pack.sh:/build-pack.sh:ro" \
- -w "$BUILD_DIR" -e HOME=/tmp -e LANG=C.UTF-8 -e JOBS="$(nproc)" \
- -e SOURCE_DATE_EPOCH -e SYNC_PROFILE="$PROFILE" \
- "$SDK_IMAGE" /bin/bash /build-pack.sh build "$BUILD_DIR" /out
- done
- sudo chown -R "$(id -u):$(id -g)" build
- sha256sum build/*/files/lib/wine/aarch64-unix/ntdll.so build/*/files/bin-arm64/wineserver
-
- - name: Make the pack
- run: |
- set -euo pipefail
- source_json=$(python3 -c 'import json, os; print(json.dumps({"repo": os.environ["REPO"], "ref": os.environ["TAG"], "asset": os.environ["ASSET"], "commit": os.environ["SOURCE_COMMIT"], "wine_commit": os.environ["WINE_COMMIT"], "sdk_image": os.environ["SDK_IMAGE"]}, sort_keys=True))')
- match=()
- if [ -z "${STOCK_DIR:-}" ] && [ "$SOURCE_MATCH" = true ]; then
- match=(--source-match)
- fi
- rm -rf out
- id=$(python3 tools/droiddeck-esync/make_pack.py --flavor "$FLAVOR" --rev "$REV" --stock-dir "${STOCK_DIR:-}" \
- --version-line "$VERSION_LINE" --control build/control --patched build/patched \
- --source-json "$source_json" --patch-series "$SERIES" --out out "${match[@]}")
- echo "Pack \`$id\` from $FLAVOR $TAG" >> "$GITHUB_STEP_SUMMARY"
- ls -l out
-
- - name: Smoke-test the pack on the release it was made for
- if: matrix.asset != ''
- run: |
- set -euo pipefail
- id=$(basename out/*.tzst .tzst)
- docker run --rm -v "$PWD:/work" -w /work "$SDK_IMAGE" \
- /opt/llvm-mingw/bin/aarch64-w64-mingw32-clang -O2 -o esstress.exe tools/droiddeck-esync/tests/esstress.c
- set +e
- bash tools/droiddeck-esync/smoke-test.sh "$STOCK_DIR" "out/$id.tzst" esstress.exe smoke
- status=$?
- set -e
- case $status in
- 0) echo "Smoke test passed for \`$id\`" >> "$GITHUB_STEP_SUMMARY" ;;
- 3) echo "::warning::stock $TAG does not run on this runner, so $id could not be smoke-tested" ;;
- *) echo "::error::$id failed the smoke test on $TAG"; exit 1 ;;
- esac
-
- - uses: actions/upload-artifact@v4
- with:
- name: droiddeck-esync-pack-${{ matrix.key }}
- path: out/
- if-no-files-found: error
-
- - uses: actions/upload-artifact@v4
- if: failure()
- with:
- name: droiddeck-esync-logs-${{ matrix.key }}
- path: |
- prep.log
- build/work-*/*.log
- smoke/*.log
- if-no-files-found: ignore
-
- publish:
- name: Publish the packs
- needs: [ discover, build ]
- if: ${{ !cancelled() && needs.discover.result == 'success' && needs.discover.outputs.publish == 'true' && needs.discover.outputs.count != '0' }}
- runs-on: ubuntu-24.04
- timeout-minutes: 30
- steps:
- - uses: actions/checkout@v4
- with:
- persist-credentials: false
-
- - uses: actions/download-artifact@v4
- with:
- pattern: droiddeck-esync-pack-*
- path: packs
-
- - name: Upload the packs to their releases
- env:
- GH_TOKEN: ${{ github.token }}
- MATRIX: ${{ needs.discover.outputs.matrix }}
- run: |
- set -euo pipefail
- mkdir -p packs
- python3 tools/droiddeck-esync/discover.py packs --matrix "$MATRIX" packs > packs.tsv
- if [ ! -s packs.tsv ]; then
- echo "::notice::no build made a pack"
- exit 0
- fi
- while IFS=$'\t' read -r -u 3 flavor dir id; do
- tag="droiddeck-esync-$flavor"
- if ! gh release view "$tag" -R "$GITHUB_REPOSITORY" >/dev/null 2>&1; then
- gh release create "$tag" -R "$GITHUB_REPOSITORY" --latest=false --prerelease=false --title "$tag" \
- --notes "droiddeck-esync packs for $flavor Proton builds (tools/droiddeck-esync). The app fetches them through the signed index in the droiddeck-esync-index release." \
- || gh release view "$tag" -R "$GITHUB_REPOSITORY" >/dev/null
- fi
- gh release upload "$tag" -R "$GITHUB_REPOSITORY" "$dir/$id.tzst" --clobber
- gh release upload "$tag" -R "$GITHUB_REPOSITORY" "$dir/$id.json" --clobber
- gh release edit "$tag" -R "$GITHUB_REPOSITORY" --latest=false --prerelease=false
- echo "Published \`$id\` to $tag" >> "$GITHUB_STEP_SUMMARY"
- done 3< packs.tsv
-
- - name: Record the builds that made no pack
- env:
- GH_TOKEN: ${{ github.token }}
- MATRIX: ${{ needs.discover.outputs.matrix }}
- RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- run: |
- set -euo pipefail
- mkdir -p packs failed
- python3 tools/droiddeck-esync/discover.py failures --matrix "$MATRIX" packs > failed.tsv
- while IFS=$'\t' read -r -u 3 flavor marker; do
- tag="droiddeck-esync-$flavor"
- if ! gh release view "$tag" -R "$GITHUB_REPOSITORY" >/dev/null 2>&1; then
- gh release create "$tag" -R "$GITHUB_REPOSITORY" --latest=false --prerelease=false --title "$tag" \
- --notes "droiddeck-esync packs for $flavor Proton builds (tools/droiddeck-esync). The app fetches them through the signed index in the droiddeck-esync-index release." \
- || gh release view "$tag" -R "$GITHUB_REPOSITORY" >/dev/null
- fi
- echo "$RUN_URL" > "failed/$marker"
- gh release upload "$tag" -R "$GITHUB_REPOSITORY" "failed/$marker" --clobber
- echo "::warning::$marker: no pack was made; discovery skips this build for a day unless rev or the patch series changes"
- done 3< failed.tsv
-
- index:
- name: Sign the index
- needs: [ discover, build, publish ]
- if: ${{ !cancelled() && needs.discover.result == 'success' && needs.discover.outputs.publish == 'true' && (needs.discover.outputs.count != '0' || needs.discover.outputs.unindexed != '0') }}
- runs-on: ubuntu-24.04
- timeout-minutes: 30
- environment: droiddeck-esync-signing
- steps:
- - uses: actions/checkout@v4
-
- - name: Collect the published packs
- env:
- GH_TOKEN: ${{ github.token }}
- run: |
- set -euo pipefail
- fetch() {
- local out
- if out=$(gh release download "$1" -R "$GITHUB_REPOSITORY" -p "$2" -D "$3" --clobber 2>&1); then
- return 0
- fi
- if grep -qiE 'release not found|no assets match' <<<"$out"; then
- echo "::notice::$1 has no $2 yet"
- return 0
- fi
- echo "$out" >&2
- return 1
- }
- rm -rf entries previous bundle-packs out
- mkdir -p entries previous bundle-packs
- for flavor in valve ge cachyos; do
- fetch "droiddeck-esync-$flavor" '*.json' entries
- done
- fetch droiddeck-esync-index index.json previous
- fetch droiddeck-esync-index index.json.sig previous
- args=(--entries entries --base-url "$SYNC_BASE_URL" --revoked tools/droiddeck-esync/revoked.txt)
- if [ -f previous/index.json ]; then
- args+=(--previous previous/index.json --previous-sig previous/index.json.sig)
- fi
- python3 tools/droiddeck-esync/make_index.py "${args[@]}" --list-bundle > bundle.tsv
- while IFS=$'\t' read -r flavor id; do
- fetch "droiddeck-esync-$flavor" "$id.tzst" bundle-packs
- done < bundle.tsv
- echo "Entries: $(find entries -name '*.json' | wc -l); bundled packs: $(wc -l < bundle.tsv)"
-
- - name: Sign the index and make the apk bundle
- id: index
- env:
- SYNC_INDEX_KEY: ${{ secrets.SYNC_INDEX_KEY }}
- run: |
- set -euo pipefail
- if [ -z "$SYNC_INDEX_KEY" ]; then
- echo "::error::the droiddeck-esync-signing environment has no SYNC_INDEX_KEY secret"
- exit 1
- fi
- args=(--entries entries --base-url "$SYNC_BASE_URL" --revoked tools/droiddeck-esync/revoked.txt)
- if [ -f previous/index.json ]; then
- args+=(--previous previous/index.json --previous-sig previous/index.json.sig)
- fi
- python3 tools/droiddeck-esync/make_index.py "${args[@]}" --out out --bundle-packs-dir bundle-packs
-
- - name: Publish the index
- env:
- GH_TOKEN: ${{ github.token }}
- CHANGED: ${{ steps.index.outputs.changed }}
- BUNDLE: ${{ steps.index.outputs.bundle }}
- run: |
- set -euo pipefail
- if [ "$CHANGED" != true ]; then
- echo "::notice::no pack was added, replaced or revoked; the published index stays"
- exit 0
- fi
- tag=droiddeck-esync-index
- if ! gh release view "$tag" -R "$GITHUB_REPOSITORY" >/dev/null 2>&1; then
- gh release create "$tag" -R "$GITHUB_REPOSITORY" --latest=false --prerelease=false --title "$tag" \
- --notes "Signed index of the droiddeck-esync packs (tools/droiddeck-esync). The app fetches index.json and index.json.sig; the apk build bundles the bundle-*.tzst that tools/droiddeck-esync/release.env names." \
- || gh release view "$tag" -R "$GITHUB_REPOSITORY" >/dev/null
- fi
- gh release upload "$tag" -R "$GITHUB_REPOSITORY" "out/$BUNDLE"
- gh release upload "$tag" -R "$GITHUB_REPOSITORY" out/index.json out/index.json.sig --clobber
- sum=$(sha256sum "out/$BUNDLE" | cut -d' ' -f1)
- gh release edit "$tag" -R "$GITHUB_REPOSITORY" --latest=false --prerelease=false
- {
- echo "### tools/droiddeck-esync/release.env"
- echo
- echo '```'
- echo "SYNC_BUNDLE_TAG=$tag"
- echo "SYNC_BUNDLE_ASSET=$BUNDLE"
- echo "SYNC_BUNDLE_SHA256=$sum"
- echo '```'
- } | tee -a "$GITHUB_STEP_SUMMARY"
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 647ab24d4d..a9f186c82e 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -28,7 +28,7 @@ concurrency:
cancel-in-progress: ${{ github.event_name == 'pull_request' }}
env:
- PRELOAD_CACHE_VERSION: v2
+ PRELOAD_CACHE_VERSION: v3
jobs:
build:
@@ -157,7 +157,7 @@ jobs:
uses: actions/cache@v4
with:
path: app/src/main/assets/linuxfs
- key: preloads-${{ env.PRELOAD_CACHE_VERSION }}-${{ hashFiles('app/src/main/cpp/fakeinput_steam.cpp', 'tools/linuxfs/preload/*.c', 'tools/linuxfs/clipboard/*.c', 'tools/proot/fastpath/*.c', 'tools/linuxfs/overlay/usr/local/bin/*', 'tools/linuxfs/overlay/usr/bin/**', 'tools/linuxfs/desktop/*', 'tools/gamescope/release.env', 'tools/wlroots/release.env', 'tools/mangoapp/*') }}
+ key: preloads-${{ env.PRELOAD_CACHE_VERSION }}-${{ hashFiles('app/src/main/cpp/fakeinput_steam.cpp', 'tools/linuxfs/preload/*.c', 'tools/linuxfs/build-x86-preloads.sh', 'tools/linuxfs/fex/*', 'tools/linuxfs/clipboard/*.c', 'tools/proot/fastpath/*.c', 'tools/linuxfs/overlay/usr/local/bin/*', 'tools/linuxfs/overlay/usr/bin/**', 'tools/linuxfs/desktop/*', 'tools/gamescope/release.env', 'tools/wlroots/release.env', 'tools/linuxfs/uruntime.env', 'tools/linuxfs/licenses/*', 'tools/mangoapp/*') }}
- name: Build libfakeinput.so and libblsession.so (glibc aarch64)
if: steps.preloads.outputs.cache-hit != 'true'
@@ -182,7 +182,7 @@ jobs:
mkdir -p "$D/usr/local/bin"
aarch64-linux-gnu-gcc -O2 -Wall -Wextra -o "$D/usr/local/bin/droiddeck-clipboard" tools/linuxfs/clipboard/clipboard.c -ldl
aarch64-linux-gnu-strip --strip-unneeded "$D/usr/local/bin/droiddeck-clipboard"
- for script in tools/linuxfs/overlay/usr/local/bin/bannerlator-*; do
+ for script in tools/linuxfs/overlay/usr/local/bin/droiddeck-* tools/linuxfs/overlay/usr/local/bin/steam-compatibility; do
install -Dm644 "$script" "$D/usr/local/bin/$(basename "$script")"
done
for f in tools/linuxfs/overlay/usr/bin/* tools/linuxfs/overlay/usr/bin/steamos-polkit-helpers/*; do
@@ -204,6 +204,12 @@ jobs:
test -f "$D/usr/local/lib/droiddeck-wlroots/libwlroots-0.20.so"
rm wlroots.tzst
fi
+ . tools/linuxfs/uruntime.env
+ curl -fsSL --retry 3 -o uruntime "https://github.com/VHSgunzo/uruntime/releases/download/${URUNTIME_VERSION}/${URUNTIME_ASSET}"
+ echo "${URUNTIME_SHA256} uruntime" | sha256sum -c -
+ install -Dm644 uruntime "$D/usr/local/lib/droiddeck/uruntime"
+ install -Dm644 tools/linuxfs/licenses/uruntime-LICENSE "$D/usr/local/share/licenses/uruntime/LICENSE"
+ rm uruntime
M="$D/usr/local/lib/mangoapp"
mkdir -p "$M" mango-pkgs
grep -v '^#' tools/mangoapp/packages.txt | while read -r sum url; do
@@ -233,6 +239,46 @@ jobs:
install -Dm644 tools/linuxfs/desktop/firefox-droiddeck.js "$D/usr/lib/firefox/defaults/pref/droiddeck.js"
ls -lR "$D"
+ - name: Build the x86 preloads FEX guests load (glibc 2.31)
+ if: steps.preloads.outputs.cache-hit != 'true'
+ run: |
+ set -euo pipefail
+ docker run --rm -v "$PWD:/src" -w /src debian:bullseye bash -c '
+ set -euo pipefail
+ printf "deb http://archive.debian.org/debian bullseye main\ndeb http://archive.debian.org/debian-security bullseye-security main\n" > /etc/apt/sources.list
+ apt-get -o Acquire::Check-Valid-Until=false update -qq
+ DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends gcc g++ gcc-multilib g++-multilib binutils >/dev/null
+ tools/linuxfs/build-x86-preloads.sh app/src/main/assets/linuxfs
+ '
+ sudo chown -R "$(id -u):$(id -g)" app/src/main/assets/linuxfs
+ ls -l app/src/main/assets/linuxfs/x86_64 app/src/main/assets/linuxfs/i386
+
+ - name: Bundle the droiddeck-esync packs
+ env:
+ GH_TOKEN: ${{ github.token }}
+ run: |
+ set -euo pipefail
+ if [ -f tools/droiddeck-esync/release.env ]; then
+ . tools/droiddeck-esync/release.env
+ gh release download "$SYNC_BUNDLE_TAG" -R "$SYNC_BUNDLE_REPO" -p "$SYNC_BUNDLE_ASSET" -O sync-bundle.tzst
+ echo "$SYNC_BUNDLE_SHA256 sync-bundle.tzst" | sha256sum -c -
+ mkdir -p app/src/main/assets/droiddeck-esync
+ tar --use-compress-program=unzstd -xf sync-bundle.tzst -C app/src/main/assets/droiddeck-esync
+ rm sync-bundle.tzst
+ gh release download "$SYNC_BUNDLE_TAG" -R "$SYNC_BUNDLE_REPO" -p index.json -O sync-index.json
+ revoked=$(python3 -c 'import json, sys; print(" ".join(p["id"] for p in json.load(open(sys.argv[1]))["packs"] if p.get("revoked") is True))' sync-index.json)
+ for id in $revoked; do
+ if [ -e "app/src/main/assets/droiddeck-esync/packs/$id.tzst" ]; then
+ echo "::warning::$SYNC_BUNDLE_ASSET carries revoked pack $id; it is left out of the APK (point tools/droiddeck-esync/release.env at a newer bundle)"
+ rm -f "app/src/main/assets/droiddeck-esync/packs/$id.tzst"
+ fi
+ done
+ rm sync-index.json
+ test -f app/src/main/assets/droiddeck-esync/index.json
+ test -f app/src/main/assets/droiddeck-esync/index.json.sig
+ ls -lR app/src/main/assets/droiddeck-esync
+ fi
+
- name: Cache PulseAudio 13.0 source
id: pa-src
uses: actions/cache@v4
@@ -297,11 +343,11 @@ jobs:
echo "::error::libfakeinput.so exports the C++ runtime"; exit 1
fi
SESSION=$(syms "$D/libblsession.so")
- for sym in socket bind getsockname setsockopt statfs statvfs; do
+ for sym in socket bind getsockname setsockopt statfs statvfs syscall shm_open shm_unlink mmap mmap64 munmap; do
grep -qx "$sym" <<<"$SESSION" || { echo "::error::libblsession.so does not export $sym"; exit 1; }
done
- test -f "$D/usr/local/bin/bannerlator-session"
- test -f "$D/usr/local/bin/bannerlator-proton-extra"
+ test -f "$D/usr/local/bin/droiddeck-session"
+ test -f "$D/usr/local/bin/droiddeck-proton-extra"
- name: Cache the CMake build tree
uses: actions/cache@v4
diff --git a/.github/workflows/watch-proton-releases.yml b/.github/workflows/watch-proton-releases.yml
deleted file mode 100644
index b5f56b39ac..0000000000
--- a/.github/workflows/watch-proton-releases.yml
+++ /dev/null
@@ -1,112 +0,0 @@
-name: Watch Proton releases
-
-on:
- schedule:
- - cron: '*/20 * * * *'
- workflow_dispatch:
-
-permissions:
- contents: write
- actions: write
-
-concurrency:
- group: watch-proton-releases
- cancel-in-progress: false
-
-jobs:
- watch:
- if: ${{ github.repository == 'Droid-Deck/DroidDeck' }}
- runs-on: ubuntu-24.04
- timeout-minutes: 15
- steps:
- - uses: actions/checkout@v4
- with:
- persist-credentials: false
-
- - name: Pick the steamcmd cache week
- id: week
- run: echo "week=$(date -u +%G-%V)" >> "$GITHUB_OUTPUT"
-
- - uses: actions/cache@v4
- with:
- path: ~/steamcmd
- key: steamcmd-${{ runner.os }}-${{ steps.week.outputs.week }}
- restore-keys: steamcmd-${{ runner.os }}-
-
- - name: Read the Proton builds Steam ships
- run: |
- set -euo pipefail
- sudo apt-get update -qq
- sudo apt-get install -y -qq lib32gcc-s1 >/dev/null
- mkdir -p ~/steamcmd
- if [ ! -x ~/steamcmd/steamcmd.sh ]; then
- curl -fsSL https://steamcdn-a.akamaihd.net/client/installer/steamcmd_linux.tar.gz | tar -xz -C ~/steamcmd
- fi
- apps=$(python3 tools/droiddeck-esync/discover.py steam-apps)
- args=(+login anonymous +app_info_update 1)
- for app in $apps; do
- args+=(+app_info_print "$app")
- done
- if ! timeout 300 ~/steamcmd/steamcmd.sh "${args[@]}" +quit > steam-info.txt 2>&1; then
- tail -n 20 steam-info.txt
- echo "::warning::steamcmd failed; this run watches the source tags only"
- : > steam-info.txt
- fi
-
- - name: Fetch the previous watch state
- env:
- GH_TOKEN: ${{ github.token }}
- run: |
- set -euo pipefail
- mkdir -p previous
- if ! out=$(gh release download droiddeck-esync-index -R "$GITHUB_REPOSITORY" -p watch-state.json -D previous --clobber 2>&1); then
- if grep -qiE 'release not found|no assets match' <<<"$out"; then
- echo "::notice::no watch state yet; every flavor counts as new"
- else
- echo "$out" >&2
- exit 1
- fi
- fi
-
- - name: Compare with the last run
- id: watch
- env:
- GH_TOKEN: ${{ github.token }}
- run: |
- set -euo pipefail
- info=()
- if [ -s steam-info.txt ]; then
- info=(--steam-info steam-info.txt)
- fi
- python3 tools/droiddeck-esync/discover.py watch --state previous/watch-state.json "${info[@]}" --out watch-state.json
-
- - name: Start the pack builds
- if: steps.watch.outputs.changed != ''
- env:
- GH_TOKEN: ${{ github.token }}
- CHANGED: ${{ steps.watch.outputs.changed }}
- run: |
- set -euo pipefail
- read -r -a flavors <<<"$CHANGED"
- if [ "${#flavors[@]}" -gt 1 ]; then
- flavors=(all)
- fi
- for flavor in "${flavors[@]}"; do
- gh workflow run build-droiddeck-esync-packs.yml -R "$GITHUB_REPOSITORY" --ref main -f flavor="$flavor" -f publish=true
- echo "Started the pack build for $flavor" >> "$GITHUB_STEP_SUMMARY"
- done
-
- - name: Save the watch state
- env:
- GH_TOKEN: ${{ github.token }}
- run: |
- set -euo pipefail
- tag=droiddeck-esync-index
- if ! gh release view "$tag" -R "$GITHUB_REPOSITORY" >/dev/null 2>&1; then
- echo "::notice::$tag does not exist yet; the state is saved once the first index is published"
- exit 0
- fi
- if cmp -s watch-state.json previous/watch-state.json; then
- exit 0
- fi
- gh release upload "$tag" -R "$GITHUB_REPOSITORY" watch-state.json --clobber
diff --git a/.gitignore b/.gitignore
index 3240a2ea04..41551eec33 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,6 +14,7 @@ app/src/main/assets/linuxfs/
app/src/main/jniLibs/arm64-v8a/libproot.so
app/src/main/jniLibs/arm64-v8a/.proot-inputs
app/src/main/jniLibs/arm64-v8a/libproot-loader.so
+app/src/main/assets/droiddeck-esync/
# Kotlin compiler session files (build-tool state, never source).
.kotlin/
diff --git a/README.md b/README.md
index 003924efef..5e6cc4c390 100644
--- a/README.md
+++ b/README.md
@@ -33,4 +33,4 @@ Compatibility and performance vary by device; hardware validation is limited. De
## Credits and licence
-GPL-3.0. Runtime, shim, input, and controller work build on WinNative and Bannerlator (maxjivi05). LSFG frame generation is from the work of Camille LaVey and the [Eden](https://eden-emu.dev) emulator project, following [lsfg-vk](https://github.com/PancakeTAS/lsfg-vk), ported to WinNative and DroidDeck by [@maxjivi05](https://github.com/maxjivi05); it needs your own copy of [Lossless Scaling](https://store.steampowered.com/app/993090/) and ships none of its shaders. See [LICENSE](LICENSE). Steam and Proton belong to Valve Corporation; this project is not affiliated with Valve.
+GPL-3.0. Runtime, shim, input, and controller work build on WinNative and Bannerlator (maxjivi05). LSFG frame generation is from the work of Camille LaVey and the [Eden](https://eden-emu.dev) emulator project, following [lsfg-vk](https://github.com/PancakeTAS/lsfg-vk), ported to WinNative and DroidDeck by [@maxjivi05](https://github.com/maxjivi05); it needs your own copy of [Lossless Scaling](https://store.steampowered.com/app/993090/) and ships none of its shaders. x86 AppImages, and any whose own runtime cannot unpack them, are unpacked with [uruntime](https://github.com/VHSgunzo/uruntime) by VHSgunzo (MIT), shipped unmodified with its licence. See [LICENSE](LICENSE). Steam and Proton belong to Valve Corporation; this project is not affiliated with Valve.
diff --git a/app/build.gradle b/app/build.gradle
index 963e1db0e5..d6d2a4ab91 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -180,7 +180,7 @@ android {
// A stale local bundle can omit a newly required helper on a fresh runtime install.
def stageSessionScripts = tasks.register('stageSessionScripts', Copy) {
from(rootProject.file('tools/linuxfs/overlay')) {
- include 'usr/local/bin/bannerlator-*', 'usr/bin/**'
+ include 'usr/local/bin/droiddeck-*', 'usr/local/bin/steam-compatibility', 'usr/bin/**'
}
into(layout.projectDirectory.dir('src/main/assets/linuxfs'))
}
diff --git a/app/src/main/cpp/fakeinput_steam.cpp b/app/src/main/cpp/fakeinput_steam.cpp
index 3e0f18f6d4..d1c69d2a4d 100644
--- a/app/src/main/cpp/fakeinput_steam.cpp
+++ b/app/src/main/cpp/fakeinput_steam.cpp
@@ -54,7 +54,7 @@
#include
#include
-#define EXPORT __attribute__((visibility("default"))) extern "C"
+#define EXPORT extern "C" __attribute__((visibility("default")))
// glibc declares the request as unsigned long; bionic as int. The same source also serves the
// Linux runtime's preload (tools/linuxfs), where Steam and SDL run against glibc.
@@ -1729,10 +1729,11 @@ __attribute__((visibility("hidden"))) static bool deck_device_library(void *call
return !strncmp(name, "libudev.so", 10) || !strncmp(name, "libsystemd.so", 13);
}
+static int real_fstat(int fd, struct stat *buf);
+
__attribute__((visibility("hidden"))) static bool deck_mount_id_from_fdinfo(
int dirfd, const char *path, int flags, struct statx *buf) {
static auto real_openat = reinterpret_cast(dlsym(RTLD_NEXT, "openat"));
- static auto real_fstat = reinterpret_cast(dlsym(RTLD_NEXT, "fstat"));
int target;
if (!path || !*path) {
if (!(flags & AT_EMPTY_PATH)) return false;
@@ -1950,9 +1951,8 @@ EXPORT int openat(int dirfd, const char *pathname, int flags, ...) {
return fd;
}
-EXPORT int stat(const char *pathname, struct stat *statbuf) {
- static auto my_stat = reinterpret_cast(dlsym(RTLD_NEXT, "stat"));
-
+template
+static int fake_stat_path(const char *pathname, S *statbuf, Real real) {
if (is_withdrawn_pad_path(pathname) || (is_deck_hidraw_path(pathname) && !process_is_steam_client())) {
errno = ENOENT;
return -1;
@@ -1988,7 +1988,7 @@ EXPORT int stat(const char *pathname, struct stat *statbuf) {
}
}
- int ret = my_stat(pathname, statbuf);
+ int ret = real(pathname, statbuf);
if (ret == 0 && event && get_event_number(event) >= 0) {
statbuf->st_mode = (statbuf->st_mode & ~S_IFMT) | S_IFCHR;
@@ -2001,10 +2001,9 @@ EXPORT int stat(const char *pathname, struct stat *statbuf) {
return ret;
}
-EXPORT int fstat(int fd, struct stat *buf) {
- static auto my_fstat = reinterpret_cast(dlsym(RTLD_NEXT, "fstat"));
-
- int ret = my_fstat(fd, buf);
+template
+static int fake_stat_fd(int fd, S *buf, Real real) {
+ int ret = real(fd, buf);
std::lock_guard guard(controller_mutex());
if (ret == 0 && deck_map().count(fd)) {
@@ -2021,6 +2020,36 @@ EXPORT int fstat(int fd, struct stat *buf) {
return ret;
}
+static int real_stat(const char *pathname, struct stat *statbuf) {
+ static auto fn = reinterpret_cast(dlsym(RTLD_NEXT, "stat"));
+ if (fn) return fn(pathname, statbuf);
+#ifdef _STAT_VER
+ static auto xfn = reinterpret_cast(dlsym(RTLD_NEXT, "__xstat"));
+ if (xfn) return xfn(_STAT_VER, pathname, statbuf);
+#endif
+ errno = ENOSYS;
+ return -1;
+}
+
+static int real_fstat(int fd, struct stat *buf) {
+ static auto fn = reinterpret_cast(dlsym(RTLD_NEXT, "fstat"));
+ if (fn) return fn(fd, buf);
+#ifdef _STAT_VER
+ static auto xfn = reinterpret_cast(dlsym(RTLD_NEXT, "__fxstat"));
+ if (xfn) return xfn(_STAT_VER, fd, buf);
+#endif
+ errno = ENOSYS;
+ return -1;
+}
+
+EXPORT int stat(const char *pathname, struct stat *statbuf) {
+ return fake_stat_path(pathname, statbuf, real_stat);
+}
+
+EXPORT int fstat(int fd, struct stat *buf) {
+ return fake_stat_fd(fd, buf, real_fstat);
+}
+
EXPORT int access(const char *pathname, int mode) {
static auto my_access = reinterpret_cast(dlsym(RTLD_NEXT, "access"));
if (fake_uinput_enabled() && is_uinput_path(pathname)) return 0;
@@ -2866,31 +2895,57 @@ EXPORT int openat64(int dirfd, const char *pathname, int flags, ...) {
return openat(dirfd, pathname, flags, mode);
}
+static int real_stat64(const char *pathname, struct stat64 *statbuf) {
+ static auto fn = reinterpret_cast(dlsym(RTLD_NEXT, "stat64"));
+ if (fn) return fn(pathname, statbuf);
+#ifdef _STAT_VER
+ static auto xfn = reinterpret_cast(dlsym(RTLD_NEXT, "__xstat64"));
+ if (xfn) return xfn(_STAT_VER, pathname, statbuf);
+#endif
+ errno = ENOSYS;
+ return -1;
+}
+
+static int real_fstat64(int fd, struct stat64 *buf) {
+ static auto fn = reinterpret_cast(dlsym(RTLD_NEXT, "fstat64"));
+ if (fn) return fn(fd, buf);
+#ifdef _STAT_VER
+ static auto xfn = reinterpret_cast(dlsym(RTLD_NEXT, "__fxstat64"));
+ if (xfn) return xfn(_STAT_VER, fd, buf);
+#endif
+ errno = ENOSYS;
+ return -1;
+}
+
EXPORT int stat64(const char *pathname, struct stat64 *statbuf) {
- return stat(pathname, reinterpret_cast(statbuf));
+ return fake_stat_path(pathname, statbuf, real_stat64);
}
EXPORT int fstat64(int fd, struct stat64 *buf) {
- return fstat(fd, reinterpret_cast(buf));
+ return fake_stat_fd(fd, buf, real_fstat64);
}
EXPORT int __xstat(int version, const char *pathname, struct stat *statbuf) {
- (void)version;
- return stat(pathname, statbuf);
+ static auto real = reinterpret_cast(dlsym(RTLD_NEXT, "__xstat"));
+ if (!real) return stat(pathname, statbuf);
+ return fake_stat_path(pathname, statbuf, [version](const char *path, struct stat *buf) { return real(version, path, buf); });
}
EXPORT int __xstat64(int version, const char *pathname, struct stat64 *statbuf) {
- (void)version;
- return stat(pathname, reinterpret_cast(statbuf));
+ static auto real = reinterpret_cast(dlsym(RTLD_NEXT, "__xstat64"));
+ if (!real) return stat64(pathname, statbuf);
+ return fake_stat_path(pathname, statbuf, [version](const char *path, struct stat64 *buf) { return real(version, path, buf); });
}
EXPORT int __fxstat(int version, int fd, struct stat *buf) {
- (void)version;
- return fstat(fd, buf);
+ static auto real = reinterpret_cast(dlsym(RTLD_NEXT, "__fxstat"));
+ if (!real) return fstat(fd, buf);
+ return fake_stat_fd(fd, buf, [version](int f, struct stat *b) { return real(version, f, b); });
}
EXPORT int __fxstat64(int version, int fd, struct stat64 *buf) {
- (void)version;
- return fstat(fd, reinterpret_cast(buf));
+ static auto real = reinterpret_cast(dlsym(RTLD_NEXT, "__fxstat64"));
+ if (!real) return fstat64(fd, buf);
+ return fake_stat_fd(fd, buf, [version](int f, struct stat64 *b) { return real(version, f, b); });
}
#endif
diff --git a/app/src/main/cpp/waylandcomp/CMakeLists.txt b/app/src/main/cpp/waylandcomp/CMakeLists.txt
index d942fd6867..ddf19d05f7 100644
--- a/app/src/main/cpp/waylandcomp/CMakeLists.txt
+++ b/app/src/main/cpp/waylandcomp/CMakeLists.txt
@@ -4,7 +4,7 @@
# generated/ (no host wayland-scanner needed at app build time). Built by the app
# (add_subdirectory from ../CMakeLists.txt) and on its own by standalone/ for
# build-waylandcomp.yml.
-add_library(bannerwayland SHARED
+add_library(droiddeckwayland SHARED
src/compositor.c
src/vk_present.c
src/effects_chain.c
@@ -12,7 +12,7 @@ add_library(bannerwayland SHARED
src/sc_layer.c
src/ahb_swapchain.c
src/waylandcomp_jni.c
- src/banner_ext.c
+ src/droiddeck_ext.c
src/wl_dmabuf.c
src/wl_clipboard.c
src/wl_text_input.c
@@ -36,9 +36,9 @@ add_library(bannerwayland SHARED
src/framegen_jni.c
)
# Warnings on for the compositor's own C. They do not fail the build; they are there to be read.
-target_compile_options(bannerwayland PRIVATE
+target_compile_options(droiddeckwayland PRIVATE
$<$:-Wall -Wextra -Wno-unused-parameter -Wno-missing-field-initializers>)
-target_include_directories(bannerwayland PRIVATE
+target_include_directories(droiddeckwayland PRIVATE
generated
prebuilt/include
src
@@ -54,56 +54,56 @@ target_include_directories(bannerwayland PRIVATE
# framegen tree and the vendored DXBC translator (thirdparty/dxbc, for the LSFG cache format),
# which only the app build has: the standalone build (standalone/) gets the stub, which reports
# every engine unavailable and generates nothing.
-set(BANNER_FRAMEGEN_LSFG_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../framegen/lsfg)
-set(BANNER_FRAMEGEN_WINFG_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../framegen/winfg)
-if (TARGET dxbc AND EXISTS ${BANNER_FRAMEGEN_LSFG_DIR}/lsfg_engine.cpp
- AND EXISTS ${BANNER_FRAMEGEN_WINFG_DIR}/winfg_engine.cpp)
- message(STATUS "bannerwayland: frame-generation engines built in (LSFG Native, Win-FG Native)")
- target_sources(bannerwayland PRIVATE
+set(DROIDDECK_FRAMEGEN_LSFG_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../framegen/lsfg)
+set(DROIDDECK_FRAMEGEN_WINFG_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../framegen/winfg)
+if (TARGET dxbc AND EXISTS ${DROIDDECK_FRAMEGEN_LSFG_DIR}/lsfg_engine.cpp
+ AND EXISTS ${DROIDDECK_FRAMEGEN_WINFG_DIR}/winfg_engine.cpp)
+ message(STATUS "droiddeckwayland: frame-generation engines built in (LSFG Native, Win-FG Native)")
+ target_sources(droiddeckwayland PRIVATE
src/framegen_engine.cpp
- ${BANNER_FRAMEGEN_LSFG_DIR}/lsfg_probe.cpp
- ${BANNER_FRAMEGEN_LSFG_DIR}/lsfg_dll.cpp
- ${BANNER_FRAMEGEN_LSFG_DIR}/lsfg_dxbc.cpp
- ${BANNER_FRAMEGEN_LSFG_DIR}/lsfg_vkd.cpp
- ${BANNER_FRAMEGEN_LSFG_DIR}/lsfg_common.cpp
- ${BANNER_FRAMEGEN_LSFG_DIR}/lsfg_shaders.cpp
- ${BANNER_FRAMEGEN_LSFG_DIR}/lsfg_mipmaps.cpp
- ${BANNER_FRAMEGEN_LSFG_DIR}/lsfg_alpha.cpp
- ${BANNER_FRAMEGEN_LSFG_DIR}/lsfg_beta.cpp
- ${BANNER_FRAMEGEN_LSFG_DIR}/lsfg_gamma.cpp
- ${BANNER_FRAMEGEN_LSFG_DIR}/lsfg_delta.cpp
- ${BANNER_FRAMEGEN_LSFG_DIR}/lsfg_generate.cpp
- ${BANNER_FRAMEGEN_LSFG_DIR}/lsfg_chain.cpp
- ${BANNER_FRAMEGEN_LSFG_DIR}/lsfg_pacer.cpp
- ${BANNER_FRAMEGEN_LSFG_DIR}/lsfg_engine.cpp
- ${BANNER_FRAMEGEN_LSFG_DIR}/lsfg_governor.cpp
+ ${DROIDDECK_FRAMEGEN_LSFG_DIR}/lsfg_probe.cpp
+ ${DROIDDECK_FRAMEGEN_LSFG_DIR}/lsfg_dll.cpp
+ ${DROIDDECK_FRAMEGEN_LSFG_DIR}/lsfg_dxbc.cpp
+ ${DROIDDECK_FRAMEGEN_LSFG_DIR}/lsfg_vkd.cpp
+ ${DROIDDECK_FRAMEGEN_LSFG_DIR}/lsfg_common.cpp
+ ${DROIDDECK_FRAMEGEN_LSFG_DIR}/lsfg_shaders.cpp
+ ${DROIDDECK_FRAMEGEN_LSFG_DIR}/lsfg_mipmaps.cpp
+ ${DROIDDECK_FRAMEGEN_LSFG_DIR}/lsfg_alpha.cpp
+ ${DROIDDECK_FRAMEGEN_LSFG_DIR}/lsfg_beta.cpp
+ ${DROIDDECK_FRAMEGEN_LSFG_DIR}/lsfg_gamma.cpp
+ ${DROIDDECK_FRAMEGEN_LSFG_DIR}/lsfg_delta.cpp
+ ${DROIDDECK_FRAMEGEN_LSFG_DIR}/lsfg_generate.cpp
+ ${DROIDDECK_FRAMEGEN_LSFG_DIR}/lsfg_chain.cpp
+ ${DROIDDECK_FRAMEGEN_LSFG_DIR}/lsfg_pacer.cpp
+ ${DROIDDECK_FRAMEGEN_LSFG_DIR}/lsfg_engine.cpp
+ ${DROIDDECK_FRAMEGEN_LSFG_DIR}/lsfg_governor.cpp
# The Lossless.dll import (validate / extract / cache) for the app's LsfgNative.
- ${BANNER_FRAMEGEN_LSFG_DIR}/lsfg_jni.cpp
- ${BANNER_FRAMEGEN_WINFG_DIR}/framegen.cpp
- ${BANNER_FRAMEGEN_WINFG_DIR}/winfg_vkd.cpp
- ${BANNER_FRAMEGEN_WINFG_DIR}/winfg_engine.cpp
+ ${DROIDDECK_FRAMEGEN_LSFG_DIR}/lsfg_jni.cpp
+ ${DROIDDECK_FRAMEGEN_WINFG_DIR}/framegen.cpp
+ ${DROIDDECK_FRAMEGEN_WINFG_DIR}/winfg_vkd.cpp
+ ${DROIDDECK_FRAMEGEN_WINFG_DIR}/winfg_engine.cpp
)
- target_include_directories(bannerwayland PRIVATE
+ target_include_directories(droiddeckwayland PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/.. # as the frame-generation engines see it
${CMAKE_CURRENT_SOURCE_DIR}/../framegen # VulkanRendererContext.h (VkTable), lsfg/, winfg/
)
- target_compile_options(bannerwayland PRIVATE
+ target_compile_options(droiddeckwayland PRIVATE
$<$:-std=c++17 -fvisibility=hidden>)
- target_compile_definitions(bannerwayland PRIVATE
+ target_compile_definitions(droiddeckwayland PRIVATE
WINFG_UPSTREAM="${WINFG_UPSTREAM}"
WINFG_CHAIN_HASH="${WINFG_CHAIN_HASH}"
)
- target_link_libraries(bannerwayland dxbc atomic)
+ target_link_libraries(droiddeckwayland dxbc atomic)
else()
- message(STATUS "bannerwayland: frame-generation engines NOT built in (standalone build): stub")
- target_sources(bannerwayland PRIVATE src/framegen_engine_stub.c)
+ message(STATUS "droiddeckwayland: frame-generation engines NOT built in (standalone build): stub")
+ target_sources(droiddeckwayland PRIVATE src/framegen_engine_stub.c)
endif()
add_library(wayland-server SHARED IMPORTED)
set_target_properties(wayland-server PROPERTIES IMPORTED_LOCATION
${CMAKE_CURRENT_SOURCE_DIR}/prebuilt/lib/libwayland-server.so)
# Vulkan is loaded at runtime via adrenotools (Turnip), not linked directly - so the
# compositor uses Turnip's driver, which supports dmabuf import (drm_format_modifier).
-target_link_libraries(bannerwayland
+target_link_libraries(droiddeckwayland
wayland-server
adrenotools
dl
diff --git a/app/src/main/cpp/waylandcomp/ZERO_COPY_SPIKE.md b/app/src/main/cpp/waylandcomp/ZERO_COPY_SPIKE.md
index f4f7ea50a8..37b08b2334 100644
--- a/app/src/main/cpp/waylandcomp/ZERO_COPY_SPIKE.md
+++ b/app/src/main/cpp/waylandcomp/ZERO_COPY_SPIKE.md
@@ -29,7 +29,7 @@ the dma-buf fd through `zwp_linux_dmabuf_v1` as today (so the blit path stays as
The host half - one `ASurfaceControl` layer per fullscreen window, geometry from the fullscreen
mode, release fences from `ASurfaceTransaction_setOnComplete`, black base surface, HUD/pointer as
Android views above - is implemented in this branch as a gated prototype (`sc_layer.c`,
-`BANNER_WAYLAND_ZERO_COPY=1`) with a compositor-owned AHB pool and one blit, so the
+`DROIDDECK_WAYLAND_ZERO_COPY=1`) with a compositor-owned AHB pool and one blit, so the
SurfaceFlinger side can be measured on the device before the driver work starts.
---
@@ -240,13 +240,13 @@ Prerequisite: a build of this branch, container on Wayland, the AIO Graphics Tes
D3D12 tabs) as the workload, session log in `Download/Wayland-logs/`.
0. **UBWC modifier A/B (no layers).** Done on `feat/wayland-ubwc` (advertised when the compositor's
- driver imports it, `BANNER_WAYLAND_UBWC=0` = old linear-only list; see `WAYLAND_RUNTIME.md`
+ driver imports it, `DROIDDECK_WAYLAND_UBWC=0` = old linear-only list; see `WAYLAND_RUNTIME.md`
"Compressed (UBWC) game buffers"). Run the AIO Vulkan/D3D12 with and without. Expect
`vulkan: … is presenting GPU frames through Wayland: WxH, format XB24, tiled (zero-copy)` and
no `dmabuf import failed`. Records how much of the 20 % is the linear swapchain alone.
-1. **Layer mode smoke.** Put `BANNER_WAYLAND_ZERO_COPY=1` in the container's environment
+1. **Layer mode smoke.** Put `DROIDDECK_WAYLAND_ZERO_COPY=1` in the container's environment
variables, launch the AIO fullscreen. Expected log lines (tag `layer`):
- `SurfaceControl "banner_wayland_game" created as a child of the screen surface`,
+ `SurfaceControl "droiddeck_wayland_game" created as a child of the screen surface`,
`pool buffer 1920x1080 UBWC (QCOM_COMPRESSED), stride 1920 px (gralloc handle 2 fds / N ints)`
(or `linear` after `import of a UBWC … failed` - also a result: it tells whether the compositor
Turnip accepts gralloc's UBWC pitch), `geometry: buffer 0,0-1920,1080 -> screen …`,
@@ -254,7 +254,7 @@ D3D12 tabs) as the workload, session log in `Download/Wayland-logs/`.
and the probe line `kernel exports sync_file fences from the game's dma-buf …` or
`DMA_BUF_IOCTL_EXPORT_SYNC_FILE … failed (…)`. Picture correct, HUD and pointer on top, fullscreen
mode changes move the layer (`geometry:` lines).
-2. **Composition type.** With the AIO running: `dumpsys SurfaceFlinger | grep -A3 banner_wayland_game`
+2. **Composition type.** With the AIO running: `dumpsys SurfaceFlinger | grep -A3 droiddeck_wayland_game`
and the `GPU_TARGET` line of the pipe table. DEVICE/DEVICE on the game layer with an empty GPU
target = the DPU does the scaling; CLIENT = no gain on this panel orientation → try the
handheld's native orientation / a resolution equal to the panel's.
@@ -271,7 +271,7 @@ harden: async fence instead of CPU wait, per-window layers, presentation feedbac
`getLatchTime`); option (a) WSI + protocol + wcp = 2–3 days + 1 day device proving; option (c) =
3–4 days + the same proving; (b) = not buildable.
-## 6. What the prototype in this branch does (`BANNER_WAYLAND_ZERO_COPY=1`)
+## 6. What the prototype in this branch does (`DROIDDECK_WAYLAND_ZERO_COPY=1`)
Files: `src/sc_layer.{c,h}` (new), `src/vk_present.{c,h}` (`vkp_image_import_dmabuf` with a
blit-destination role, `vkp_blit_image`, `vkp_update_map`, `vkp_map_draw`, `vkp_window`,
diff --git a/app/src/main/cpp/waylandcomp/src/ahb_swapchain.c b/app/src/main/cpp/waylandcomp/src/ahb_swapchain.c
index a697ab19b4..4a981f1ee1 100644
--- a/app/src/main/cpp/waylandcomp/src/ahb_swapchain.c
+++ b/app/src/main/cpp/waylandcomp/src/ahb_swapchain.c
@@ -2,8 +2,8 @@
* See ahb_swapchain.h and ZERO_COPY_SPIKE.md. */
#define _GNU_SOURCE
#include "ahb_swapchain.h"
-#include "banner_color.h"
-#include "banner_ext.h"
+#include "droiddeck_color.h"
+#include "droiddeck_ext.h"
#include "sc_layer.h"
#include "vk_present.h"
#include "banner-ahb-v1-server-protocol.h"
@@ -22,10 +22,10 @@
#define MOD_QCOM_COMPRESSED 0x0500000000000001ULL /* DRM_FORMAT_MOD_QCOM_COMPRESSED (UBWC) */
/* linux/dma-buf.h (not in the NDK sysroot's older headers): sync_file export / import. */
-struct banner_dma_buf_sync_file { uint32_t flags; int32_t fd; };
-#define BANNER_DMA_BUF_SYNC_READ 1u
-#define BANNER_DMA_BUF_IOCTL_EXPORT_SYNC_FILE _IOWR('b', 2, struct banner_dma_buf_sync_file)
-#define BANNER_DMA_BUF_IOCTL_IMPORT_SYNC_FILE _IOW('b', 3, struct banner_dma_buf_sync_file)
+struct droiddeck_dma_buf_sync_file { uint32_t flags; int32_t fd; };
+#define DROIDDECK_DMA_BUF_SYNC_READ 1u
+#define DROIDDECK_DMA_BUF_IOCTL_EXPORT_SYNC_FILE _IOWR('b', 2, struct droiddeck_dma_buf_sync_file)
+#define DROIDDECK_DMA_BUF_IOCTL_IMPORT_SYNC_FILE _IOW('b', 3, struct droiddeck_dma_buf_sync_file)
extern volatile int g_zero_copy;
@@ -90,9 +90,9 @@ static void buf_free(struct ahb_buf *ab) {
if (ab->fence_src) { wl_event_source_remove(ab->fence_src); ab->fence_src = NULL; }
if (ab->fence_fd >= 0) { close(ab->fence_fd); ab->fence_fd = -1; }
wl_list_remove(&ab->link);
- *banner_dmabuf_ahb_slot(ab->b) = NULL;
+ *droiddeck_dmabuf_ahb_slot(ab->b) = NULL;
AHardwareBuffer_release(ab->ahb);
- banner_dmabuf_unref(ab->b);
+ droiddeck_dmabuf_unref(ab->b);
free(ab);
}
@@ -113,7 +113,7 @@ static void on_buffer_resource_destroyed(struct wl_listener *l, void *data) {
static void send_deferred_release(struct ahb_buf *ab) {
if (ab->release_pending && ab->resource)
- banner_release_buffer(ab->surface, ab->resource, ab->surface != NULL, ab->deferred_ns);
+ droiddeck_release_buffer(ab->surface, ab->resource, ab->surface != NULL, ab->deferred_ns);
ab->release_pending = 0;
ab->surface = NULL;
}
@@ -138,14 +138,14 @@ static void handle_released(uint64_t id, int fd) {
if (!ab) { if (fd >= 0) close(fd); return; }
ab->on_layer = 0;
if (fd >= 0) {
- struct banner_dma_buf_sync_file imp = {.flags = BANNER_DMA_BUF_SYNC_READ, .fd = fd};
- int dmabuf_fd = banner_dmabuf_fd(ab->b);
- if (dmabuf_fd >= 0 && ioctl(dmabuf_fd, BANNER_DMA_BUF_IOCTL_IMPORT_SYNC_FILE, &imp) == 0) {
+ struct droiddeck_dma_buf_sync_file imp = {.flags = DROIDDECK_DMA_BUF_SYNC_READ, .fd = fd};
+ int dmabuf_fd = droiddeck_dmabuf_fd(ab->b);
+ if (dmabuf_fd >= 0 && ioctl(dmabuf_fd, DROIDDECK_DMA_BUF_IOCTL_IMPORT_SYNC_FILE, &imp) == 0) {
close(fd);
} else {
if (!g_import_failed_logged) {
g_import_failed_logged = 1;
- banner_log("layer", "zero-copy: DMA_BUF_IOCTL_IMPORT_SYNC_FILE failed (%s): releases wait for the display's fence here instead",
+ droiddeck_log("layer", "zero-copy: DMA_BUF_IOCTL_IMPORT_SYNC_FILE failed (%s): releases wait for the display's fence here instead",
strerror(errno));
}
/* Wait it out in the event loop (a sync_file is readable once signalled). */
@@ -196,23 +196,23 @@ void ahb_swapchain_layer_released(void *token, int release_fd) {
/* ---- present */
int ahb_swapchain_has_ahb(const struct dmabuf_buffer *b) {
- return b && *banner_dmabuf_ahb_slot((struct dmabuf_buffer *)b) != NULL;
+ return b && *droiddeck_dmabuf_ahb_slot((struct dmabuf_buffer *)b) != NULL;
}
int ahb_swapchain_present(struct dmabuf_buffer *b, struct surface *s, int scene_w, int scene_h) {
- struct ahb_buf *ab = b ? *banner_dmabuf_ahb_slot(b) : NULL;
+ struct ahb_buf *ab = b ? *droiddeck_dmabuf_ahb_slot(b) : NULL;
if (!ab) return -1;
- int dmabuf_fd = banner_dmabuf_fd(b);
+ int dmabuf_fd = droiddeck_dmabuf_fd(b);
/* Acquire fence: the game's render fence, which its driver put into the dma-buf before the
* commit (Mesa's implicit sync). The display waits on it, not the CPU. */
int acquire = -1;
- struct banner_dma_buf_sync_file exp = {.flags = BANNER_DMA_BUF_SYNC_READ, .fd = -1};
- if (dmabuf_fd >= 0 && ioctl(dmabuf_fd, BANNER_DMA_BUF_IOCTL_EXPORT_SYNC_FILE, &exp) == 0 && exp.fd >= 0) {
+ struct droiddeck_dma_buf_sync_file exp = {.flags = DROIDDECK_DMA_BUF_SYNC_READ, .fd = -1};
+ if (dmabuf_fd >= 0 && ioctl(dmabuf_fd, DROIDDECK_DMA_BUF_IOCTL_EXPORT_SYNC_FILE, &exp) == 0 && exp.fd >= 0) {
acquire = exp.fd;
} else if (dmabuf_fd >= 0) {
if (!g_export_failed_logged) {
g_export_failed_logged = 1;
- banner_log("layer", "zero-copy: DMA_BUF_IOCTL_EXPORT_SYNC_FILE failed (%s): waiting for each frame on the CPU instead",
+ droiddeck_log("layer", "zero-copy: DMA_BUF_IOCTL_EXPORT_SYNC_FILE failed (%s): waiting for each frame on the CPU instead",
strerror(errno));
}
struct pollfd p = {.fd = dmabuf_fd, .events = POLLIN}; /* readable = the writers are done */
@@ -220,7 +220,7 @@ int ahb_swapchain_present(struct dmabuf_buffer *b, struct surface *s, int scene_
do { r = poll(&p, 1, 100); } while (r < 0 && errno == EINTR);
}
int r = sc_layer_present_ahb(ab->ahb, ab->w, ab->h, acquire, (void *)(uintptr_t)ab->id, scene_w, scene_h,
- s ? banner_surface_color(s) : NULL, ab->format);
+ s ? droiddeck_surface_color(s) : NULL, ab->format);
if (r < 0) return -1;
if (r == 1) return 0; /* nothing of it on screen: not on the layer, nothing to release later */
if (!ab->on_layer) {
@@ -231,8 +231,8 @@ int ahb_swapchain_present(struct dmabuf_buffer *b, struct surface *s, int scene_
if (s && g_announced != s) {
char name[160];
g_announced = s;
- banner_surface_describe(s, name, sizeof(name));
- banner_log("layer", "zero-copy: presenting %s without a copy", name);
+ droiddeck_surface_describe(s, name, sizeof(name));
+ droiddeck_log("layer", "zero-copy: presenting %s without a copy", name);
}
return 0;
}
@@ -245,7 +245,7 @@ int ahb_swapchain_last_frame_age_ms(void) {
}
int ahb_swapchain_defer_release(struct dmabuf_buffer *b, struct wl_resource *buffer, struct surface *s, int paced) {
- struct ahb_buf *ab = b ? *banner_dmabuf_ahb_slot(b) : NULL;
+ struct ahb_buf *ab = b ? *droiddeck_dmabuf_ahb_slot(b) : NULL;
if (!ab || !ab->on_layer || !buffer || ab->resource != buffer) return 0;
ab->release_pending = 1;
ab->deferred_ns = now_ns();
@@ -268,7 +268,7 @@ unsigned ahb_swapchain_stats_take(void) {
int ahb_swapchain_advertised(void) { return g_advertised; }
uint32_t ahb_swapchain_ahb_format(const struct dmabuf_buffer *b) {
- struct ahb_buf *ab = b ? *banner_dmabuf_ahb_slot((struct dmabuf_buffer *)b) : NULL;
+ struct ahb_buf *ab = b ? *droiddeck_dmabuf_ahb_slot((struct dmabuf_buffer *)b) : NULL;
return ab ? ab->format : 0;
}
@@ -279,14 +279,14 @@ static void ahb_destroy(struct wl_client *c, struct wl_resource *r) { wl_resourc
static void ahb_attach(struct wl_client *c, struct wl_resource *r, struct wl_resource *buffer, int32_t sock,
uint32_t width, uint32_t height, uint32_t stride, uint32_t mod_hi, uint32_t mod_lo,
uint32_t image_count) {
- struct dmabuf_buffer *b = banner_dmabuf_from_resource(buffer);
+ struct dmabuf_buffer *b = droiddeck_dmabuf_from_resource(buffer);
uint64_t modifier = ((uint64_t)mod_hi << 32) | mod_lo;
if (!b) {
- banner_log("layer", "zero-copy: %s attached an AHardwareBuffer to a non-dma-buf wl_buffer, ignored", banner_client_name(c));
+ droiddeck_log("layer", "zero-copy: %s attached an AHardwareBuffer to a non-dma-buf wl_buffer, ignored", droiddeck_client_name(c));
close(sock);
return;
}
- void **slot = banner_dmabuf_ahb_slot(b);
+ void **slot = droiddeck_dmabuf_ahb_slot(b);
if (*slot) { close(sock); return; } /* once per buffer */
/* The handle was written into the socket before the request was sent; a short wait is just
@@ -298,17 +298,17 @@ static void ahb_attach(struct wl_client *c, struct wl_resource *r, struct wl_res
int rc = pr > 0 ? AHardwareBuffer_recvHandleFromUnixSocket(sock, &ahb) : -1;
close(sock);
if (rc != 0 || !ahb) {
- banner_log("layer", "zero-copy: receiving %s's AHardwareBuffer failed (%s)", banner_client_name(c),
+ droiddeck_log("layer", "zero-copy: receiving %s's AHardwareBuffer failed (%s)", droiddeck_client_name(c),
pr > 0 ? "recvHandleFromUnixSocket" : "nothing on the socket");
return;
}
AHardwareBuffer_Desc d;
AHardwareBuffer_describe(ahb, &d);
int bw, bh;
- banner_dmabuf_size(b, &bw, &bh);
+ droiddeck_dmabuf_size(b, &bw, &bh);
if ((int)d.width != bw || (int)d.height != bh || (int)width != bw || (int)height != bh) {
- banner_log("layer", "zero-copy: %s's AHardwareBuffer is %ux%u but its wl_buffer %dx%d, ignored",
- banner_client_name(c), d.width, d.height, bw, bh);
+ droiddeck_log("layer", "zero-copy: %s's AHardwareBuffer is %ux%u but its wl_buffer %dx%d, ignored",
+ droiddeck_client_name(c), d.width, d.height, bw, bh);
AHardwareBuffer_release(ahb);
return;
}
@@ -317,7 +317,7 @@ static void ahb_attach(struct wl_client *c, struct wl_resource *r, struct wl_res
if (!ab) { AHardwareBuffer_release(ahb); wl_client_post_no_memory(c); return; }
ab->id = g_next_id++;
ab->b = b;
- banner_dmabuf_ref(b);
+ droiddeck_dmabuf_ref(b);
ab->ahb = ahb;
ab->w = bw; ab->h = bh;
ab->stride = d.stride ? d.stride : stride;
@@ -335,8 +335,8 @@ static void ahb_attach(struct wl_client *c, struct wl_resource *r, struct wl_res
if (g_last_chain.client != c || g_last_chain.w != bw || g_last_chain.h != bh ||
g_last_chain.image_count != image_count || g_last_chain.modifier != modifier || g_last_chain.format != d.format) {
g_last_chain = (struct chain_seen){c, bw, bh, image_count, modifier, d.format};
- banner_log("layer", "zero-copy: AHB swapchain from %s (%u images, %dx%d, %s, %s, stride %u px)", banner_client_name(c),
- image_count, bw, bh, banner_ahb_format_name(d.format), modifier == MOD_QCOM_COMPRESSED ? "UBWC (QCOM_COMPRESSED)"
+ droiddeck_log("layer", "zero-copy: AHB swapchain from %s (%u images, %dx%d, %s, %s, stride %u px)", droiddeck_client_name(c),
+ image_count, bw, bh, droiddeck_ahb_format_name(d.format), modifier == MOD_QCOM_COMPRESSED ? "UBWC (QCOM_COMPRESSED)"
: modifier == 0 ? "linear" : "unknown modifier", ab->stride);
}
}
@@ -363,7 +363,7 @@ static void bind_ahb(struct wl_client *c, void *data, uint32_t ver, uint32_t id)
/* One line per program, not per surface-format query (each binds its own). */
if (last_named != c) {
last_named = c;
- banner_log("layer", "zero-copy: %s bound banner_ahb_v1 version %u (%s)", banner_client_name(c), ver,
+ droiddeck_log("layer", "zero-copy: %s bound banner_ahb_v1 version %u (%s)", droiddeck_client_name(c), ver,
ver >= 2 ? "follows the live switch" : "version 1: decides from its launch environment only");
}
}
@@ -372,7 +372,7 @@ void ahb_swapchain_set_mode(int on, int live) {
on = on ? 1 : 0;
g_zero_copy = on;
if (!g_advertised) {
- if (live) banner_log("layer", "zero-copy switched %s from the drawer, but no display layer is available on this device: no change",
+ if (live) droiddeck_log("layer", "zero-copy switched %s from the drawer, but no display layer is available on this device: no change",
on ? "on" : "off");
return;
}
@@ -390,37 +390,37 @@ void ahb_swapchain_set_mode(int on, int live) {
memset(&g_last_chain, 0, sizeof(g_last_chain));
g_announced = NULL;
if (live)
- banner_log("layer", "zero-copy switched %s from the drawer: %d bound program%s told to rebuild their swapchains%s",
+ droiddeck_log("layer", "zero-copy switched %s from the drawer: %d bound program%s told to rebuild their swapchains%s",
on ? "on" : "off", told, told == 1 ? "" : "s",
on ? "; frames go on the display layer once the new gralloc swapchain is up"
: "; gralloc frames still in flight stay on the layer (or take the copy path) until then");
else
- banner_log("layer", "zero-copy: %s at launch (%s)", on ? "on" : "off",
- on ? "BANNER_WAYLAND_ZERO_COPY=1: games present their own gralloc buffers on the display layer"
+ droiddeck_log("layer", "zero-copy: %s at launch (%s)", on ? "on" : "off",
+ on ? "DROIDDECK_WAYLAND_ZERO_COPY=1: games present their own gralloc buffers on the display layer"
: "the drawer's Zero-copy presentation switch turns it on live");
- if (live) wl_display_flush_clients(banner_get_display());
- banner_request_redraw();
+ if (live) wl_display_flush_clients(droiddeck_get_display());
+ droiddeck_request_redraw();
}
void ahb_swapchain_init(struct wl_display *display) {
wl_list_init(&g_bufs);
wl_list_init(&g_clients);
if (!sc_layer_available()) {
- banner_log("layer", "zero-copy: no display layer on this device (see the line above): banner_ahb_v1 not advertised");
+ droiddeck_log("layer", "zero-copy: no display layer on this device (see the line above): banner_ahb_v1 not advertised");
return;
}
g_loop = wl_display_get_event_loop(display);
if (pipe2(g_rel_pipe, O_CLOEXEC | O_NONBLOCK) != 0) {
- banner_log("error", "zero-copy: release pipe creation failed (%s); zero-copy presents disabled", strerror(errno));
+ droiddeck_log("error", "zero-copy: release pipe creation failed (%s); zero-copy presents disabled", strerror(errno));
g_rel_pipe[0] = g_rel_pipe[1] = -1;
return;
}
wl_event_loop_add_fd(g_loop, g_rel_pipe[0], WL_EVENT_READABLE, on_release_pipe, NULL);
if (!wl_global_create(display, &banner_ahb_v1_interface, 2, NULL, bind_ahb)) {
- banner_log("error", "zero-copy: banner_ahb_v1 global creation failed");
+ droiddeck_log("error", "zero-copy: banner_ahb_v1 global creation failed");
return;
}
g_advertised = 1;
- banner_log("layer", "zero-copy: banner_ahb_v1 version 2 advertised (games built for it present their own gralloc buffers while the switch is on)");
+ droiddeck_log("layer", "zero-copy: banner_ahb_v1 version 2 advertised (games built for it present their own gralloc buffers while the switch is on)");
ahb_swapchain_set_mode(g_zero_copy, 0);
}
diff --git a/app/src/main/cpp/waylandcomp/src/ahb_swapchain.h b/app/src/main/cpp/waylandcomp/src/ahb_swapchain.h
index fff1bf2f7b..2c72a12b52 100644
--- a/app/src/main/cpp/waylandcomp/src/ahb_swapchain.h
+++ b/app/src/main/cpp/waylandcomp/src/ahb_swapchain.h
@@ -1,7 +1,7 @@
#ifndef AHB_SWAPCHAIN_H
#define AHB_SWAPCHAIN_H
/*
- * Zero-copy game frames (layer mode, BANNER_WAYLAND_ZERO_COPY=1 at launch, the drawer's "Zero-copy
+ * Zero-copy game frames (layer mode, DROIDDECK_WAYLAND_ZERO_COPY=1 at launch, the drawer's "Zero-copy
* presentation" switch live): the guest half of the design in ZERO_COPY_SPIKE.md. Our Wayland Turnip
* (banners-turnip-wayland, patches/wayland/banner_ahb_wsi.py) binds the private global banner_ahb_v1
* (version 2), which this compositor advertises on every session where a display layer is possible,
@@ -63,21 +63,21 @@ uint32_t ahb_swapchain_ahb_format(const struct dmabuf_buffer *b);
void ahb_swapchain_layer_released(void *token, int release_fd);
/* ---- ahb_swapchain.c -> compositor.c (hooks) */
-struct dmabuf_buffer *banner_dmabuf_from_resource(struct wl_resource *buffer);
-int banner_dmabuf_fd(const struct dmabuf_buffer *b); /* plane 0's dma-buf */
-void banner_dmabuf_size(const struct dmabuf_buffer *b, int *w, int *h);
-void **banner_dmabuf_ahb_slot(struct dmabuf_buffer *b); /* this module's per-buffer state */
-void banner_dmabuf_ref(struct dmabuf_buffer *b);
-void banner_dmabuf_unref(struct dmabuf_buffer *b);
+struct dmabuf_buffer *droiddeck_dmabuf_from_resource(struct wl_resource *buffer);
+int droiddeck_dmabuf_fd(const struct dmabuf_buffer *b); /* plane 0's dma-buf */
+void droiddeck_dmabuf_size(const struct dmabuf_buffer *b, int *w, int *h);
+void **droiddeck_dmabuf_ahb_slot(struct dmabuf_buffer *b); /* this module's per-buffer state */
+void droiddeck_dmabuf_ref(struct dmabuf_buffer *b);
+void droiddeck_dmabuf_unref(struct dmabuf_buffer *b);
/* Give a wl_buffer back to its client now (paced = 0) or on the FPS limiter's cadence (s != NULL).
* since_ns = when the compositor let go of it (CLOCK_MONOTONIC; the perf line's release latency). */
-void banner_release_buffer(struct surface *s, struct wl_resource *buffer, int paced, int64_t since_ns);
+void droiddeck_release_buffer(struct surface *s, struct wl_resource *buffer, int paced, int64_t since_ns);
/* Redraw the scene on the next tick (the present path may have changed). */
-void banner_request_redraw(void);
+void droiddeck_request_redraw(void);
/* "" (program) of the window a surface belongs to, for the log. */
-void banner_surface_describe(const struct surface *s, char *out, size_t size);
-/* The surface's current image description (banner_color.h), NULL = none / HDR gate closed. */
-struct banner_color;
-const struct banner_color *banner_surface_color(const struct surface *s);
+void droiddeck_surface_describe(const struct surface *s, char *out, size_t size);
+/* The surface's current image description (droiddeck_color.h), NULL = none / HDR gate closed. */
+struct droiddeck_color;
+const struct droiddeck_color *droiddeck_surface_color(const struct surface *s);
#endif
diff --git a/app/src/main/cpp/waylandcomp/src/banner_ext.h b/app/src/main/cpp/waylandcomp/src/banner_ext.h
deleted file mode 100644
index f982b95332..0000000000
--- a/app/src/main/cpp/waylandcomp/src/banner_ext.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Interface between compositor.c and the extension modules that live in their own files:
- * wl_clipboard.c wl_data_device_manager + zwlr_data_control_manager_v1 (selection only)
- * wl_text_input.c zwp_text_input_manager_v3 (host IME / soft keyboard)
- * wl_toplevel_icon.c xdg_toplevel_icon_manager_v1 (accepted, not rendered)
- * banner_ext.c the host→compositor message queue shared by the modules
- * Everything here runs on the compositor (dispatch) thread unless noted.
- */
-#pragma once
-#include
-#include
-
-void banner_log(const char *tag, const char *fmt, ...);
-
-/* ---- compositor.c → modules */
-void banner_ext_init(struct wl_display *display); /* creates the globals + host queue */
-void banner_clipboard_keyboard_focus(struct wl_client *client); /* keyboard focus moved; NULL = none */
-void banner_text_input_refocus(void); /* the text-input target may have changed */
-void banner_text_input_surface_gone(struct wl_resource *surface);
-
-/* ---- modules → compositor.c */
-const char *banner_client_name(struct wl_client *client);
-struct wl_display *banner_get_display(void);
-/* The surface text input follows (the last clicked window, else the topmost program window). */
-struct wl_resource *banner_ime_target(void);
-/* Scene (virtual desktop) origin of a toplevel surface; 0,0 when unknown. */
-void banner_surface_scene_origin(struct wl_resource *surface, int *x, int *y);
-/* Deliver a key press/release through the wl_keyboard path as if typed. */
-void banner_inject_key(uint32_t evdev, int pressed);
-
-/* ---- modules → app (JNI upcalls; waylandcomp_jni.c) */
-void banner_on_clipboard_text(const char *utf8, int len);
-void banner_on_text_input(int enabled, const char *program, int x, int y, int w, int h);
-
-/* ---- app → modules (callable from any thread; queued to the compositor thread) */
-void banner_host_clipboard_text(const char *utf8, int len); /* len 0 = clear */
-void banner_host_text_commit(const char *utf8, int len);
-void banner_host_text_preedit(const char *utf8, int len, int cursor_begin, int cursor_end);
-void banner_host_text_delete(int before, int after);
-void banner_host_zero_copy(int on, int live); /* the drawer's zero-copy switch (ahb_swapchain_set_mode) */
-void banner_host_hdr_output(int on); /* the drawer's HDR output switch (banner_color_set_output) */
-
-/* ---- module internals reached through the queue (banner_ext.c → modules) */
-void clipboard_init(struct wl_display *display);
-void clipboard_host_text(char *utf8, size_t len); /* takes ownership of utf8 */
-void text_input_init(struct wl_display *display);
-void text_input_host_commit(const char *utf8, size_t len);
-void text_input_host_preedit(const char *utf8, size_t len, int cursor_begin, int cursor_end);
-void text_input_host_delete(int before, int after);
-void toplevel_icon_init(struct wl_display *display);
diff --git a/app/src/main/cpp/waylandcomp/src/blend_pass.c b/app/src/main/cpp/waylandcomp/src/blend_pass.c
index 471eedc9ae..842287b07b 100644
--- a/app/src/main/cpp/waylandcomp/src/blend_pass.c
+++ b/app/src/main/cpp/waylandcomp/src/blend_pass.c
@@ -2,7 +2,7 @@
#define _POSIX_C_SOURCE 200809L
#include "blend_pass.h"
#include "vk_loader.h"
-#include "vk_present.h" /* banner_log, vkp_gpu_name */
+#include "vk_present.h" /* droiddeck_log, vkp_gpu_name */
#include
/* SPIR-V, pre-compiled (glslangValidator -V blend.vert --vn blend_vert_code, the same for blend.frag)
@@ -168,12 +168,12 @@ static int objects_ensure(void) {
if (!(g_vert = shader(blend_vert_code, sizeof(blend_vert_code)))) goto fail;
if (!(g_frag = shader(blend_frag_code, sizeof(blend_frag_code)))) goto fail;
g_ready = 1;
- banner_log("gpu", "alpha composition ready on %s: translucent surfaces are blended over what is under them",
+ droiddeck_log("gpu", "alpha composition ready on %s: translucent surfaces are blended over what is under them",
vkp_gpu_name());
return 0;
fail:
objects_destroy();
- banner_log("error", "gpu: the alpha composition pass could not be built on this driver; translucent surfaces "
+ droiddeck_log("error", "gpu: the alpha composition pass could not be built on this driver; translucent surfaces "
"are drawn opaque this session");
return -1;
}
diff --git a/app/src/main/cpp/waylandcomp/src/compositor.c b/app/src/main/cpp/waylandcomp/src/compositor.c
index 75a16311ea..fbbd09886e 100644
--- a/app/src/main/cpp/waylandcomp/src/compositor.c
+++ b/app/src/main/cpp/waylandcomp/src/compositor.c
@@ -1,5 +1,5 @@
/*
- * bannerlator-wayland - the embedded compositor of the Wayland display path.
+ * droiddeck-wayland - the embedded compositor of the Wayland display path.
*
* Clients are the Wine processes of a container (winewayland.drv) and, through them,
* Mesa's Vulkan WSI. Each process is its own client, so a Windows virtual desktop is
@@ -50,12 +50,12 @@
#include "framegen_bridge.h"
#include
#include "effects_chain.h"
-#include "banner_ext.h"
-#include "banner_color.h"
+#include "droiddeck_ext.h"
+#include "droiddeck_color.h"
#include "compositor_internal.h"
-#define WLOGI(...) __android_log_print(ANDROID_LOG_INFO, "BannerWayland", __VA_ARGS__)
-#define WLOGE(...) __android_log_print(ANDROID_LOG_ERROR, "BannerWayland", __VA_ARGS__)
+#define WLOGI(...) __android_log_print(ANDROID_LOG_INFO, "DroidDeckWayland", __VA_ARGS__)
+#define WLOGE(...) __android_log_print(ANDROID_LOG_ERROR, "DroidDeckWayland", __VA_ARGS__)
/* ------------------------------------------------------------------ session log
* One readable, time-stamped file per Wayland session in Download/Wayland-logs, also
@@ -75,7 +75,7 @@ static pthread_mutex_t g_log_lock = PTHREAD_MUTEX_INITIALIZER;
static char *g_prelog[PRELOG_MAX];
static int g_prelog_n;
-void banner_log(const char *tag, const char *fmt, ...) {
+void droiddeck_log(const char *tag, const char *fmt, ...) {
char msg[512];
va_list ap;
va_start(ap, fmt);
@@ -121,11 +121,11 @@ static void open_session_log(void) {
setvbuf(f, NULL, _IOLBF, 0);
strftime(stamp, sizeof(stamp), "%Y-%m-%d %H:%M:%S", &tm);
fprintf(f,
- "Bannerlator Wayland session\n"
- "===========================\n"
+ "DroidDeck Wayland session\n"
+ "=========================\n"
"Started %s\n"
- "Display Wayland: Windows programs draw through the Bannerlator compositor.\n"
- " No X server is used for this session.\n"
+ "Display Wayland: programs draw through the DroidDeck compositor.\n"
+ " gamescope and the desktop start their own Xwayland for X11 programs.\n"
"Log %s\n\n"
"Time Area Event\n"
"------------ -------- -----------------------------------------------------\n",
@@ -178,8 +178,8 @@ static const char *client_name(struct wl_client *client) {
static void on_client_destroyed(struct wl_listener *l, void *data) {
struct client_info *ci = wl_container_of(l, ci, destroy), **pp;
- banner_log("program", "disconnected: %s (pid %d)", ci->name, (int)ci->pid);
- banner_color_client_gone(ci->client); /* HDR summary for a program that presented HDR (gate open only) */
+ droiddeck_log("program", "disconnected: %s (pid %d)", ci->name, (int)ci->pid);
+ droiddeck_color_client_gone(ci->client); /* HDR summary for a program that presented HDR (gate open only) */
for (pp = &g_clients; *pp; pp = &(*pp)->next)
if (*pp == ci) { *pp = ci->next; break; }
free(ci);
@@ -211,7 +211,7 @@ static void on_client_created(struct wl_listener *l, void *data) {
wl_client_add_destroy_listener(client, &ci->destroy);
ci->next = g_clients;
g_clients = ci;
- banner_log("program", "connected over Wayland: %s (pid %d)", ci->name, (int)ci->pid);
+ droiddeck_log("program", "connected over Wayland: %s (pid %d)", ci->name, (int)ci->pid);
}
/* ------------------------------------------------------------------ surfaces */
@@ -304,7 +304,7 @@ volatile int g_fps_limit;
* the X11 renderer's unviewable "explorer.exe". They still exist for input routing. */
volatile int g_hide_shell;
-/* Experimental layer mode (BANNER_WAYLAND_ZERO_COPY=1 in the container's environment): a single
+/* Experimental layer mode (DROIDDECK_WAYLAND_ZERO_COPY=1 in the container's environment): a single
* fullscreen window is shown on its own Android layer (sc_layer.c) instead of being blitted into the
* screen swapchain. Set from the app before the compositor starts; read per frame. */
volatile int g_zero_copy;
@@ -314,11 +314,11 @@ static int g_zero_copy_fx_skip_said;
/* Compressed (UBWC) game buffers: zwp_linux_dmabuf_v1 advertises DRM_FORMAT_MOD_QCOM_COMPRESSED next
* to LINEAR for every format the renderer's own driver can import that way, so Turnip's Wayland WSI
* in the game allocates UBWC swapchain images instead of resolving each frame to a linear copy.
- * BANNER_WAYLAND_UBWC=0 in the container's environment turns the advertisement off (A/B switch). Set
+ * DROIDDECK_WAYLAND_UBWC=0 in the container's environment turns the advertisement off (A/B switch). Set
* from the app before the compositor starts; read at every zwp_linux_dmabuf_v1 bind. */
volatile int g_ubwc = 1;
-/* Debug (BANNER_WAYLAND_NO_RENDER_NODE=1): name no DRM device in the dma-buf feedback, as a phone
+/* Debug (DROIDDECK_WAYLAND_NO_RENDER_NODE=1): name no DRM device in the dma-buf feedback, as a phone
* that exposes no /dev/dri node to apps does, to reproduce its OpenGL path here. Set from the app
* before the compositor starts. */
volatile int g_no_render_node;
@@ -544,13 +544,13 @@ static void cursor_publish_shm(struct wl_shm_buffer *shm, int hx, int hy) {
/* The serial alone, without the lock: the app asks on every pointer move, and the snapshot below
* copies up to 256 KB of pixels across JNI and holds the lock the compositor thread takes to
* change the cursor. A torn read is only a missed or an extra snapshot. */
-int banner_cursor_serial(void) {
+int droiddeck_cursor_serial(void) {
return __atomic_load_n(&g_cursor_serial, __ATOMIC_RELAXED);
}
/* Read by the app (UI thread). out = [serial, hidden, w, h, hotspotX, hotspotY, pixels...].
* Returns the number of ints written, or 0 if out is too small. */
-int banner_cursor_snapshot(int *out, int cap) {
+int droiddeck_cursor_snapshot(int *out, int cap) {
int n = 0;
pthread_mutex_lock(&g_cursor_lock);
int need = 6 + (g_cursor_hidden ? 0 : g_cursor_w * g_cursor_h);
@@ -650,7 +650,7 @@ static void map_toplevel(struct surface *s) {
{
char name[160];
describe(s, name, sizeof(name));
- banner_log("window", "opened %s %dx%d at %d,%d%s", name, w, h, s->x, s->y,
+ droiddeck_log("window", "opened %s %dx%d at %d,%d%s", name, w, h, s->x, s->y,
s->placed ? "" : " (no desktop position yet)");
}
wl_list_insert(g_toplevels.prev, &s->toplevel_link); /* new windows start on top */
@@ -667,12 +667,12 @@ static void unmap_toplevel(struct surface *s) {
{
char name[160];
describe(s, name, sizeof(name));
- banner_log("window", "closed %s", name);
+ droiddeck_log("window", "closed %s", name);
}
wl_list_remove(&s->toplevel_link);
wl_list_init(&s->toplevel_link);
if (g_ime_click == s) g_ime_click = NULL;
- banner_text_input_refocus();
+ droiddeck_text_input_refocus();
}
/* Let go of the surface's dmabuf content. paced = 1: the buffer was replaced, give it back on the
@@ -752,11 +752,11 @@ static struct surface *g_hud_surface;
static int64_t g_hud_last_ns;
/* That window committed a frame the screen has not drawn yet. */
static int g_hud_fresh;
-extern void banner_on_game_surface(const char *window, const char *gpu); /* window NULL = gone */
-extern void banner_on_game_frame(void);
+extern void droiddeck_on_game_surface(const char *window, const char *gpu); /* window NULL = gone */
+extern void droiddeck_on_game_frame(void);
/* The program behind that window: its Linux pid (the Wayland client's credentials) and executable name
* ("" when /proc gave none) - the app arms its CPU affinity on it (X11 does that from window events). */
-extern void banner_on_game_program(int pid, const char *program);
+extern void droiddeck_on_game_program(int pid, const char *program);
static void take_dmabuf(struct surface *s, struct dmabuf_buffer *b, struct wl_resource *buffer) {
if (s->dmabuf != buffer || s->dmabuf_buf != b) {
@@ -787,7 +787,7 @@ static void take_dmabuf(struct surface *s, struct dmabuf_buffer *b, struct wl_re
(s->buf_w != b->width || s->buf_h != b->height)) {
char name[160];
describe(s, name, sizeof(name));
- banner_log("vulkan", "%s changed its frame size: %dx%d -> %dx%d", name,
+ droiddeck_log("vulkan", "%s changed its frame size: %dx%d -> %dx%d", name,
s->buf_w, s->buf_h, b->width, b->height);
}
s->buf_w = b->width;
@@ -803,18 +803,18 @@ static void take_dmabuf(struct surface *s, struct dmabuf_buffer *b, struct wl_re
if (b->img)
/* Imported for the copy path. Whether its frames ALSO go on the display layer without a copy
* is decided per frame (fullscreen, zero-copy on) and counted in the 10 s lines. */
- banner_log("vulkan", "%s is presenting GPU frames through Wayland: %dx%d, format %c%c%c%c, %s (%s)",
+ droiddeck_log("vulkan", "%s is presenting GPU frames through Wayland: %dx%d, format %c%c%c%c, %s (%s)",
name, b->width, b->height, b->format & 0xff, (b->format >> 8) & 0xff,
(b->format >> 16) & 0xff, (b->format >> 24) & 0xff,
vkp_modifier_name(b->modifier),
ahb_swapchain_has_ahb(b) ? "gralloc buffers: can go on the display layer without a copy"
: "dma-buf: copied into the screen swapchain");
else if (ahb_swapchain_has_ahb(b))
- banner_log("vulkan", "%s is presenting GPU frames through Wayland: %dx%d on its own display layer only "
+ droiddeck_log("vulkan", "%s is presenting GPU frames through Wayland: %dx%d on its own display layer only "
"(gralloc buffers the compositor cannot import for the copy path)",
name, b->width, b->height);
else
- banner_log("error", "could not import GPU frames from %s (%dx%d, modifier %#llx)",
+ droiddeck_log("error", "could not import GPU frames from %s (%dx%d, modifier %#llx)",
name, b->width, b->height, (unsigned long long)b->modifier);
}
/* The HUD follows the window whether its frames are copied or go straight to the layer: a
@@ -830,21 +830,21 @@ static void take_dmabuf(struct surface *s, struct dmabuf_buffer *b, struct wl_re
char name[160];
describe(s, name, sizeof(name));
g_hud_surface = s;
- banner_on_game_surface(name, vkp_gpu_name());
+ droiddeck_on_game_surface(name, vkp_gpu_name());
struct client_info *ci = client_info_of(wl_resource_get_client(s->resource));
- if (ci) banner_on_game_program((int)ci->pid, strncmp(ci->name, "pid ", 4) ? ci->name : "");
+ if (ci) droiddeck_on_game_program((int)ci->pid, strncmp(ci->name, "pid ", 4) ? ci->name : "");
}
/* HDR session (gate open): a DXVK game switches to HDR by REBUILDING its swapchain on the same
* surface, so the one-shot line above never sees the 10-bit buffers - name every format change. */
- if (b->format != s->hdr_fmt_logged && banner_color_hdr_open()) {
+ if (b->format != s->hdr_fmt_logged && droiddeck_color_hdr_open()) {
char name[160];
uint32_t af = ahb_swapchain_ahb_format(b);
int ten = b->format == FOURCC('A', 'B', '3', '0') || b->format == FOURCC('X', 'B', '3', '0');
describe(s, name, sizeof(name));
- banner_log("color", "%s presents %dx%d buffers in %c%c%c%c (%s), %s%s%s; %s", name, b->width, b->height,
+ droiddeck_log("color", "%s presents %dx%d buffers in %c%c%c%c (%s), %s%s%s; %s", name, b->width, b->height,
b->format & 0xff, (b->format >> 8) & 0xff, (b->format >> 16) & 0xff, (b->format >> 24) & 0xff,
ten ? "10-bit A2B10G10R10" : "8-bit", vkp_modifier_name(b->modifier),
- af ? ", gralloc " : ", no gralloc buffer (copy path only)", af ? banner_ahb_format_name(af) : "",
+ af ? ", gralloc " : ", no gralloc buffer (copy path only)", af ? droiddeck_ahb_format_name(af) : "",
b->img ? "the compositor imported it"
: af ? "the compositor's driver could NOT import it (display layer only, fullscreen)"
: "the compositor's driver could NOT import it (nothing can show it)");
@@ -854,23 +854,23 @@ static void take_dmabuf(struct surface *s, struct dmabuf_buffer *b, struct wl_re
* Asking whether the compositor could import it, as this used to, is a question about the
* copy path and not about whether a frame happened: a game whose buffers go straight to
* the display layer draws on screen while the counter sat at 0.0 fps and 1000.0 ms. */
- if (s == g_hud_surface) { g_hud_last_ns = now_ns(); g_hud_fresh = 1; banner_on_game_frame(); }
+ if (s == g_hud_surface) { g_hud_last_ns = now_ns(); g_hud_fresh = 1; droiddeck_on_game_frame(); }
}
/* ---- hooks for ahb_swapchain.c (zero-copy layers) */
-struct dmabuf_buffer *banner_dmabuf_from_resource(struct wl_resource *buffer) { return get_dmabuf(buffer); }
-int banner_dmabuf_fd(const struct dmabuf_buffer *b) { return b && b->n_planes > 0 ? b->fd[0] : -1; }
-void banner_dmabuf_size(const struct dmabuf_buffer *b, int *w, int *h) { *w = b->width; *h = b->height; }
-void **banner_dmabuf_ahb_slot(struct dmabuf_buffer *b) { return &b->ahb_state; }
-void banner_dmabuf_ref(struct dmabuf_buffer *b) { b->refs++; }
-void banner_dmabuf_unref(struct dmabuf_buffer *b) { dmabuf_buffer_unref(b); }
-void banner_release_buffer(struct surface *s, struct wl_resource *buffer, int paced, int64_t since_ns) {
+struct dmabuf_buffer *droiddeck_dmabuf_from_resource(struct wl_resource *buffer) { return get_dmabuf(buffer); }
+int droiddeck_dmabuf_fd(const struct dmabuf_buffer *b) { return b && b->n_planes > 0 ? b->fd[0] : -1; }
+void droiddeck_dmabuf_size(const struct dmabuf_buffer *b, int *w, int *h) { *w = b->width; *h = b->height; }
+void **droiddeck_dmabuf_ahb_slot(struct dmabuf_buffer *b) { return &b->ahb_state; }
+void droiddeck_dmabuf_ref(struct dmabuf_buffer *b) { b->refs++; }
+void droiddeck_dmabuf_unref(struct dmabuf_buffer *b) { dmabuf_buffer_unref(b); }
+void droiddeck_release_buffer(struct surface *s, struct wl_resource *buffer, int paced, int64_t since_ns) {
if (paced && s) release_buffer(s, buffer, since_ns);
else { wl_buffer_send_release(buffer); perf_note_release(since_ns); }
}
-void banner_surface_describe(const struct surface *s, char *out, size_t size) { describe(s, out, size); }
-const struct banner_color *banner_surface_color(const struct surface *s) {
- return s ? banner_color_of(s->resource) : NULL;
+void droiddeck_surface_describe(const struct surface *s, char *out, size_t size) { describe(s, out, size); }
+const struct droiddeck_color *droiddeck_surface_color(const struct surface *s) {
+ return s ? droiddeck_color_of(s->resource) : NULL;
}
/* ------------------------------------------------------------------ wl_surface */
@@ -1134,7 +1134,7 @@ static void surface_commit(struct wl_client *c, struct wl_resource *r) {
wl_list_insert_list(s->feedback.prev, &s->pending_feedback);
wl_list_init(&s->pending_feedback);
constraints_surface_commit(s);
- banner_color_commit(s->resource); /* wp_color_management_surface_v1 state (returns at once when HDR is off) */
+ droiddeck_color_commit(s->resource); /* wp_color_management_surface_v1 state (returns at once when HDR is off) */
if (s->role == ROLE_TOPLEVEL && s->xdg_toplevel) {
if (s->has_content) map_toplevel(s);
@@ -1184,9 +1184,9 @@ static void surface_resource_destroy(struct wl_resource *r) {
if (g_grab == s) g_grab = NULL;
if (g_key_target == s) g_key_target = NULL;
if (g_ime_click == s) g_ime_click = NULL;
- banner_text_input_surface_gone(r);
- if (g_desktop == s) { g_desktop = NULL; banner_log("desktop", "the desktop closed"); }
- if (g_hud_surface == s) { g_hud_surface = NULL; banner_on_game_surface(NULL, NULL); }
+ droiddeck_text_input_surface_gone(r);
+ if (g_desktop == s) { g_desktop = NULL; droiddeck_log("desktop", "the desktop closed"); }
+ if (g_hud_surface == s) { g_hud_surface = NULL; droiddeck_on_game_surface(NULL, NULL); }
constraints_surface_gone(s);
unmap_toplevel(s);
@@ -1436,7 +1436,7 @@ static void xdg_toplevel_set_title(struct wl_client *c, struct wl_resource *r, c
if (announce) {
char after[160];
describe(s, after, sizeof(after));
- banner_log("window", "renamed %s -> %s", before, after);
+ droiddeck_log("window", "renamed %s -> %s", before, after);
}
}
static void xdg_toplevel_set_app_id(struct wl_client *c, struct wl_resource *r, const char *id) {}
@@ -1613,7 +1613,7 @@ static void desktop_set_desktop(struct wl_client *c, struct wl_resource *r, stru
if (!s || (s->role != ROLE_NONE && s->role != ROLE_DESKTOP)) return;
s->role = ROLE_DESKTOP;
g_desktop = s;
- banner_log("desktop", "Windows virtual desktop created by %s", client_name(c));
+ droiddeck_log("desktop", "Windows virtual desktop created by %s", client_name(c));
schedule_render();
}
static void desktop_set_window(struct wl_client *c, struct wl_resource *r, struct wl_resource *surface,
@@ -1623,7 +1623,7 @@ static void desktop_set_window(struct wl_client *c, struct wl_resource *r, struc
if (s->placed && (s->x != x || s->y != y) && s->mapped && log_budget()) {
char name[160];
describe(s, name, sizeof(name));
- banner_log("window", "moved %s to %d,%d", name, x, y);
+ droiddeck_log("window", "moved %s to %d,%d", name, x, y);
}
s->hwnd = hwnd;
s->x = x;
@@ -1666,13 +1666,13 @@ static void bind_output(struct wl_client *c, void *data, uint32_t ver, uint32_t
if (!r) { wl_client_post_no_memory(c); return; }
wl_resource_set_implementation(r, &output_impl, NULL, NULL);
wl_output_send_geometry(r, 0, 0, 340, 190, WL_OUTPUT_SUBPIXEL_UNKNOWN,
- "Bannerlator", "Wayland", WL_OUTPUT_TRANSFORM_NORMAL);
+ "DroidDeck", "Wayland", WL_OUTPUT_TRANSFORM_NORMAL);
wl_output_send_mode(r, WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED,
g_output_w > 0 ? g_output_w : 1920, g_output_h > 0 ? g_output_h : 1080,
g_output_refresh_mhz > 0 ? g_output_refresh_mhz : 60000);
if (ver >= WL_OUTPUT_NAME_SINCE_VERSION) {
- wl_output_send_name(r, "Bannerlator-1");
- wl_output_send_description(r, "Bannerlator display");
+ wl_output_send_name(r, "DroidDeck-1");
+ wl_output_send_description(r, "DroidDeck display");
}
if (ver >= 2) {
wl_output_send_scale(r, 1);
@@ -1701,7 +1701,7 @@ static int g_hdr_unimported_rect[4], g_hdr_unimported_below; /* scene x,y,w,h; d
static void note_hdr_unimported(const struct draw_list *dl, struct surface *s, int ox, int oy) {
if (!s->dmabuf_buf || s->dmabuf_buf->img || !ahb_swapchain_has_ahb(s->dmabuf_buf)) return;
- const struct banner_color *c = banner_color_of(s->resource);
+ const struct droiddeck_color *c = droiddeck_color_of(s->resource);
if (!c || !c->dataspace) return;
if (s->src_set && (s->src[0] != 0 || s->src[1] != 0 || (int)(s->src[2] + 0.5f) != s->buf_w ||
(int)(s->src[3] + 0.5f) != s->buf_h)) return; /* cropped: the layer shows whole buffers */
@@ -1730,7 +1730,7 @@ static void add_surface(struct draw_list *dl, struct surface *s, int ox, int oy)
int dw, dh;
if (!img) {
- if (g_zero_copy && banner_color_hdr_open()) note_hdr_unimported(dl, s, ox, oy);
+ if (g_zero_copy && droiddeck_color_hdr_open()) note_hdr_unimported(dl, s, ox, oy);
return;
}
if (s->src_set) { sx = s->src[0]; sy = s->src[1]; sw = s->src[2]; sh = s->src[3]; }
@@ -1850,7 +1850,7 @@ static struct surface *ahb_layer_only_candidate(int scene_w, int scene_h) {
return s;
}
-/* ---- HDR (banner_color.h) in the scene
+/* ---- HDR (droiddeck_color.h) in the scene
* An HDR frame is only right on the game's own display layer: everything the compositor draws itself -
* the scene blit, the effects chain, frame generation, its swapchain - is 8-bit sRGB, and a PQ-encoded
* frame pushed through it as it stands comes out washed out. So a scene with HDR in it takes one of
@@ -1866,7 +1866,7 @@ static struct surface *ahb_layer_only_candidate(int scene_w, int scene_h) {
* tone-mapped to SDR (correct colours instead of washed out).
* 3 a frame the compositor could not import: only its display layer can show it, so effects and
* frame generation are skipped for it (said in the log).
- * The drawer's HDR output switch (banner_color_output) OFF: the same routes, tone-mapped - route 0
+ * The drawer's HDR output switch (droiddeck_color_output) OFF: the same routes, tone-mapped - route 0
* becomes route 1 (the whole scene composed, tone-mapped to sRGB, onto the game layer UNtagged), route 2
* tone-maps into an SDR swapchain, route 3 cannot (nothing can read those frames) and stays HDR, said
* in the log. The game is told nothing; it keeps rendering HDR.
@@ -1876,7 +1876,7 @@ struct hdr_scene {
struct vkp_hdr_frame hf;
unsigned char *is_hdr; /* per draw (calloc'd; free after the frame) */
int n_hdr;
- const struct banner_color *color; /* the topmost HDR draw's description: what the picture is tagged */
+ const struct droiddeck_color *color; /* the topmost HDR draw's description: what the picture is tagged */
struct surface *who; /* its surface, for the log */
const char *why; /* route 1: why the game cannot be alone on its layer */
};
@@ -1891,29 +1891,29 @@ static struct surface *hdr_unimported_fullscreen(const struct draw_list *dl, int
}
static int is_hdr_surface(struct surface *s) {
- const struct banner_color *c = s ? banner_color_of(s->resource) : NULL;
+ const struct droiddeck_color *c = s ? droiddeck_color_of(s->resource) : NULL;
return c && c->dataspace;
}
/* Which route this scene takes (see above); fills hs. 0 whenever the gate is closed or no HDR is drawn. */
static int hdr_plan(const struct draw_list *dl, int w, int h, int fx_on, int framegen, struct hdr_scene *hs) {
memset(hs, 0, sizeof(*hs));
- if (!banner_color_hdr_open()) return 0;
+ if (!droiddeck_color_hdr_open()) return 0;
/* A fullscreen HDR frame this compositor could not import has no draw: layer only (route 3). */
struct surface *un = hdr_unimported_fullscreen(dl, w, h);
if (!un) {
struct surface *lo = ahb_layer_only_candidate(w, h);
if (lo && is_hdr_surface(lo)) un = lo;
}
- if (un && g_zero_copy) { hs->color = banner_color_of(un->resource); hs->who = un; return 3; }
- hs->hf.tonemap = !banner_color_output();
+ if (un && g_zero_copy) { hs->color = droiddeck_color_of(un->resource); hs->who = un; return 3; }
+ hs->hf.tonemap = !droiddeck_color_output();
if (dl->n <= 0 || !(hs->is_hdr = calloc((size_t)dl->n, 1))) return 0;
for (int i = 0; i < dl->n; i++) {
struct surface *s = surface_for_image(dl->d[i].img);
if (!is_hdr_surface(s)) continue;
hs->is_hdr[i] = 1;
hs->n_hdr++;
- hs->color = banner_color_of(s->resource); /* later draws are above: the topmost wins */
+ hs->color = droiddeck_color_of(s->resource); /* later draws are above: the topmost wins */
hs->who = s;
}
if (!hs->n_hdr) { free(hs->is_hdr); hs->is_hdr = NULL; return 0; }
@@ -1942,7 +1942,7 @@ static int hdr_plan(const struct draw_list *dl, int w, int h, int fx_on, int fra
static void hdr_note_route(int route, const struct hdr_scene *hs) {
static int said = -1, said_tm = -1;
static const char *said_why;
- const int tm = route != 0 && !banner_color_output(); /* route 0 never runs with the switch off */
+ const int tm = route != 0 && !droiddeck_color_output(); /* route 0 never runs with the switch off */
if (route == said && tm == said_tm && (route != 1 || hs->why == said_why)) return;
int was = said;
said = route; said_why = hs->why; said_tm = tm;
@@ -1951,30 +1951,30 @@ static void hdr_note_route(int route, const struct hdr_scene *hs) {
switch (route) {
case 1:
if (tm)
- banner_log("color", "tone-mapped picture for %s: %s - the whole scene is composed and tone-mapped to SDR "
+ droiddeck_log("color", "tone-mapped picture for %s: %s - the whole scene is composed and tone-mapped to SDR "
"(HDR peak %.0f nits rolled off to SDR white, screen effects applied after it) on the game's "
"display layer, untagged", name, hs->why ? hs->why : "?", hs->hf.peak_nits);
else
- banner_log("color", "HDR picture for %s: %s - the whole scene is composed into one 10-bit PQ BT.2020 picture "
+ droiddeck_log("color", "HDR picture for %s: %s - the whole scene is composed into one 10-bit PQ BT.2020 picture "
"(SDR content at %.0f nits, screen effects applied in 10-bit) on the game's display layer, tagged "
- "BT2020_PQ", name, hs->why ? hs->why : "?", banner_color_sdr_white());
+ "BT2020_PQ", name, hs->why ? hs->why : "?", droiddeck_color_sdr_white());
break;
case 2:
if (tm)
- banner_log("color", "HDR with frame generation for %s, HDR output switched off: the scene is tone-mapped to "
+ droiddeck_log("color", "HDR with frame generation for %s, HDR output switched off: the scene is tone-mapped to "
"SDR and presented through an SDR screen swapchain", name);
else
- banner_log("color", "HDR with frame generation for %s: the scene is composed into PQ and presented through "
+ droiddeck_log("color", "HDR with frame generation for %s: the scene is composed into PQ and presented through "
"the screen swapchain (HDR10 where the surface offers it, else tone-mapped to SDR)", name);
break;
case 3:
if (tm)
- banner_log("color", "HDR output is switched off, but %s's HDR frames cannot be imported by the compositor, "
+ droiddeck_log("color", "HDR output is switched off, but %s's HDR frames cannot be imported by the compositor, "
"so nothing can tone-map them: they stay HDR on its own display layer", name);
break; /* otherwise hdr_note_precedence says it */
default:
if (was == 1 || was == 2)
- banner_log("color", "%s is back on its own display layer (no composition needed)", name);
+ droiddeck_log("color", "%s is back on its own display layer (no composition needed)", name);
break;
}
}
@@ -1987,18 +1987,18 @@ static void hdr_note_precedence(struct surface *hs, int fx_on, int framegen) {
if (hs) describe(hs, name, sizeof(name));
if (fx_skip != fx_said) {
if (fx_skip)
- banner_log("color", "screen effects are NOT applied to %s: its HDR frames cannot be imported by the "
+ droiddeck_log("color", "screen effects are NOT applied to %s: its HDR frames cannot be imported by the "
"compositor, so only its own display layer can show them (as they are)", name);
else if (fx_said == 1)
- banner_log("color", "screen effects apply to the scene again (no HDR game on its layer, or effects off)");
+ droiddeck_log("color", "screen effects apply to the scene again (no HDR game on its layer, or effects off)");
fx_said = fx_skip;
}
if (fg_skip != fg_said) {
if (fg_skip)
- banner_log("color", "frame generation is NOT applied to %s: its HDR frames cannot be imported by the "
+ droiddeck_log("color", "frame generation is NOT applied to %s: its HDR frames cannot be imported by the "
"compositor, so only its own display layer can show them (as they are)", name);
else if (fg_said == 1)
- banner_log("color", "frame generation applies again (no HDR game on its layer, or frame generation off)");
+ droiddeck_log("color", "frame generation applies again (no HDR game on its layer, or frame generation off)");
fg_said = fg_skip;
}
}
@@ -2007,11 +2007,11 @@ static void hdr_note_precedence(struct surface *hs, int fx_on, int framegen) {
static void hdr_count_copied(const struct draw_list *dl, const char *reason) {
for (int i = 0; i < dl->n; i++) {
struct surface *s = surface_for_image(dl->d[i].img);
- const struct banner_color *c = s ? banner_color_of(s->resource) : NULL;
+ const struct droiddeck_color *c = s ? droiddeck_color_of(s->resource) : NULL;
if (!c || !c->dataspace) continue;
char name[160];
describe(s, name, sizeof(name));
- banner_color_frame_copied(name, reason);
+ droiddeck_color_frame_copied(name, reason);
}
}
@@ -2028,8 +2028,8 @@ static void render_scene(void) {
wl_list_for_each(s, &g_surfaces, link) s->drawn = 0;
scene_size(&w, &h);
if (w != g_scene_w || h != g_scene_h) {
- if (g_desktop) banner_log("desktop", "size %dx%d", w, h);
- else banner_log("desktop", "no desktop: showing %dx%d (largest window)", w, h);
+ if (g_desktop) droiddeck_log("desktop", "size %dx%d", w, h);
+ else droiddeck_log("desktop", "no desktop: showing %dx%d (largest window)", w, h);
g_scene_w = w;
g_scene_h = h;
}
@@ -2048,7 +2048,7 @@ static void render_scene(void) {
struct hdr_scene hs;
int hdr_route = hdr_plan(&dl, w, h, fx_on, framegen, &hs);
const char *hdr_copy = NULL; /* why this scene's HDR frames (if any) took the copy path */
- if (banner_color_hdr_open()) {
+ if (droiddeck_color_hdr_open()) {
hdr_note_route(hdr_route, &hs);
hdr_note_precedence(hdr_route == 3 ? hs.who : NULL, fx_on, framegen);
}
@@ -2059,12 +2059,12 @@ static void render_scene(void) {
sc_layer_hide_overlay();
if (sc_layer_present_hdr_scene(dl.d, dl.n, &hs.hf, w, h, hs.color) == 0) {
rendered = vkp_base_black(w, h) == 0; /* black under the composed picture, presented only when it is not already */
- if (fell_back) { fell_back = 0; banner_log("color", "the composed picture is on the game's display layer again"); }
+ if (fell_back) { fell_back = 0; droiddeck_log("color", "the composed picture is on the game's display layer again"); }
} else {
hdr_route = 2; /* no layer this frame: the picture goes through the swapchain instead */
if (!fell_back) {
fell_back = 1;
- banner_log("color", "the composed picture could not go on the game's display layer (no layer, or the "
+ droiddeck_log("color", "the composed picture could not go on the game's display layer (no layer, or the "
"10-bit pass failed): it goes through the screen swapchain instead until that changes");
}
}
@@ -2074,8 +2074,8 @@ static void render_scene(void) {
sc_layer_hide();
rendered = vkp_render_hdr(w, h, dl.d, dl.n, &hs.hf, &how) == 0;
copy = 1;
- if (rendered && how == 1) banner_color_frame_shown(hs.color, BANNER_HDR_SWAPCHAIN, 0);
- else if (rendered && how == 2) banner_color_frame_shown(hs.color, BANNER_HDR_TONEMAPPED, 0);
+ if (rendered && how == 1) droiddeck_color_frame_shown(hs.color, DROIDDECK_HDR_SWAPCHAIN, 0);
+ else if (rendered && how == 2) droiddeck_color_frame_shown(hs.color, DROIDDECK_HDR_TONEMAPPED, 0);
else if (rendered) hdr_copy = "the HDR composition pass is unavailable on this driver";
}
if (hdr_route == 0 || hdr_route == 3) {
@@ -2104,14 +2104,14 @@ static void render_scene(void) {
if (g_zero_copy && blocked != g_zero_copy_paused) {
g_zero_copy_paused = blocked;
if (blocked == 1)
- banner_log("framegen", "zero-copy paused: frame generation needs the compositor pass");
+ droiddeck_log("framegen", "zero-copy paused: frame generation needs the compositor pass");
else if (blocked == 2)
- banner_log("effects", "zero-copy paused: a window above the game needs the compositor pass for the whole scene");
+ droiddeck_log("effects", "zero-copy paused: a window above the game needs the compositor pass for the whole scene");
else if (blocked == 3)
- banner_log("layer", "zero-copy paused: a window above the game would need a second display layer, "
+ droiddeck_log("layer", "zero-copy paused: a window above the game would need a second display layer, "
"which this display cannot compose in hardware - whole scene on the copy path");
else
- banner_log("effects", "zero-copy resumed: the game is back on its own display layer");
+ droiddeck_log("effects", "zero-copy resumed: the game is back on its own display layer");
}
struct surface *ls = li >= 0 ? surface_for_image(dl.d[li].img) : NULL;
/* A frame this renderer could not import can only be shown on the layer, effects or not. */
@@ -2121,7 +2121,7 @@ static void render_scene(void) {
if (li < 0 && !ls) ls = hdr_unimported_fullscreen(&dl, w, h);
if (ls && pass_on && li < 0 && !g_zero_copy_fx_skip_said) {
g_zero_copy_fx_skip_said = 1;
- banner_log(framegen ? "framegen" : "effects",
+ droiddeck_log(framegen ? "framegen" : "effects",
"the game's frames cannot be imported by the compositor: shown zero-copy, %s skipped",
framegen ? "frame generation" : "effects");
}
@@ -2148,7 +2148,7 @@ static void render_scene(void) {
r = ahb_swapchain_present(ls->dmabuf_buf, ls, w, h);
if (r != 0 && li >= 0)
r = fx_on ? sc_layer_present_pass(&dl.d[li], 1, w, h)
- : sc_layer_present(dl.d[li].img, w, h, ls ? banner_surface_color(ls) : NULL);
+ : sc_layer_present(dl.d[li].img, w, h, ls ? droiddeck_surface_color(ls) : NULL);
if (r == 0) {
if (ls) ls->drawn = 1;
/* The one window above the game keeps the game off the copy path entirely: it goes on
@@ -2188,7 +2188,7 @@ static void render_scene(void) {
}
} /* routes 0 and 3 */
free(hs.is_hdr);
- if (hdr_copy && rendered && banner_color_hdr_open()) hdr_count_copied(&dl, hdr_copy);
+ if (hdr_copy && rendered && droiddeck_color_hdr_open()) hdr_count_copied(&dl, hdr_copy);
if (rendered) {
int64_t t = now_ns();
g_stat_frames++;
@@ -2370,7 +2370,7 @@ static void bind_seat(struct wl_client *c, void *data, uint32_t ver, uint32_t id
struct wl_resource *r = wl_resource_create(c, &wl_seat_interface, ver, id);
wl_resource_set_implementation(r, &seat_impl, NULL, NULL);
wl_seat_send_capabilities(r, WL_SEAT_CAPABILITY_POINTER | WL_SEAT_CAPABILITY_KEYBOARD | WL_SEAT_CAPABILITY_TOUCH);
- if (ver >= 2) wl_seat_send_name(r, "bannerlator-seat");
+ if (ver >= 2) wl_seat_send_name(r, "droiddeck-seat");
}
static struct seat_pointer *pointer_for(struct wl_client *client) {
@@ -2449,7 +2449,7 @@ static void keyboard_focus(struct wl_resource *target) {
g_mods_depressed, 0, g_mods_locked, 0);
}
wl_array_release(&keys);
- banner_clipboard_keyboard_focus(client); /* wl_data_device selection follows focus */
+ droiddeck_clipboard_keyboard_focus(client); /* wl_data_device selection follows focus */
}
/* ------------------------------------------------------------------ pointer constraints
@@ -2502,14 +2502,14 @@ static int g_raw_valid;
/* JNI: the app switches its touch/mouse path to deltas while a lock holds and re-syncs its
* pointer to x,y when it ends. */
-extern void banner_on_pointer_lock(int locked, int x, int y);
+extern void droiddeck_on_pointer_lock(int locked, int x, int y);
static void sync_lock_notify(void) {
static int last;
int locked = g_active_constraint && g_active_constraint->is_lock;
if (locked == last) return;
last = locked;
- banner_on_pointer_lock(locked, (int)g_ptr_x, (int)g_ptr_y);
+ droiddeck_on_pointer_lock(locked, (int)g_ptr_x, (int)g_ptr_y);
}
static void constraint_describe(const struct constraint *k, char *out, size_t size) {
@@ -2570,7 +2570,7 @@ static void constraint_end(struct constraint *k, int tell_client, const char *wh
g_raw_valid = 0;
if (tell_client) constraint_send_state(k, 0);
constraint_describe(k, name, sizeof(name));
- banner_log("pointer", "%s: %s (%s), pointer at %d,%d", k->is_lock ? "unlocked" : "unconfined",
+ droiddeck_log("pointer", "%s: %s (%s), pointer at %d,%d", k->is_lock ? "unlocked" : "unconfined",
name, why, (int)g_ptr_x, (int)g_ptr_y);
sync_lock_notify();
}
@@ -2590,15 +2590,15 @@ static void constraint_activate(struct constraint *k) {
constraint_send_state(k, 1);
constraint_describe(k, name, sizeof(name));
if (k->is_lock)
- banner_log("pointer", "locked: %s (%s), pointer frozen at %d,%d", name,
+ droiddeck_log("pointer", "locked: %s (%s), pointer frozen at %d,%d", name,
k->lifetime == ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ONESHOT ? "oneshot" : "persistent",
(int)g_ptr_x, (int)g_ptr_y);
else if (k->region.set)
- banner_log("pointer", "confined: %s (%s) to %dx%d at %d,%d of the window", name,
+ droiddeck_log("pointer", "confined: %s (%s) to %dx%d at %d,%d of the window", name,
k->lifetime == ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ONESHOT ? "oneshot" : "persistent",
k->region.w, k->region.h, k->region.x, k->region.y);
else
- banner_log("pointer", "confined: %s (%s) to the whole window", name,
+ droiddeck_log("pointer", "confined: %s (%s) to the whole window", name,
k->lifetime == ZWP_POINTER_CONSTRAINTS_V1_LIFETIME_ONESHOT ? "oneshot" : "persistent");
sync_lock_notify();
wl_display_flush_clients(g_display);
@@ -2652,7 +2652,7 @@ static void constraints_surface_commit(struct surface *s) {
g_ptr_x = ox + k->hint_x;
g_ptr_y = oy + k->hint_y;
if (log_budget())
- banner_log("pointer", "position hint: pointer moved to %d,%d", (int)g_ptr_x, (int)g_ptr_y);
+ droiddeck_log("pointer", "position hint: pointer moved to %d,%d", (int)g_ptr_x, (int)g_ptr_y);
}
}
if (k->pending_region_set) {
@@ -2733,7 +2733,7 @@ static void constraint_create(struct wl_client *c, struct wl_resource *r, uint32
wl_list_insert(g_constraints.prev, &k->link);
if (!s) { k->defunct = 1; return; }
constraint_describe(k, name, sizeof(name));
- banner_log("pointer", "%s requested by %s for %s", is_lock ? "lock" : "confine", client_name(c), name);
+ droiddeck_log("pointer", "%s requested by %s for %s", is_lock ? "lock" : "confine", client_name(c), name);
constraint_activate(k);
}
@@ -2764,7 +2764,7 @@ static void bind_pointer_constraints(struct wl_client *c, void *data, uint32_t v
static void relative_pointer_resource_destroy(struct wl_resource *r) {
struct relative_pointer *rp = wl_resource_get_user_data(r);
if (!rp) return;
- banner_log("pointer", "relative pointer released by %s", client_name(wl_resource_get_client(r)));
+ droiddeck_log("pointer", "relative pointer released by %s", client_name(wl_resource_get_client(r)));
wl_list_remove(&rp->link);
free(rp);
}
@@ -2783,7 +2783,7 @@ static void relative_pointer_manager_get(struct wl_client *c, struct wl_resource
rp->pointer = pointer;
wl_resource_set_implementation(res, &relative_pointer_impl, rp, relative_pointer_resource_destroy);
wl_list_insert(g_relative_pointers.prev, &rp->link);
- banner_log("pointer", "relative pointer created for %s (motion arrives as deltas)", client_name(c));
+ droiddeck_log("pointer", "relative pointer created for %s (motion arrives as deltas)", client_name(c));
}
static const struct zwp_relative_pointer_manager_v1_interface relative_pointer_manager_impl = {
.destroy = relative_pointer_manager_destroy,
@@ -2890,7 +2890,7 @@ static void pointer_input(double x, double y, int relative, uint32_t button, int
if (button && pressed && !(k && k->is_lock)) {
struct surface *clicked = toplevel_at(g_ptr_x, g_ptr_y);
if (clicked) g_ime_click = clicked;
- banner_text_input_refocus();
+ droiddeck_text_input_refocus();
}
wl_display_flush_clients(g_display);
}
@@ -3034,7 +3034,7 @@ static void touch_down(int id, double x, double y) {
if (!any_active) {
char name[160];
describe(target, name, sizeof(name));
- banner_log("touch", "%s gets %s", name, has_touch ? "touch" : "the pointer (it takes no touch)");
+ droiddeck_log("touch", "%s gets %s", name, has_touch ? "touch" : "the pointer (it takes no touch)");
}
if (!has_touch) {
if (any_active) return; /* one finger drives the pointer; a second one is ignored */
@@ -3113,7 +3113,7 @@ static void deliver_touch(const struct input_msg *m) {
}
static void key_event(uint32_t evdev, int pressed);
-struct wl_resource *banner_ime_target(void);
+struct wl_resource *droiddeck_ime_target(void);
static void deliver_key(const struct input_msg *m) {
key_event((uint32_t)m->p1, m->p2);
}
@@ -3177,7 +3177,7 @@ static void key_event(uint32_t evdev, int pressed) {
* thread, not to the foreground program (X11 delivers keys to the focused app window, so
* this mirrors it). The desktop itself is the last resort. */
struct surface *target = NULL;
- struct wl_resource *ime = banner_ime_target();
+ struct wl_resource *ime = droiddeck_ime_target();
if (ime) target = wl_resource_get_user_data(ime);
if (!target && g_key_target && g_key_target->mapped && g_key_target != g_desktop) target = g_key_target;
if (!target) target = g_desktop;
@@ -3220,14 +3220,14 @@ static int on_input_readable(int fd, uint32_t mask, void *data) {
/* Called from JNI (Android UI thread). Queues a pointer event; the compositor thread
* dispatches it. x/y are in INPUT_SPACE (0..1919, 0..1079) over the whole output. */
-void banner_wayland_send_pointer(int action, int x, int y) {
+void droiddeck_wayland_send_pointer(int action, int x, int y) {
if (g_input_pipe[1] < 0) return;
struct input_msg m = { 0, action, x, y, 0 };
ssize_t n = write(g_input_pipe[1], &m, sizeof(m));
(void)n;
}
-void banner_wayland_send_touch(int action, int pointer_id, int x, int y) {
+void droiddeck_wayland_send_touch(int action, int pointer_id, int x, int y) {
if (g_input_pipe[1] < 0) return;
struct input_msg m = { 7, action, pointer_id, x, y };
ssize_t n = write(g_input_pipe[1], &m, sizeof(m));
@@ -3235,7 +3235,7 @@ void banner_wayland_send_touch(int action, int pointer_id, int x, int y) {
}
/* Called from JNI. Queues a key event. evdev = Linux input keycode (e.g. KEY_A=30); state 1=down 0=up. */
-void banner_wayland_send_key(int evdev, int state) {
+void droiddeck_wayland_send_key(int evdev, int state) {
if (g_input_pipe[1] < 0) return;
struct input_msg m = { 1, evdev, state, 0, 0 };
ssize_t n = write(g_input_pipe[1], &m, sizeof(m));
@@ -3243,7 +3243,7 @@ void banner_wayland_send_key(int evdev, int state) {
}
/* Called from JNI on every screen refresh (Choreographer). */
-void banner_wayland_vsync(int64_t frame_time_ns) {
+void droiddeck_wayland_vsync(int64_t frame_time_ns) {
if (g_input_pipe[1] < 0) return;
struct input_msg m = { 5, (int)(frame_time_ns >> 32), (int)(uint32_t)frame_time_ns, 0, 0 };
ssize_t n = write(g_input_pipe[1], &m, sizeof(m));
@@ -3253,7 +3253,7 @@ void banner_wayland_vsync(int64_t frame_time_ns) {
/* Called from JNI with the app's X-server input (on-screen controls, mouse): type 2 = motion
* to scene x,y; 3 = evdev button a pressed/released (b); 4 = a wheel steps (negative = up);
* 6 = relative motion by a,b in 1/256 pixel (the app's Relative Mouse / captured-mouse path). */
-void banner_wayland_send_scene_input(int type, int a, int b) {
+void droiddeck_wayland_send_scene_input(int type, int a, int b) {
if (g_input_pipe[1] < 0) return;
struct input_msg m = { type, a, b, 0, 0 };
ssize_t n = write(g_input_pipe[1], &m, sizeof(m));
@@ -3261,15 +3261,15 @@ void banner_wayland_send_scene_input(int type, int a, int b) {
}
/* ------------------------------------------------------------------ extension module hooks
- * What wl_clipboard.c / wl_text_input.c need from the scene (see banner_ext.h). */
+ * What wl_clipboard.c / wl_text_input.c need from the scene (see droiddeck_ext.h). */
-const char *banner_client_name(struct wl_client *client) { return client_name(client); }
-struct wl_display *banner_get_display(void) { return g_display; }
-void banner_request_redraw(void) { schedule_render(); }
+const char *droiddeck_client_name(struct wl_client *client) { return client_name(client); }
+struct wl_display *droiddeck_get_display(void) { return g_display; }
+void droiddeck_request_redraw(void) { schedule_render(); }
/* The surface text input follows: the last clicked mapped program window, else the topmost
* mapped window not owned by the desktop's process (explorer). NULL when there is none. */
-struct wl_resource *banner_ime_target(void) {
+struct wl_resource *droiddeck_ime_target(void) {
struct surface *s;
if (g_ime_click && g_ime_click->mapped) return g_ime_click->resource;
struct wl_client *shell = g_desktop ? wl_resource_get_client(g_desktop->resource) : NULL;
@@ -3278,13 +3278,13 @@ struct wl_resource *banner_ime_target(void) {
return NULL;
}
-void banner_surface_scene_origin(struct wl_resource *surface, int *x, int *y) {
+void droiddeck_surface_scene_origin(struct wl_resource *surface, int *x, int *y) {
struct surface *s = surface ? wl_resource_get_user_data(surface) : NULL;
*x = 0; *y = 0;
if (s && s->placed) { *x = s->x; *y = s->y; }
}
-void banner_inject_key(uint32_t evdev, int pressed) { key_event(evdev, pressed); }
+void droiddeck_inject_key(uint32_t evdev, int pressed) { key_event(evdev, pressed); }
/* ------------------------------------------------------------------ 10 s summary */
@@ -3311,7 +3311,7 @@ static int on_stats_timer(void *data) {
* zero-copy, so they are counted apart from the line above. */
if (layer_frames) off += snprintf(extra + off, sizeof(extra) - (size_t)off, " | %u layer frames", layer_frames);
if (generated) snprintf(extra + off, sizeof(extra) - (size_t)off, " | %u generated frames", generated);
- banner_log("stats", "last 10 s: %u frames on screen (%.1f fps) | %u GPU frames from games | %u window redraws | %d windows open%s",
+ droiddeck_log("stats", "last 10 s: %u frames on screen (%.1f fps) | %u GPU frames from games | %u window redraws | %d windows open%s",
g_stat_frames + generated, (g_stat_frames + generated) / 10.0, g_stat_dmabuf, g_stat_shm, windows, extra);
}
/* The perf line, next to the stats line and only when something happened: the compositor thread's
@@ -3323,7 +3323,7 @@ static int on_stats_timer(void *data) {
const unsigned drops = sc_layer_drops_take();
#define PERF_MS(sum, n) ((n) ? (double)(sum) / 1e6 / (double)(n) : 0.0)
if (g_perf.scenes || vp.presents || g_perf.releases || drops)
- banner_log("perf", "last 10 s: %u ticks, %u scenes, %u on screen (copy %u, zero-copy %u, layer copy %u) | "
+ droiddeck_log("perf", "last 10 s: %u ticks, %u scenes, %u on screen (copy %u, zero-copy %u, layer copy %u) | "
"render_scene %.2f/%.2f ms | base %u black kept, %u presented | acquire %.2f/%.2f ms | "
"present %.2f/%.2f ms (%u) | fence wait %.2f/%.2f ms (%u, %u GPU release waits) | "
"release %.2f/%.2f ms (%u, %u held) | %u pool drops",
@@ -3339,7 +3339,7 @@ static int on_stats_timer(void *data) {
memset(&g_perf, 0, sizeof(g_perf));
}
g_stat_frames = g_stat_dmabuf = g_stat_shm = 0;
- banner_color_stats_tick(); /* HDR evidence for the same window (nothing when the HDR gate is closed) */
+ droiddeck_color_stats_tick(); /* HDR evidence for the same window (nothing when the HDR gate is closed) */
/* A program that asked for dma-buf feedback (EGL's GPU path does, first thing) but has drawn
* only wl_shm frames since is an OpenGL program whose EGL gave up on the GPU. The software
* path it fell to has no rasteriser in the Wayland layers, so what it commits is black. */
@@ -3347,7 +3347,7 @@ static int on_stats_timer(void *data) {
if (!ci->asked_feedback || ci->dmabuf_buffers || ci->shm_gl_said || ci->shm_frames < 150)
continue;
ci->shm_gl_said = 1;
- banner_log("opengl", "%s asked for GPU buffers but has drawn only software (shared-memory) "
+ droiddeck_log("opengl", "%s asked for GPU buffers but has drawn only software (shared-memory) "
"frames: its OpenGL fell back to software rendering, which the Wayland layer cannot "
"draw - expect a black picture (main device %u:%u)", ci->name,
(unsigned)major(g_main_device), (unsigned)minor(g_main_device));
@@ -3373,7 +3373,7 @@ static void test_input_line(const char *line) {
int n = sscanf(line, "%15s %lf %lf", cmd, &x, &y);
if (n < 2) return;
- banner_log("test", "input: %s", line);
+ droiddeck_log("test", "input: %s", line);
if (!strcmp(cmd, "key") || !strcmp(cmd, "keydown") || !strcmp(cmd, "keyup")) {
code = (unsigned)x;
if (strcmp(cmd, "keyup")) key_event(code, 1);
@@ -3436,7 +3436,7 @@ static void start_test_input(struct wl_event_loop *loop) {
static struct wl_listener g_client_created = { .notify = on_client_created };
-int banner_wayland_run(void) {
+int droiddeck_wayland_run(void) {
wl_list_init(&g_surfaces);
wl_list_init(&g_toplevels);
wl_list_init(&g_constraints);
@@ -3468,7 +3468,7 @@ int banner_wayland_run(void) {
rt ? rt : "(null)");
return 1;
}
- banner_log("display", "Wayland compositor listening on %s/wayland-0", rt ? rt : "?");
+ droiddeck_log("display", "Wayland compositor listening on %s/wayland-0", rt ? rt : "?");
wl_display_add_client_created_listener(display, &g_client_created);
wl_global_create(display, &wl_compositor_interface, 6, NULL, bind_compositor);
@@ -3485,13 +3485,13 @@ int banner_wayland_run(void) {
wl_global_create(display, &wp_presentation_interface, 2, NULL, bind_presentation);
wl_global_create(display, &zwp_pointer_constraints_v1_interface, 1, NULL, bind_pointer_constraints);
wl_global_create(display, &zwp_relative_pointer_manager_v1_interface, 1, NULL, bind_relative_pointer_manager);
- banner_ext_init(display); /* clipboard, text input, toplevel icons (own files, see banner_ext.h) */
+ droiddeck_ext_init(display); /* clipboard, text input, toplevel icons (own files, see droiddeck_ext.h) */
ahb_swapchain_init(display); /* zero-copy layers: banner_ahb_v1, advertised whenever a display
* layer is possible; the mode event carries the live switch
* (ahb_swapchain.h) */
- banner_color_init(display); /* HDR10 (opt-in): decides the gate from the app's request + the
+ droiddeck_color_init(display); /* HDR10 (opt-in): decides the gate from the app's request + the
* display + the layer path above; creates wp_color_manager_v1
- * only when it is open (banner_color.h). Before any client can
+ * only when it is open (droiddeck_color.h). Before any client can
* bind zwp_linux_dmabuf_v1, whose table it widens. */
wl_list_init(&g_pending_releases);
g_release_timer_fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC);
diff --git a/app/src/main/cpp/waylandcomp/src/compositor_internal.h b/app/src/main/cpp/waylandcomp/src/compositor_internal.h
index db739132af..0468f007f3 100644
--- a/app/src/main/cpp/waylandcomp/src/compositor_internal.h
+++ b/app/src/main/cpp/waylandcomp/src/compositor_internal.h
@@ -1,7 +1,7 @@
/*
* What compositor.c shares with the protocol modules split out of it (wl_dmabuf.c): the dma-buf
* buffer records, the per-client bookkeeping and the few functions and globals both sides use.
- * Everything declared here is hidden: it is internal to libbannerwayland, not part of its ABI.
+ * Everything declared here is hidden: it is internal to libdroiddeckwayland, not part of its ABI.
*/
#pragma once
#include
@@ -13,7 +13,7 @@
#define COMPOSITOR_INTERNAL __attribute__((visibility("hidden")))
#ifndef WLOGE
-#define WLOGE(...) __android_log_print(ANDROID_LOG_ERROR, "BannerWayland", __VA_ARGS__)
+#define WLOGE(...) __android_log_print(ANDROID_LOG_ERROR, "DroidDeckWayland", __VA_ARGS__)
#endif
/* ------------------------------------------------------------------ dmabuf buffers */
@@ -71,8 +71,8 @@ struct client_info {
COMPOSITOR_INTERNAL struct client_info *client_info_of(struct wl_client *client);
COMPOSITOR_INTERNAL void dmabuf_buffer_unref(struct dmabuf_buffer *b);
COMPOSITOR_INTERNAL extern const struct wl_buffer_interface dbuf_buffer_impl;
-extern volatile int g_ubwc; /* BANNER_WAYLAND_UBWC (waylandcomp_jni.c sets it) */
-extern volatile int g_no_render_node; /* BANNER_WAYLAND_NO_RENDER_NODE */
+extern volatile int g_ubwc; /* DROIDDECK_WAYLAND_UBWC (waylandcomp_jni.c sets it) */
+extern volatile int g_no_render_node; /* DROIDDECK_WAYLAND_NO_RENDER_NODE */
/* ---- wl_dmabuf.c */
COMPOSITOR_INTERNAL extern dev_t g_main_device; /* the render node clients are told to allocate on */
diff --git a/app/src/main/cpp/waylandcomp/src/banner_color.h b/app/src/main/cpp/waylandcomp/src/droiddeck_color.h
similarity index 70%
rename from app/src/main/cpp/waylandcomp/src/banner_color.h
rename to app/src/main/cpp/waylandcomp/src/droiddeck_color.h
index e39a81bfbd..9591870a1f 100644
--- a/app/src/main/cpp/waylandcomp/src/banner_color.h
+++ b/app/src/main/cpp/waylandcomp/src/droiddeck_color.h
@@ -1,5 +1,5 @@
-#ifndef BANNER_COLOR_H
-#define BANNER_COLOR_H
+#ifndef DROIDDECK_COLOR_H
+#define DROIDDECK_COLOR_H
/*
* HDR10 output on the Wayland backend (opt-in) - the compositor half of HDR_RECON.md Phase A (round 1)
* plus HDR-aware composition (round 2, hdr_compose.h), implemented in wl_color_mgmt.c. The game half
@@ -8,18 +8,18 @@
* with DXVK_HDR=1 (the app exports it when the setting is on).
*
* THE GATE. Nothing here exists for a session unless all of these hold when the compositor starts:
- * - the container's / game's "HDR output" setting is on, or BANNER_WAYLAND_HDR=1 in their
+ * - the container's / game's "HDR output" setting is on, or DROIDDECK_WAYLAND_HDR=1 in their
* environment (which overrides the setting either way);
* - the display the game is on lists HDR10 among its supported HDR types (read by the app from
* android.view.Display - a property of the connector, not of the device);
* - display layers with dataspace control (ASurfaceTransaction_setBufferDataSpace, Android 10+)
* and the zero-copy global (banner_ahb_v1): the HDR frame (or the composed HDR picture) is shown
* on the game's own display layer, tagged BT2020_PQ.
- * In game, the drawer's HDR output switch (banner_color_set_output) flips between that and the same
+ * In game, the drawer's HDR output switch (droiddeck_color_set_output) flips between that and the same
* frames tone-mapped to SDR, live; the gate itself never changes during a session.
* A closed gate advertises nothing - no colour-management global, no 10-bit dma-buf formats - so the
* session is byte-for-byte what it was before this file existed, and the session log says why.
- * BANNER_WAYLAND_HDR=force skips the display check only (testing the negotiation on an SDR panel;
+ * DROIDDECK_WAYLAND_HDR=force skips the display check only (testing the negotiation on an SDR panel;
* SurfaceFlinger then tone-maps the layer, and says so in its composition type).
*
* WHAT AN OPEN GATE OFFERS (exactly the subset Mesa binds, HDR_RECON.md §2.2): wp_color_manager_v1
@@ -35,13 +35,13 @@
#include
/* ADataSpace values (NDK ) the layer path emits. */
-#define BANNER_ADATASPACE_UNKNOWN 0
-#define BANNER_ADATASPACE_BT2020_PQ 163971072 /* STANDARD_BT2020 | TRANSFER_ST2084 | RANGE_FULL = 0x09c60000 */
-#define BANNER_ADATASPACE_BT2020_HLG 168165376 /* STANDARD_BT2020 | TRANSFER_HLG | RANGE_FULL */
+#define DROIDDECK_ADATASPACE_UNKNOWN 0
+#define DROIDDECK_ADATASPACE_BT2020_PQ 163971072 /* STANDARD_BT2020 | TRANSFER_ST2084 | RANGE_FULL = 0x09c60000 */
+#define DROIDDECK_ADATASPACE_BT2020_HLG 168165376 /* STANDARD_BT2020 | TRANSFER_HLG | RANGE_FULL */
/* One image description as the program made it, and what it becomes on a display layer. Immutable:
* a changed description is a new record with a new identity. */
-struct banner_color {
+struct droiddeck_color {
uint32_t identity; /* the id the `ready` event carried (never 0) */
uint32_t primaries, tf; /* wp_color_manager_v1 named values */
int32_t dataspace; /* ADataSpace on a display layer; 0 = none (treated as sRGB) */
@@ -54,97 +54,97 @@ struct banner_color {
};
/* ---- app -> compositor (JNI, any thread) */
-/* mode 0 = off, 1 = BANNER_WAYLAND_HDR=1, 2 = BANNER_WAYLAND_HDR=force (testing). source names where
+/* mode 0 = off, 1 = DROIDDECK_WAYLAND_HDR=1, 2 = DROIDDECK_WAYLAND_HDR=force (testing). source names where
* the switch came from; dxvk_hdr = DXVK_HDR=1 is in the game's environment; zero_copy_forced = the
* app turned zero-copy presentation on for this session because HDR needs it. Before the start. */
-void banner_color_set_request(int mode, const char *source, int dxvk_hdr, int zero_copy_forced);
+void droiddeck_color_set_request(int mode, const char *source, int dxvk_hdr, int zero_copy_forced);
/* The display the game is on, as android.view.Display reports it. Before the start (it feeds the
* gate) and again whenever it changes (logged; the gate is decided once per session). */
-void banner_color_set_display(int id, const char *name, const char *formats, int hdr10, float max_lum,
+void droiddeck_color_set_display(int id, const char *name, const char *formats, int hdr10, float max_lum,
float max_avg, float min_lum, int ratio_available, float ratio, int api);
/* One reading of Display.getHdrSdrRatio() (API 34+; < 0 = not available). listener = it came from
* the display's ratio listener rather than the app's periodic sampler. */
-void banner_color_ratio_sample(float ratio, int listener);
+void droiddeck_color_ratio_sample(float ratio, int listener);
/* Milliseconds since an HDR frame last went onto a display layer; -1 = none this session. */
-int banner_color_last_frame_age_ms(void);
+int droiddeck_color_last_frame_age_ms(void);
/* -1 = the compositor has not decided yet, 0 = closed, 1 = open. */
-int banner_color_gate_state(void);
+int droiddeck_color_gate_state(void);
/* The session is ending: write the summary line ("HDR on screen: …"). */
-void banner_color_session_end(void);
+void droiddeck_color_session_end(void);
/* 1 while HDR frames are really on screen: a frame tagged BT2020_PQ reached a display layer or the HDR
* swapchain in the last 1.5 s AND, where the display reports an HDR/SDR ratio, its last reading is
* above 1.01 (the HUD badge). */
-int banner_color_hdr_on_screen(void);
+int droiddeck_color_hdr_on_screen(void);
/* The HUD / drawer state: 0 = no HDR frames on screen (or not confirmed yet), 1 = HDR frames on screen
- * with headroom (as banner_color_hdr_on_screen), 2 = HDR frames on screen but the display has given
+ * with headroom (as droiddeck_color_hdr_on_screen), 2 = HDR frames on screen but the display has given
* them NO headroom (ratio <= 1.01) for 5 s or more - the brightness slider at maximum, or a screen
* recording (Android turns HDR headroom off while the screen is recorded). */
-int banner_color_hdr_state(void);
+int droiddeck_color_hdr_state(void);
/* Nits SDR content is placed at inside an HDR picture (default 203, BT.2408); any thread. */
-void banner_color_set_sdr_white(float nits);
-float banner_color_sdr_white(void);
-/* The HDR session was asked for (BANNER_WAYLAND_HDR / the setting resolved on or force) - known before
+void droiddeck_color_set_sdr_white(float nits);
+float droiddeck_color_sdr_white(void);
+/* The HDR session was asked for (DROIDDECK_WAYLAND_HDR / the setting resolved on or force) - known before
* the compositor starts, so the Vulkan instance can enable VK_EXT_swapchain_colorspace for it. */
-int banner_color_requested(void);
+int droiddeck_color_requested(void);
/* The drawer's live "HDR output" switch, per session, starting ON. On = HDR frames go to the display as
* HDR; off = the SAME frames are composed tone-mapped to SDR (hdr_compose.h) - the game is told nothing
* and keeps rendering HDR (DXVK_HDR and the colour-manager offer were decided at launch). Compositor
- * thread (the app posts it through banner_host_hdr_output); logs the flip and redraws. */
-void banner_color_set_output(int on);
+ * thread (the app posts it through droiddeck_host_hdr_output); logs the flip and redraws. */
+void droiddeck_color_set_output(int on);
/* 1 = HDR output on (any thread). */
-int banner_color_output(void);
+int droiddeck_color_output(void);
/* 1 while an HDR game's frames are being shown tone-mapped to SDR (the last one < 1.5 s ago); any thread. */
-int banner_color_tonemapped_on_screen(void);
+int droiddeck_color_tonemapped_on_screen(void);
/* Device evidence beside the HDR/SDR headroom (the app, non-root APIs; any thread; HDR sessions only):
* PowerManager thermal status (0..6, -1 unknown) + getThermalHeadroom(10) (< 0 = not available),
* Settings.System SCREEN_BRIGHTNESS (0..255, -1 unknown) + SCREEN_BRIGHTNESS_MODE (1 auto, 0 manual).
* Changes of status and brightness are logged; every no-headroom line, the 10 s line and the verdict
* carry the last values. */
-void banner_color_env_sample(int thermal, float headroom, int brightness, int bmode);
+void droiddeck_color_env_sample(int thermal, float headroom, int brightness, int bmode);
/* ---- the explicit HDR headroom request (Android 15+: ASurfaceTransaction_setDesiredHdrHeadroom on the game
* layer, SurfaceView.setDesiredHdrHeadroom on the screen surface). Some phones only boost HDR when asked. */
/* The ratio to ask for an HDR frame of `c`: content peak (max CLL, else mastering max, else the display's
* peak) / SDR white (203), capped at the display's highest ratio when it reports one; 0 = ask nothing
* (not HDR, or the display reports it cannot boost). `why` gets the one-line reason. Any thread. */
-float banner_color_desired_headroom(const struct banner_color *c, char *why, size_t n);
+float droiddeck_color_desired_headroom(const struct droiddeck_color *c, char *why, size_t n);
/* What was last asked for (> 0 the ratio, 0 nothing, -1 the API is missing): for the no-headroom lines. */
-void banner_color_note_headroom_request(float ratio);
+void droiddeck_color_note_headroom_request(float ratio);
/* Display.getHighestHdrSdrRatio() (Android 16+; <= 0 = not reported). Any thread; logged when it arrives. */
-void banner_color_set_highest_ratio(float ratio);
+void droiddeck_color_set_highest_ratio(float ratio);
/* The headroom the SCREEN surface should ask for (frames through the HDR10 swapchain in the last 1.5 s),
* 0 = none; `why` gets the reason. The app polls it and applies it. Any thread. */
-float banner_color_screen_headroom(char *why, size_t n);
+float droiddeck_color_screen_headroom(char *why, size_t n);
/* ---- compositor.c -> here */
/* Decide the gate (call after ahb_swapchain_init) and create the global when it is open. */
-void banner_color_init(struct wl_display *display);
+void droiddeck_color_init(struct wl_display *display);
/* The gate is open: the 10-bit dma-buf formats may be advertised, descriptions may exist. */
-int banner_color_hdr_open(void);
+int droiddeck_color_hdr_open(void);
/* wl_surface.commit: the pending image description (if any request touched it) becomes current. */
-void banner_color_commit(struct wl_resource *surface);
+void droiddeck_color_commit(struct wl_resource *surface);
/* The surface's current image description; NULL = none (sRGB, today's default). */
-const struct banner_color *banner_color_of(struct wl_resource *surface);
+const struct droiddeck_color *droiddeck_color_of(struct wl_resource *surface);
/* A program disconnected: if it presented HDR, its part of the summary is written now. */
-void banner_color_client_gone(struct wl_client *client);
+void droiddeck_color_client_gone(struct wl_client *client);
/* The 10 s summary tick (one `color` line when anything HDR happened in the window). */
-void banner_color_stats_tick(void);
+void droiddeck_color_stats_tick(void);
/* A frame of an HDR-described surface went through the compositor's own 8-bit sRGB pass this scene
* (who = the window, reason = why it did not get the display layer). Shown untone-mapped. */
-void banner_color_frame_copied(const char *who, const char *reason);
+void droiddeck_color_frame_copied(const char *who, const char *reason);
/* ---- sc_layer.c / compositor.c -> here: a NEW frame of an HDR-described surface was shown, and how */
-enum banner_hdr_path {
- BANNER_HDR_ZERO_COPY = 0, /* the game's own gralloc buffer on its display layer, tagged */
- BANNER_HDR_LAYER_COPY, /* one 8-bit copy of the game's frame on its layer, tagged */
- BANNER_HDR_COMPOSED, /* the whole scene composed into one PQ picture on the game layer (hdr_compose.h) */
- BANNER_HDR_SWAPCHAIN, /* composed into PQ and presented through an HDR10 swapchain (frame generation) */
- BANNER_HDR_TONEMAPPED, /* composed and tone-mapped to SDR (HDR output switched off, or a present that
+enum droiddeck_hdr_path {
+ DROIDDECK_HDR_ZERO_COPY = 0, /* the game's own gralloc buffer on its display layer, tagged */
+ DROIDDECK_HDR_LAYER_COPY, /* one 8-bit copy of the game's frame on its layer, tagged */
+ DROIDDECK_HDR_COMPOSED, /* the whole scene composed into one PQ picture on the game layer (hdr_compose.h) */
+ DROIDDECK_HDR_SWAPCHAIN, /* composed into PQ and presented through an HDR10 swapchain (frame generation) */
+ DROIDDECK_HDR_TONEMAPPED, /* composed and tone-mapped to SDR (HDR output switched off, or a present that
* cannot carry HDR) - NOT HDR */
};
/* ahb_format = the buffer's AHARDWAREBUFFER_FORMAT_* where one exists (0 otherwise). */
-void banner_color_frame_shown(const struct banner_color *c, int path, uint32_t ahb_format);
+void droiddeck_color_frame_shown(const struct droiddeck_color *c, int path, uint32_t ahb_format);
/* "RGBA1010102 (10-bit)" etc. for an AHARDWAREBUFFER_FORMAT_* value (static buffer). */
-const char *banner_ahb_format_name(uint32_t format);
+const char *droiddeck_ahb_format_name(uint32_t format);
#endif
diff --git a/app/src/main/cpp/waylandcomp/src/banner_ext.c b/app/src/main/cpp/waylandcomp/src/droiddeck_ext.c
similarity index 82%
rename from app/src/main/cpp/waylandcomp/src/banner_ext.c
rename to app/src/main/cpp/waylandcomp/src/droiddeck_ext.c
index 0b9c8c4110..74ddc6adaf 100644
--- a/app/src/main/cpp/waylandcomp/src/banner_ext.c
+++ b/app/src/main/cpp/waylandcomp/src/droiddeck_ext.c
@@ -2,7 +2,7 @@
* Host → compositor message queue plus the init of the extension modules.
*
* The app's threads (UI thread, clipboard listener) hand text to the compositor through
- * banner_host_* ; the messages are queued under a mutex and a pipe byte wakes the wl event
+ * droiddeck_host_* ; the messages are queued under a mutex and a pipe byte wakes the wl event
* loop, which drains them on the compositor thread - the only thread that may touch
* wl_resources.
*/
@@ -13,9 +13,9 @@
#include
#include
#include
-#include "banner_ext.h"
+#include "droiddeck_ext.h"
#include "ahb_swapchain.h"
-#include "banner_color.h"
+#include "droiddeck_color.h"
enum host_kind { HOST_CLIPBOARD = 1, HOST_TEXT_COMMIT, HOST_TEXT_PREEDIT, HOST_TEXT_DELETE, HOST_ZERO_COPY, HOST_HDR_OUTPUT };
@@ -53,22 +53,22 @@ static void host_post(enum host_kind kind, const char *text, size_t len, int a,
}
}
-void banner_host_clipboard_text(const char *utf8, int len) {
+void droiddeck_host_clipboard_text(const char *utf8, int len) {
host_post(HOST_CLIPBOARD, utf8, len > 0 ? (size_t)len : 0, 0, 0);
}
-void banner_host_text_commit(const char *utf8, int len) {
+void droiddeck_host_text_commit(const char *utf8, int len) {
host_post(HOST_TEXT_COMMIT, utf8, len > 0 ? (size_t)len : 0, 0, 0);
}
-void banner_host_text_preedit(const char *utf8, int len, int cursor_begin, int cursor_end) {
+void droiddeck_host_text_preedit(const char *utf8, int len, int cursor_begin, int cursor_end) {
host_post(HOST_TEXT_PREEDIT, utf8, len > 0 ? (size_t)len : 0, cursor_begin, cursor_end);
}
-void banner_host_text_delete(int before, int after) {
+void droiddeck_host_text_delete(int before, int after) {
host_post(HOST_TEXT_DELETE, NULL, 0, before, after);
}
-void banner_host_zero_copy(int on, int live) {
+void droiddeck_host_zero_copy(int on, int live) {
host_post(HOST_ZERO_COPY, NULL, 0, on, live);
}
-void banner_host_hdr_output(int on) {
+void droiddeck_host_hdr_output(int on) {
host_post(HOST_HDR_OUTPUT, NULL, 0, on, 0);
}
@@ -99,17 +99,17 @@ static int on_wake(int fd, uint32_t mask, void *data) {
ahb_swapchain_set_mode(m->a, m->b);
break;
case HOST_HDR_OUTPUT:
- banner_color_set_output(m->a);
+ droiddeck_color_set_output(m->a);
break;
}
free(m->text);
free(m);
}
- wl_display_flush_clients(banner_get_display());
+ wl_display_flush_clients(droiddeck_get_display());
return 0;
}
-void banner_ext_init(struct wl_display *display) {
+void droiddeck_ext_init(struct wl_display *display) {
struct wl_event_loop *loop = wl_display_get_event_loop(display);
if (pipe2(g_wake, O_CLOEXEC | O_NONBLOCK) == 0) {
wl_event_loop_add_fd(loop, g_wake[0], WL_EVENT_READABLE, on_wake, NULL);
@@ -118,7 +118,7 @@ void banner_ext_init(struct wl_display *display) {
pthread_mutex_unlock(&g_mu);
if (queued) { char c = 1; ssize_t n = write(g_wake[1], &c, 1); (void)n; }
} else
- __android_log_print(ANDROID_LOG_ERROR, "BannerWayland", "host queue pipe failed");
+ __android_log_print(ANDROID_LOG_ERROR, "DroidDeckWayland", "host queue pipe failed");
clipboard_init(display);
text_input_init(display);
toplevel_icon_init(display);
diff --git a/app/src/main/cpp/waylandcomp/src/droiddeck_ext.h b/app/src/main/cpp/waylandcomp/src/droiddeck_ext.h
new file mode 100644
index 0000000000..e21014fbf5
--- /dev/null
+++ b/app/src/main/cpp/waylandcomp/src/droiddeck_ext.h
@@ -0,0 +1,50 @@
+/*
+ * Interface between compositor.c and the extension modules that live in their own files:
+ * wl_clipboard.c wl_data_device_manager + zwlr_data_control_manager_v1 (selection only)
+ * wl_text_input.c zwp_text_input_manager_v3 (host IME / soft keyboard)
+ * wl_toplevel_icon.c xdg_toplevel_icon_manager_v1 (accepted, not rendered)
+ * droiddeck_ext.c the host→compositor message queue shared by the modules
+ * Everything here runs on the compositor (dispatch) thread unless noted.
+ */
+#pragma once
+#include
+#include
+
+void droiddeck_log(const char *tag, const char *fmt, ...);
+
+/* ---- compositor.c → modules */
+void droiddeck_ext_init(struct wl_display *display); /* creates the globals + host queue */
+void droiddeck_clipboard_keyboard_focus(struct wl_client *client); /* keyboard focus moved; NULL = none */
+void droiddeck_text_input_refocus(void); /* the text-input target may have changed */
+void droiddeck_text_input_surface_gone(struct wl_resource *surface);
+
+/* ---- modules → compositor.c */
+const char *droiddeck_client_name(struct wl_client *client);
+struct wl_display *droiddeck_get_display(void);
+/* The surface text input follows (the last clicked window, else the topmost program window). */
+struct wl_resource *droiddeck_ime_target(void);
+/* Scene (virtual desktop) origin of a toplevel surface; 0,0 when unknown. */
+void droiddeck_surface_scene_origin(struct wl_resource *surface, int *x, int *y);
+/* Deliver a key press/release through the wl_keyboard path as if typed. */
+void droiddeck_inject_key(uint32_t evdev, int pressed);
+
+/* ---- modules → app (JNI upcalls; waylandcomp_jni.c) */
+void droiddeck_on_clipboard_text(const char *utf8, int len);
+void droiddeck_on_text_input(int enabled, const char *program, int x, int y, int w, int h);
+
+/* ---- app → modules (callable from any thread; queued to the compositor thread) */
+void droiddeck_host_clipboard_text(const char *utf8, int len); /* len 0 = clear */
+void droiddeck_host_text_commit(const char *utf8, int len);
+void droiddeck_host_text_preedit(const char *utf8, int len, int cursor_begin, int cursor_end);
+void droiddeck_host_text_delete(int before, int after);
+void droiddeck_host_zero_copy(int on, int live); /* the drawer's zero-copy switch (ahb_swapchain_set_mode) */
+void droiddeck_host_hdr_output(int on); /* the drawer's HDR output switch (droiddeck_color_set_output) */
+
+/* ---- module internals reached through the queue (droiddeck_ext.c → modules) */
+void clipboard_init(struct wl_display *display);
+void clipboard_host_text(char *utf8, size_t len); /* takes ownership of utf8 */
+void text_input_init(struct wl_display *display);
+void text_input_host_commit(const char *utf8, size_t len);
+void text_input_host_preedit(const char *utf8, size_t len, int cursor_begin, int cursor_end);
+void text_input_host_delete(int before, int after);
+void toplevel_icon_init(struct wl_display *display);
diff --git a/app/src/main/cpp/waylandcomp/src/effects_chain.c b/app/src/main/cpp/waylandcomp/src/effects_chain.c
index a4227102d8..0ab39af658 100644
--- a/app/src/main/cpp/waylandcomp/src/effects_chain.c
+++ b/app/src/main/cpp/waylandcomp/src/effects_chain.c
@@ -2,7 +2,7 @@
#define _POSIX_C_SOURCE 200809L
#include "effects_chain.h"
#include "vk_loader.h"
-#include "vk_present.h" /* banner_log */
+#include "vk_present.h" /* droiddeck_log */
#include
#include
#include
@@ -115,7 +115,7 @@ static void log_settings(const struct fx_settings *s) {
char line[400];
int n;
if (!spatial_mode(s->scaling) && !effect_count(s)) {
- banner_log("effects", "all off: scaling=%s (plain blit)", scaling_name(s->scaling));
+ droiddeck_log("effects", "all off: scaling=%s (plain blit)", scaling_name(s->scaling));
return;
}
n = snprintf(line, sizeof(line), "scaling=%s", scaling_name(s->scaling));
@@ -133,7 +133,7 @@ static void log_settings(const struct fx_settings *s) {
if (s->crt) n += snprintf(line + n, sizeof(line) - n, ", CRT on");
if (s->deband_on) n += snprintf(line + n, sizeof(line) - n, ", Deband on %d%%", s->deband_pct);
(void)n;
- banner_log("effects", "%s", line);
+ droiddeck_log("effects", "%s", line);
}
int vkp_effects_sync(void) {
@@ -262,7 +262,7 @@ static int target_ensure(struct fx_target *t, int w, int h, const char *what) {
VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
.sharingMode = VK_SHARING_MODE_EXCLUSIVE, .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED};
VkResult r = g_vk.CreateImage(g_dev, &ii, NULL, &t->img);
- if (r != VK_SUCCESS) { banner_log("error", "effects: %s image %dx%d: vkCreateImage %d", what, w, h, (int)r); return -1; }
+ if (r != VK_SUCCESS) { droiddeck_log("error", "effects: %s image %dx%d: vkCreateImage %d", what, w, h, (int)r); return -1; }
VkMemoryRequirements req;
g_vk.GetImageMemoryRequirements(g_dev, t->img, &req);
int idx = memtype(req.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
@@ -271,7 +271,7 @@ static int target_ensure(struct fx_target *t, int w, int h, const char *what) {
.memoryTypeIndex = (uint32_t)(idx < 0 ? 0 : idx)};
r = g_vk.AllocateMemory(g_dev, &mai, NULL, &t->mem);
if (r != VK_SUCCESS) {
- banner_log("error", "effects: %s image %dx%d (%llu bytes): vkAllocateMemory %d", what, w, h,
+ droiddeck_log("error", "effects: %s image %dx%d (%llu bytes): vkAllocateMemory %d", what, w, h,
(unsigned long long)req.size, (int)r);
target_destroy(t); return -1;
}
@@ -312,7 +312,7 @@ static VkShaderModule shader(const uint32_t *code, size_t size) {
* viewport/scissor - the X11 renderer's createPostPipeline. */
static VkPipeline post_pipeline(VkShaderModule vert, const uint32_t *frag_code, size_t frag_size, const char *name) {
VkShaderModule frag = shader(frag_code, frag_size);
- if (!frag) { banner_log("error", "effects: %s: vkCreateShaderModule failed", name); return VK_NULL_HANDLE; }
+ if (!frag) { droiddeck_log("error", "effects: %s: vkCreateShaderModule failed", name); return VK_NULL_HANDLE; }
VkPipelineShaderStageCreateInfo st[2] = {
{.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, .stage = VK_SHADER_STAGE_VERTEX_BIT, .module = vert, .pName = "main"},
{.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, .stage = VK_SHADER_STAGE_FRAGMENT_BIT, .module = frag, .pName = "main"}};
@@ -340,7 +340,7 @@ static VkPipeline post_pipeline(VkShaderModule vert, const uint32_t *frag_code,
VkPipeline p = VK_NULL_HANDLE;
VkResult r = g_vk.CreateGraphicsPipelines(g_dev, VK_NULL_HANDLE, 1, &pi, NULL, &p);
g_vk.DestroyShaderModule(g_dev, frag, NULL);
- if (r != VK_SUCCESS) { banner_log("error", "effects: %s: vkCreateGraphicsPipelines %d", name, (int)r); return VK_NULL_HANDLE; }
+ if (r != VK_SUCCESS) { droiddeck_log("error", "effects: %s: vkCreateGraphicsPipelines %d", name, (int)r); return VK_NULL_HANDLE; }
return p;
}
@@ -367,7 +367,7 @@ void vkp_effects_set_formats(VkFormat scene_fmt, VkFormat target_fmt) {
g_fx_fmt = target_fmt;
g_scene_fmt = scene_fmt;
if (g_dev)
- banner_log("effects", "chain now works in %s (%s)",
+ droiddeck_log("effects", "chain now works in %s (%s)",
target_fmt == FX_FORMAT ? "8-bit RGBA"
: target_fmt == VK_FORMAT_R16G16B16A16_SFLOAT ? "FP16 RGBA" : "10-bit RGB",
target_fmt == FX_FORMAT ? "SDR frames"
@@ -383,7 +383,7 @@ void vkp_effects_set_formats(VkFormat scene_fmt, VkFormat target_fmt) {
* unavailable for this session (logged once; frames fall back to the plain blit). */
static int objects_ensure(void) {
if (g_ready) return g_ready == 1 ? 0 : -1;
- if (!g_dev || !g_vk.CreateGraphicsPipelines) { g_ready = -1; banner_log("error", "effects: no device for the chain"); return -1; }
+ if (!g_dev || !g_vk.CreateGraphicsPipelines) { g_ready = -1; droiddeck_log("error", "effects: no device for the chain"); return -1; }
/* Render pass: one colour target, overwritten whole (DONT_CARE), left SHADER_READ_ONLY for the
* next pass. The dependencies order this pass after whoever read the target last (previous
* pass / previous frame's blit) and before whoever samples or blits it next. */
@@ -448,12 +448,12 @@ static int objects_ensure(void) {
#undef MK
g_vk.DestroyShaderModule(g_dev, vert, NULL);
g_ready = 1;
- banner_log("effects", "chain ready: 13 passes (SGSR, SGSR HQ, NIS, FSR EASU+RCAS, CAS, colour, FXAA, Toon, HDR, NTSC, CRT, deband) on %s", vkp_gpu_name());
+ droiddeck_log("effects", "chain ready: 13 passes (SGSR, SGSR HQ, NIS, FSR EASU+RCAS, CAS, colour, FXAA, Toon, HDR, NTSC, CRT, deband) on %s", vkp_gpu_name());
return 0;
fail:
objects_destroy();
g_ready = -1;
- banner_log("error", "effects: the screen-effect chain could not be built on this driver; effects are off for this session");
+ droiddeck_log("error", "effects: the screen-effect chain could not be built on this driver; effects are off for this session");
return -1;
}
diff --git a/app/src/main/cpp/waylandcomp/src/framegen_bridge.c b/app/src/main/cpp/waylandcomp/src/framegen_bridge.c
index 47a819bfdd..ac2100365c 100644
--- a/app/src/main/cpp/waylandcomp/src/framegen_bridge.c
+++ b/app/src/main/cpp/waylandcomp/src/framegen_bridge.c
@@ -11,9 +11,9 @@
#include
#include
-void banner_log(const char *tag, const char *fmt, ...) __attribute__((format(printf, 2, 3)));
-#define FGLOG(...) banner_log("framegen", __VA_ARGS__)
-#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, "BannerWayland", __VA_ARGS__)
+void droiddeck_log(const char *tag, const char *fmt, ...) __attribute__((format(printf, 2, 3)));
+#define FGLOG(...) droiddeck_log("framegen", __VA_ARGS__)
+#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, "DroidDeckWayland", __VA_ARGS__)
/* ---- app controls (written from any thread, read on the compositor thread) ------------- */
static _Atomic int g_kind = VKP_FG_ENGINE_LSFG;
diff --git a/app/src/main/cpp/waylandcomp/src/framegen_engine.cpp b/app/src/main/cpp/waylandcomp/src/framegen_engine.cpp
index 35e160edc0..12674e533b 100644
--- a/app/src/main/cpp/waylandcomp/src/framegen_engine.cpp
+++ b/app/src/main/cpp/waylandcomp/src/framegen_engine.cpp
@@ -20,8 +20,8 @@
#include "lsfg/lsfg_vkd.h"
#include "winfg/winfg_engine.h"
-#define ELOG(...) __android_log_print(ANDROID_LOG_INFO, "BannerWayland", "framegen: " __VA_ARGS__)
-#define ELOGE(...) __android_log_print(ANDROID_LOG_ERROR, "BannerWayland", "framegen: " __VA_ARGS__)
+#define ELOG(...) __android_log_print(ANDROID_LOG_INFO, "DroidDeckWayland", "framegen: " __VA_ARGS__)
+#define ELOGE(...) __android_log_print(ANDROID_LOG_ERROR, "DroidDeckWayland", "framegen: " __VA_ARGS__)
namespace {
diff --git a/app/src/main/cpp/waylandcomp/src/hdr_compose.c b/app/src/main/cpp/waylandcomp/src/hdr_compose.c
index a927df9088..6f54d4e0cd 100644
--- a/app/src/main/cpp/waylandcomp/src/hdr_compose.c
+++ b/app/src/main/cpp/waylandcomp/src/hdr_compose.c
@@ -2,7 +2,7 @@
#define _POSIX_C_SOURCE 200809L
#include "hdr_compose.h"
#include "vk_loader.h"
-#include "vk_present.h" /* banner_log, vkp_gpu_name */
+#include "vk_present.h" /* droiddeck_log, vkp_gpu_name */
#include
#include
@@ -190,7 +190,7 @@ static int objects_ensure(void) {
if (!(g_out[i].pipe = make_pipe(g_out[i].rp))) goto fail;
}
g_ready = 1;
- banner_log("color", "HDR composition ready on %s: scenes that mix HDR and SDR content are put into one "
+ droiddeck_log("color", "HDR composition ready on %s: scenes that mix HDR and SDR content are put into one "
"encoding (PQ BT.2020, or tone-mapped sRGB) instead of being shown washed out", vkp_gpu_name());
return 0;
fail:
@@ -200,7 +200,7 @@ fail:
g_dev = keep;
}
g_ready = -1;
- banner_log("error", "color: the HDR composition pass could not be built on this driver; HDR scenes that cannot "
+ droiddeck_log("error", "color: the HDR composition pass could not be built on this driver; HDR scenes that cannot "
"stay on the game's own layer are shown the old way (washed out) this session");
return -1;
}
diff --git a/app/src/main/cpp/waylandcomp/src/sc_layer.c b/app/src/main/cpp/waylandcomp/src/sc_layer.c
index e8a651c42c..3f44a6be8f 100644
--- a/app/src/main/cpp/waylandcomp/src/sc_layer.c
+++ b/app/src/main/cpp/waylandcomp/src/sc_layer.c
@@ -5,7 +5,7 @@
#define _GNU_SOURCE
#include "sc_layer.h"
#include "ahb_swapchain.h"
-#include "banner_color.h"
+#include "droiddeck_color.h"
#include "vk_present.h"
#include
#include
@@ -34,7 +34,7 @@
/* The gralloc buffer handle behind an AHardwareBuffer (AOSP cutils/native_handle.h, which the NDK
* does not ship; the layout is a stable ABI: fds first, then ints). */
-struct banner_native_handle { int version; int numFds; int numInts; int data[]; };
+struct droiddeck_native_handle { int version; int numFds; int numInts; int data[]; };
/* ---- libandroid SurfaceControl API (dlsym) ---------------------------------------------------- */
@@ -44,12 +44,12 @@ typedef struct ASurfaceTransactionStats ASurfaceTransactionStats;
typedef void (*sc_complete_fn)(void *context, ASurfaceTransactionStats *stats);
/* (NDK, API 29), declared here like the rest of this table: stable ABI. */
-struct banner_color_xy { float x, y; };
-struct banner_hdr_smpte2086 {
- struct banner_color_xy displayPrimaryRed, displayPrimaryGreen, displayPrimaryBlue, whitePoint;
+struct droiddeck_color_xy { float x, y; };
+struct droiddeck_hdr_smpte2086 {
+ struct droiddeck_color_xy displayPrimaryRed, displayPrimaryGreen, displayPrimaryBlue, whitePoint;
float maxLuminance, minLuminance;
};
-struct banner_hdr_cta861_3 { float maxContentLightLevel, maxFrameAverageLightLevel; };
+struct droiddeck_hdr_cta861_3 { float maxContentLightLevel, maxFrameAverageLightLevel; };
static struct {
ASurfaceControl *(*createFromWindow)(ANativeWindow *, const char *);
@@ -69,11 +69,11 @@ static struct {
* the layer simply carries no vote and the app's surface vote is all there is. */
void (*setFrameRate)(ASurfaceTransaction *, ASurfaceControl *, float, int8_t);
void (*setFrameRateStrategy)(ASurfaceTransaction *, ASurfaceControl *, float, int8_t, int8_t);
- /* Colour (API 29), optional: only an HDR session ever calls them (banner_color.h's gate needs
+ /* Colour (API 29), optional: only an HDR session ever calls them (droiddeck_color.h's gate needs
* setBufferDataSpace; the metadata calls are sent when present). */
void (*setBufferDataSpace)(ASurfaceTransaction *, ASurfaceControl *, int32_t);
- void (*setHdrMetadata_smpte2086)(ASurfaceTransaction *, ASurfaceControl *, const struct banner_hdr_smpte2086 *);
- void (*setHdrMetadata_cta861_3)(ASurfaceTransaction *, ASurfaceControl *, const struct banner_hdr_cta861_3 *);
+ void (*setHdrMetadata_smpte2086)(ASurfaceTransaction *, ASurfaceControl *, const struct droiddeck_hdr_smpte2086 *);
+ void (*setHdrMetadata_cta861_3)(ASurfaceTransaction *, ASurfaceControl *, const struct droiddeck_hdr_cta861_3 *);
/* Not in the public NDK headers (vndk/hardware_buffer.h) but exported by libnativewindow.so on
* every device; Mesa's Android WSI calls it for every gralloc buffer it imports. */
const void *(*getNativeHandle)(const AHardwareBuffer *);
@@ -95,12 +95,12 @@ static int load_api(void) {
if (!nw) nw = dlopen("libnativewindow.so", RTLD_NOW);
api.getNativeHandle = nw ? dlsym(nw, "AHardwareBuffer_getNativeHandle") : NULL;
if (!api.getNativeHandle) {
- banner_log("layer", "unavailable: libnativewindow.so has no AHardwareBuffer_getNativeHandle");
+ droiddeck_log("layer", "unavailable: libnativewindow.so has no AHardwareBuffer_getNativeHandle");
return -1;
}
void *lib = dlopen("libandroid.so", RTLD_NOW | RTLD_NOLOAD);
if (!lib) lib = dlopen("libandroid.so", RTLD_NOW);
- if (!lib) { banner_log("layer", "unavailable: dlopen(libandroid.so): %s", dlerror()); return -1; }
+ if (!lib) { droiddeck_log("layer", "unavailable: dlopen(libandroid.so): %s", dlerror()); return -1; }
#define SYM(field, name) api.field = dlsym(lib, name)
SYM(createFromWindow, "ASurfaceControl_createFromWindow");
SYM(release, "ASurfaceControl_release");
@@ -125,7 +125,7 @@ static int load_api(void) {
if (!api.createFromWindow || !api.release || !api.txCreate || !api.txDelete || !api.txApply ||
!api.setBuffer || !api.setZOrder || !api.setVisibility || !api.setGeometry ||
!api.setBufferTransparency || !api.reparent || !api.setOnComplete || !api.prevReleaseFence) {
- banner_log("layer", "unavailable: libandroid.so lacks part of the ASurfaceControl API (Android 10+)");
+ droiddeck_log("layer", "unavailable: libandroid.so lacks part of the ASurfaceControl API (Android 10+)");
return -1;
}
api.state = 1;
@@ -214,10 +214,10 @@ static AHardwareBuffer *g_blank;
static void layers_init(void) {
if (g_layers_ready) return;
g_layers_ready = 1;
- g_layers[SC_LAYER_GAME] = (struct layer){.name = "banner_wayland_game", .z = 1, .pool_n = POOL_MAX,
+ g_layers[SC_LAYER_GAME] = (struct layer){.name = "droiddeck_wayland_game", .z = 1, .pool_n = POOL_MAX,
.cur_slot = -1, .votes_rate = 1, .fps_applied = -1.0f, .hr_applied = -1.0f,
.ds_applied = -1};
- g_layers[SC_LAYER_OVERLAY] = (struct layer){.name = "banner_wayland_overlay", .z = 2, .pool_n = 3,
+ g_layers[SC_LAYER_OVERLAY] = (struct layer){.name = "droiddeck_wayland_overlay", .z = 2, .pool_n = 3,
.cur_slot = -1, .votes_rate = 0, .fps_applied = -1.0f,
.hr_applied = -1.0f, .ds_applied = -1};
for (int i = 0; i < SC_LAYER_COUNT; i++)
@@ -330,7 +330,7 @@ static void retire_sc(struct layer *l) {
if (l->cur_token) ahb_swapchain_layer_released(l->cur_token, -1);
api.release(l->sc);
}
- banner_log("layer", "%s: SurfaceControl retired (window %p)", l->name, (void *)l->win);
+ droiddeck_log("layer", "%s: SurfaceControl retired (window %p)", l->name, (void *)l->win);
l->sc = NULL; l->win = NULL;
l->shown = 0; l->cur_slot = -1; l->cur_token = NULL; l->geo_valid = 0;
l->fps_applied = -1.0f; /* the next SurfaceControl carries no vote until it is re-applied */
@@ -368,7 +368,7 @@ static void drain_and_free_pools(void) {
/* Native-handle sniff, the same one Mesa's u_gralloc fallback uses (u_gralloc_fallback.c): a QTI
* gralloc private_handle_t carries the magic 'gmsm' as its first int and the UBWC flag
* (PRIV_FLAGS_UBWC_ALIGNED, 0x08000000) in the next one. Returns 0 when the layout is unknown. */
-static int sniff_modifier(const struct banner_native_handle *h, uint64_t *mod) {
+static int sniff_modifier(const struct droiddeck_native_handle *h, uint64_t *mod) {
const uint32_t gmsm = ('g' << 24) | ('m' << 16) | ('s' << 8) | 'm';
if (!h || h->numFds < 1 || h->numInts < 2) return 0;
if ((uint32_t)h->data[h->numFds] != gmsm) return 0;
@@ -387,7 +387,7 @@ static int g_alloc_failed; /* set by alloc_slot when gralloc or the import refus
* TIER_PLAIN the same without the vendor bit (a gralloc that refuses unknown bits; what we asked before).
* TIER_LINEAR plus a CPU bit, so the layout is known to be linear even when the handle is unreadable. */
enum { TIER_UBWC, TIER_PLAIN, TIER_LINEAR };
-#define BANNER_AHB_USAGE_VENDOR_UBWC (1ULL << 28) /* AHARDWAREBUFFER_USAGE_VENDOR_0 */
+#define DROIDDECK_AHB_USAGE_VENDOR_UBWC (1ULL << 28) /* AHARDWAREBUFFER_USAGE_VENDOR_0 */
static const char *tier_name(int tier) {
return tier == TIER_UBWC ? "asked for UBWC" : tier == TIER_PLAIN ? "no UBWC request" : "linear by request (CPU bit)";
@@ -404,22 +404,22 @@ static int alloc_slot(struct layer *l, struct slot *s, int w, int h, uint32_t fm
* composer overlay (the display scans it out). See the tiers above for the rest. */
.usage = AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT | AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE |
AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY |
- (tier == TIER_UBWC ? BANNER_AHB_USAGE_VENDOR_UBWC : 0) |
+ (tier == TIER_UBWC ? DROIDDECK_AHB_USAGE_VENDOR_UBWC : 0) |
(tier == TIER_LINEAR ? AHARDWAREBUFFER_USAGE_CPU_READ_RARELY : 0)};
AHardwareBuffer *ahb = NULL;
if (AHardwareBuffer_allocate(&d, &ahb) != 0 || !ahb) {
if (tier < TIER_LINEAR) {
- banner_log("layer", "%s: gralloc refused a %dx%d pool buffer (%s): trying %s", l->name, w, h,
+ droiddeck_log("layer", "%s: gralloc refused a %dx%d pool buffer (%s): trying %s", l->name, w, h,
tier_name(tier), tier_name(tier + 1));
l->alloc_tier = tier + 1;
continue;
}
- banner_log("error", "layer: %s: AHardwareBuffer_allocate %dx%d (format %#x) failed", l->name, w, h, fmt);
+ droiddeck_log("error", "layer: %s: AHardwareBuffer_allocate %dx%d (format %#x) failed", l->name, w, h, fmt);
g_alloc_failed = 1;
return -1;
}
AHardwareBuffer_Desc got; AHardwareBuffer_describe(ahb, &got);
- const struct banner_native_handle *nh = api.getNativeHandle(ahb);
+ const struct droiddeck_native_handle *nh = api.getNativeHandle(ahb);
uint64_t mod = MOD_LINEAR;
if (!sniff_modifier(nh, &mod)) {
/* Not a handle we can read: the only layout we can assume is linear, and only if the buffer
@@ -427,7 +427,7 @@ static int alloc_slot(struct layer *l, struct slot *s, int w, int h, uint32_t fm
if (tier < TIER_LINEAR) {
AHardwareBuffer_release(ahb);
l->alloc_tier = TIER_LINEAR;
- banner_log("layer", "%s: gralloc handle layout unknown (%d fds, %d ints): using linear pool buffers",
+ droiddeck_log("layer", "%s: gralloc handle layout unknown (%d fds, %d ints): using linear pool buffers",
l->name, nh ? nh->numFds : -1, nh ? nh->numInts : -1);
continue;
}
@@ -439,7 +439,7 @@ static int alloc_slot(struct layer *l, struct slot *s, int w, int h, uint32_t fm
struct vkp_image *img = fd >= 0 ? vkp_image_import_dmabuf(fd, fmt == AHB_RGB10A2 ? DRM_ABGR2101010 : DRM_ABGR8888,
mod, w, h, got.stride * 4, 0, 1) : NULL;
if (!img) {
- banner_log("layer", "%s: import of a %s %dx%d pool buffer (stride %u px) into the compositor's Turnip failed",
+ droiddeck_log("layer", "%s: import of a %s %dx%d pool buffer (stride %u px) into the compositor's Turnip failed",
l->name, mod == MOD_QCOM_COMPRESSED ? "UBWC" : "linear", w, h, got.stride);
AHardwareBuffer_release(ahb);
if (tier < TIER_LINEAR) { l->alloc_tier = tier + 1; continue; }
@@ -451,7 +451,7 @@ static int alloc_slot(struct layer *l, struct slot *s, int w, int h, uint32_t fm
if (l->logged_w != w || l->logged_h != h || l->logged_fmt != fmt || l->logged_mod != mod ||
l->logged_tier != tier) {
l->logged_w = w; l->logged_h = h; l->logged_fmt = fmt; l->logged_mod = mod; l->logged_tier = tier;
- banner_log("layer", "%s: pool buffers %dx%d%s: %s (%s), stride %u px, up to %d buffers (gralloc handle %d fds / %d ints)",
+ droiddeck_log("layer", "%s: pool buffers %dx%d%s: %s (%s), stride %u px, up to %d buffers (gralloc handle %d fds / %d ints)",
l->name, w, h, fmt == AHB_RGB10A2 ? " 10-bit RGBA1010102" : "",
mod == MOD_QCOM_COMPRESSED ? "UBWC (QCOM_COMPRESSED)" : "linear", tier_name(tier),
got.stride, l->pool_n, nh ? nh->numFds : -1, nh ? nh->numInts : -1);
@@ -532,10 +532,10 @@ void sc_layer_probe_dmabuf_fd(int fd) {
struct { uint32_t flags; int32_t fd; } exp = {.flags = 1u /* DMA_BUF_SYNC_READ */, .fd = -1};
/* DMA_BUF_IOCTL_EXPORT_SYNC_FILE = _IOWR('b', 2, struct dma_buf_export_sync_file) */
if (ioctl(fd, _IOWR('b', 2, exp), &exp) == 0) {
- banner_log("layer", "kernel exports sync_file fences from the game's dma-buf: zero-copy acquire fences can come from the buffer itself");
+ droiddeck_log("layer", "kernel exports sync_file fences from the game's dma-buf: zero-copy acquire fences can come from the buffer itself");
if (exp.fd >= 0) close(exp.fd);
} else {
- banner_log("layer", "DMA_BUF_IOCTL_EXPORT_SYNC_FILE on the game's dma-buf failed (%s): acquire fences must be exported by the game's driver (sync_fd) instead",
+ droiddeck_log("layer", "DMA_BUF_IOCTL_EXPORT_SYNC_FILE on the game's dma-buf failed (%s): acquire fences must be exported by the game's driver (sync_fd) instead",
strerror(errno));
}
}
@@ -549,7 +549,7 @@ static int ensure_sc(struct layer *l) {
if (l->sc && l->win != win) retire_sc(l);
if (!l->sc) {
l->sc = api.createFromWindow(win, l->name);
- if (!l->sc) { banner_log("error", "layer: ASurfaceControl_createFromWindow(%s) failed", l->name); return -1; }
+ if (!l->sc) { droiddeck_log("error", "layer: ASurfaceControl_createFromWindow(%s) failed", l->name); return -1; }
l->win = win;
l->ds_applied = -1; l->md_applied = 0; l->hr_applied = -1.0f;
ASurfaceTransaction *tx = api.txCreate();
@@ -559,7 +559,7 @@ static int ensure_sc(struct layer *l) {
apply_frame_rate(tx, l);
api.txApply(tx); api.txDelete(tx);
}
- banner_log("layer", "SurfaceControl \"%s\" created as a child of the screen surface (z=%d)", l->name, (int)l->z);
+ droiddeck_log("layer", "SurfaceControl \"%s\" created as a child of the screen surface (z=%d)", l->name, (int)l->z);
}
return 0;
}
@@ -585,7 +585,7 @@ static void apply_geometry(ASurfaceTransaction *tx, struct layer *l, const int r
l->geo_src = srcR; l->geo_dst = dstR; l->geo_valid = 1;
char cov[96] = "";
if (l->ds_applied > 0) coverage_text(l, cov, sizeof(cov));
- banner_log("layer", "%s geometry: buffer %d,%d-%d,%d -> screen %d,%d-%d,%d%s%s%s", l->name,
+ droiddeck_log("layer", "%s geometry: buffer %d,%d-%d,%d -> screen %d,%d-%d,%d%s%s%s", l->name,
r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7], cov[0] ? " (HDR layer " : "", cov, cov[0] ? ")" : "");
}
}
@@ -606,11 +606,11 @@ static void apply_frame_rate(ASurfaceTransaction *tx, struct layer *l) {
}
int first = l->fps_applied < 0.0f;
l->fps_applied = want;
- if (want > 0.0f) banner_log("layer", "display frame-rate vote on %s: %.2f Hz", l->name, want);
- else if (!first) banner_log("layer", "display frame-rate vote on %s cleared (panel runs free)", l->name);
+ if (want > 0.0f) droiddeck_log("layer", "display frame-rate vote on %s: %.2f Hz", l->name, want);
+ else if (!first) droiddeck_log("layer", "display frame-rate vote on %s cleared (panel runs free)", l->name);
}
-/* ---- colour (HDR, banner_color.h) -------------------------------------------------------------
+/* ---- colour (HDR, droiddeck_color.h) -------------------------------------------------------------
* The layer is told what its buffer's pixels MEAN - the dataspace (BT2020_PQ for an HDR10 frame) and
* the game's mastering / content-light metadata - in the same transaction as the buffer, so the
* display never shows an HDR frame decoded as sRGB or the other way round. A layer that has never been
@@ -630,67 +630,67 @@ static void coverage_text(const struct layer *l, char *out, size_t n) {
/* API 35: ask the display for HDR headroom explicitly while the layer carries an HDR frame, and clear the
* request (0 = no preference) when it stops. Only on change; a layer never tagged is never touched. */
-static void apply_headroom(ASurfaceTransaction *tx, struct layer *l, const struct banner_color *c) {
+static void apply_headroom(ASurfaceTransaction *tx, struct layer *l, const struct droiddeck_color *c) {
static int said_missing;
if (!api.setDesiredHdrHeadroom) {
if (c && c->dataspace && !said_missing) {
said_missing = 1;
- banner_color_note_headroom_request(-1.0f);
- banner_log("color", "HDR headroom request not available on %s (Android < 15 has no "
+ droiddeck_color_note_headroom_request(-1.0f);
+ droiddeck_log("color", "HDR headroom request not available on %s (Android < 15 has no "
"ASurfaceTransaction_setDesiredHdrHeadroom): the layer relies on Android's default", l->name);
}
return;
}
- const float want = (c && c->dataspace) ? banner_color_desired_headroom(c, NULL, 0) : 0.0f;
+ const float want = (c && c->dataspace) ? droiddeck_color_desired_headroom(c, NULL, 0) : 0.0f;
if (l->hr_applied < 0.0f && want == 0.0f && !(c && c->dataspace)) return; /* never asked: leave it be */
if (l->hr_applied >= 0.0f && fabsf(want - l->hr_applied) < 0.005f) return;
char why[200] = "";
- if (c && c->dataspace) banner_color_desired_headroom(c, why, sizeof(why));
+ if (c && c->dataspace) droiddeck_color_desired_headroom(c, why, sizeof(why));
api.setDesiredHdrHeadroom(tx, l->sc, want);
const int first = l->hr_applied < 0.0f;
l->hr_applied = want;
- banner_color_note_headroom_request(want);
+ droiddeck_color_note_headroom_request(want);
if (want > 0.0f)
- banner_log("color", "requested HDR headroom %.1fx on %s (%s)", want, l->name, why);
+ droiddeck_log("color", "requested HDR headroom %.1fx on %s (%s)", want, l->name, why);
else if (c && c->dataspace)
- banner_log("color", "no HDR headroom requested on %s: %s", l->name, why);
+ droiddeck_log("color", "no HDR headroom requested on %s: %s", l->name, why);
else if (!first)
- banner_log("color", "HDR headroom request on %s cleared (no preference): the frame on the layer is not HDR", l->name);
+ droiddeck_log("color", "HDR headroom request on %s cleared (no preference): the frame on the layer is not HDR", l->name);
}
-static void apply_colour(ASurfaceTransaction *tx, struct layer *l, const struct banner_color *c) {
- int32_t want = c ? c->dataspace : BANNER_ADATASPACE_UNKNOWN;
+static void apply_colour(ASurfaceTransaction *tx, struct layer *l, const struct droiddeck_color *c) {
+ int32_t want = c ? c->dataspace : DROIDDECK_ADATASPACE_UNKNOWN;
uint32_t md = (c && c->dataspace) ? c->identity : 0;
if (!api.setBufferDataSpace) return;
- if (l->ds_applied < 0 && want == BANNER_ADATASPACE_UNKNOWN) return; /* never tagged: leave it be */
+ if (l->ds_applied < 0 && want == DROIDDECK_ADATASPACE_UNKNOWN) return; /* never tagged: leave it be */
apply_headroom(tx, l, want ? c : NULL);
if (want == l->ds_applied && md == l->md_applied) return;
api.setBufferDataSpace(tx, l->sc, want);
- struct banner_hdr_smpte2086 st;
- struct banner_hdr_cta861_3 cta;
+ struct droiddeck_hdr_smpte2086 st;
+ struct droiddeck_hdr_cta861_3 cta;
int st_on = c && c->dataspace && c->has_st2086, cta_on = c && c->dataspace && c->has_cta861;
if (st_on) {
- st = (struct banner_hdr_smpte2086){
+ st = (struct droiddeck_hdr_smpte2086){
.displayPrimaryRed = {c->red[0], c->red[1]}, .displayPrimaryGreen = {c->green[0], c->green[1]},
.displayPrimaryBlue = {c->blue[0], c->blue[1]}, .whitePoint = {c->white[0], c->white[1]},
.maxLuminance = c->max_lum, .minLuminance = c->min_lum};
}
- if (cta_on) cta = (struct banner_hdr_cta861_3){.maxContentLightLevel = c->max_cll, .maxFrameAverageLightLevel = c->max_fall};
+ if (cta_on) cta = (struct droiddeck_hdr_cta861_3){.maxContentLightLevel = c->max_cll, .maxFrameAverageLightLevel = c->max_fall};
/* NULL clears what a previous description set: metadata never outlives the frame it belongs to. */
if (api.setHdrMetadata_smpte2086) api.setHdrMetadata_smpte2086(tx, l->sc, st_on ? &st : NULL);
if (api.setHdrMetadata_cta861_3) api.setHdrMetadata_cta861_3(tx, l->sc, cta_on ? &cta : NULL);
if (want) {
char cov[96];
coverage_text(l, cov, sizeof(cov));
- banner_log("color", "%s: dataspace %s (%#x) set on the display layer for image description #%u%s%s; SMPTE 2086 "
- "%s, CTA-861.3 %s [%s]", l->name, want == BANNER_ADATASPACE_BT2020_PQ ? "BT2020_PQ" : "HDR",
+ droiddeck_log("color", "%s: dataspace %s (%#x) set on the display layer for image description #%u%s%s; SMPTE 2086 "
+ "%s, CTA-861.3 %s [%s]", l->name, want == DROIDDECK_ADATASPACE_BT2020_PQ ? "BT2020_PQ" : "HDR",
(unsigned)want, c->identity, cov[0] ? ", " : "", cov,
st_on ? (api.setHdrMetadata_smpte2086 ? "sent" : "not supported by this Android") : "none given",
cta_on ? (api.setHdrMetadata_cta861_3 ? "sent" : "not supported by this Android") : "none given",
c->text);
}
else
- banner_log("color", "%s: dataspace back to UNKNOWN (sRGB), HDR metadata cleared - the frame on the layer is "
+ droiddeck_log("color", "%s: dataspace back to UNKNOWN (sRGB), HDR metadata cleared - the frame on the layer is "
"not an HDR frame", l->name);
l->ds_applied = want;
l->md_applied = md;
@@ -711,7 +711,7 @@ void sc_layer_hdr_symbols(char *out, size_t size) {
static void log_layer_count(void) {
if (g_two_logged) return;
g_two_logged = 1;
- banner_log("layer", "%d display layers in use: \"%s\" (z=%d) and \"%s\" (z=%d) above it, both children of the "
+ droiddeck_log("layer", "%d display layers in use: \"%s\" (z=%d) and \"%s\" (z=%d) above it, both children of the "
"screen surface; the app's own views (drawer, HUD, pointer) stay above both. %d is the cap - more "
"would push SurfaceFlinger into GPU client composition",
SC_LAYER_COUNT, g_layers[SC_LAYER_GAME].name, (int)g_layers[SC_LAYER_GAME].z,
@@ -748,7 +748,7 @@ static ASurfaceControl *swap_sc_begin(struct layer *l) {
if (!win || win != l->win) return NULL; /* the window changed: ensure_sc re-creates it anyway */
ASurfaceControl *fresh = api.createFromWindow(win, l->name);
if (!fresh) {
- banner_log("error", "layer: %s: composition recovery could not create a new SurfaceControl", l->name);
+ droiddeck_log("error", "layer: %s: composition recovery could not create a new SurfaceControl", l->name);
return NULL;
}
ASurfaceControl *old = l->sc;
@@ -760,14 +760,14 @@ static ASurfaceControl *swap_sc_begin(struct layer *l) {
l->geo_valid = 0;
l->fps_applied = -1.0f;
l->ds_applied = -1; l->md_applied = 0; l->hr_applied = -1.0f;
- banner_log("layer", "composition recovery: %s got a fresh SurfaceControl now that nothing is above "
+ droiddeck_log("layer", "composition recovery: %s got a fresh SurfaceControl now that nothing is above "
"the game (measured on this panel: hardware composition does NOT return from this alone)", l->name);
return old;
}
/* The transaction that puts pool slot `idx` of layer `l` on screen at `r`, as `color` (NULL = no
* description). 0 = applied. */
-static int present_slot(struct layer *l, int idx, const int r[8], const struct banner_color *color,
+static int present_slot(struct layer *l, int idx, const int r[8], const struct droiddeck_color *color,
int translucent) {
struct slot *s = &l->slots[idx];
ASurfaceTransaction *tx = api.txCreate();
@@ -792,7 +792,7 @@ static int present_slot(struct layer *l, int idx, const int r[8], const struct b
api.txDelete(tx);
l->cur_slot = idx;
l->cur_token = NULL;
- if (!l->shown) { l->shown = 1; banner_log("layer", "%s: layer shown", l->name); }
+ if (!l->shown) { l->shown = 1; droiddeck_log("layer", "%s: layer shown", l->name); }
g_stat_layer_frames++;
return 0;
}
@@ -805,7 +805,7 @@ static void log_drop(struct layer *l) {
l->drops_unlogged++;
int64_t t = now_ns();
if (!l->drop_logged_ns || t - l->drop_logged_ns > 30000000000LL) {
- banner_log("layer", "%s: no free layer buffer (display still holds all %d): %u frame%s dropped%s", l->name,
+ droiddeck_log("layer", "%s: no free layer buffer (display still holds all %d): %u frame%s dropped%s", l->name,
l->pool_n, l->drops_unlogged, l->drops_unlogged == 1 ? "" : "s",
l->drop_logged_ns ? " since the last such line" : "");
l->drop_logged_ns = t;
@@ -820,7 +820,7 @@ unsigned sc_layer_drops_take(void) {
}
int sc_layer_present_ahb(AHardwareBuffer *ahb, int w, int h, int acquire_fd, void *token, int scene_w, int scene_h,
- const struct banner_color *color, uint32_t ahb_format) {
+ const struct droiddeck_color *color, uint32_t ahb_format) {
struct layer *l = layer_of(SC_LAYER_GAME);
int r[8];
if (!ahb || !token || ensure_sc(l) != 0) goto unavailable;
@@ -863,19 +863,19 @@ int sc_layer_present_ahb(AHardwareBuffer *ahb, int w, int h, int acquire_fd, voi
api.txDelete(tx);
l->cur_slot = -1;
l->cur_token = token;
- if (!l->shown) { l->shown = 1; banner_log("layer", "%s: layer shown", l->name); }
+ if (!l->shown) { l->shown = 1; droiddeck_log("layer", "%s: layer shown", l->name); }
/* The notification is re-armed for each session; the layer and its logging flag can
* outlive it. Let the notification's own one-shot decide whether to fire. */
if (!l->first_logged) l->first_logged = 1;
vkp_signal_first_frame();
- if (color && color->dataspace) banner_color_frame_shown(color, BANNER_HDR_ZERO_COPY, ahb_format);
+ if (color && color->dataspace) droiddeck_color_frame_shown(color, DROIDDECK_HDR_ZERO_COPY, ahb_format);
return 0;
unavailable:
if (acquire_fd >= 0) close(acquire_fd);
return -1;
}
-int sc_layer_present(struct vkp_image *src, int scene_w, int scene_h, const struct banner_color *color) {
+int sc_layer_present(struct vkp_image *src, int scene_w, int scene_h, const struct droiddeck_color *color) {
struct layer *l = layer_of(SC_LAYER_GAME);
if (!src || ensure_sc(l) != 0) return -1;
int sw = vkp_image_width(src), sh = vkp_image_height(src);
@@ -889,10 +889,10 @@ int sc_layer_present(struct vkp_image *src, int scene_w, int scene_h, const stru
if (idx < 0) { log_drop(l); return 0; }
if (vkp_blit_image(src, l->slots[idx].img, wait_fd) != 0) return -1;
if (present_slot(l, idx, r, color, 0) != 0) return -1;
- if (color && color->dataspace) banner_color_frame_shown(color, BANNER_HDR_LAYER_COPY, AHB_RGBA8);
+ if (color && color->dataspace) droiddeck_color_frame_shown(color, DROIDDECK_HDR_LAYER_COPY, AHB_RGBA8);
if (!l->first_logged) {
l->first_logged = 1;
- banner_log("layer", "presenting %dx%d game frames on their own SurfaceControl layer (%s pool, %d buffers); "
+ droiddeck_log("layer", "presenting %dx%d game frames on their own SurfaceControl layer (%s pool, %d buffers); "
"HUD and pointer stay Android views above it", sw, sh,
l->pool_modifier == MOD_QCOM_COMPRESSED ? "UBWC" : "linear", l->pool_n);
}
@@ -916,7 +916,7 @@ int sc_layer_present_pass(const struct vkp_draw *draws, int n, int scene_w, int
if (present_slot(l, idx, r, NULL, 0) != 0) return -1; /* the effects chain's result is 8-bit sRGB */
if (!l->first_logged) {
l->first_logged = 1;
- banner_log("layer", "presenting %dx%d frames on their own SurfaceControl layer (%s pool, %d buffers); "
+ droiddeck_log("layer", "presenting %dx%d frames on their own SurfaceControl layer (%s pool, %d buffers); "
"HUD and pointer stay Android views above it", rw, rh,
l->pool_modifier == MOD_QCOM_COMPRESSED ? "UBWC" : "linear", l->pool_n);
}
@@ -935,7 +935,7 @@ int sc_layer_present_pass(const struct vkp_draw *draws, int n, int scene_w, int
static uint32_t g_hdr_pool_fmt = AHB_RGB10A2;
int sc_layer_present_hdr_scene(const struct vkp_draw *draws, int n, const struct vkp_hdr_frame *hf,
- int scene_w, int scene_h, const struct banner_color *color) {
+ int scene_w, int scene_h, const struct droiddeck_color *color) {
struct layer *l = layer_of(SC_LAYER_GAME);
int rw = 0, rh = 0, r[8];
if (!draws || n <= 0 || !hf || ensure_sc(l) != 0) return -1;
@@ -949,7 +949,7 @@ int sc_layer_present_hdr_scene(const struct vkp_draw *draws, int n, const struct
int idx = take_free_slot(l, rw, rh, fmt, &wait_fd);
if (idx < 0 && g_alloc_failed && fmt == AHB_RGB10A2) {
g_hdr_pool_fmt = AHB_RGBA8;
- banner_log("color", "%s: this device will not make a 10-bit layer buffer (RGBA1010102): the HDR picture goes "
+ droiddeck_log("color", "%s: this device will not make a 10-bit layer buffer (RGBA1010102): the HDR picture goes "
"on 8-bit buffers instead (still tagged BT2020_PQ; less precision)", l->name);
idx = take_free_slot(l, rw, rh, g_hdr_pool_fmt, &wait_fd);
}
@@ -957,21 +957,21 @@ int sc_layer_present_hdr_scene(const struct vkp_draw *draws, int n, const struct
if (vkp_pass_copy_to(l->slots[idx].img, wait_fd) != 0) return -1;
if (present_slot(l, idx, r, tm ? NULL : color, 0) != 0) return -1; /* tone-mapped = plain sRGB: no tag */
if (color && color->dataspace)
- banner_color_frame_shown(color, tm ? BANNER_HDR_TONEMAPPED : BANNER_HDR_COMPOSED, tm ? AHB_RGBA8 : g_hdr_pool_fmt);
+ droiddeck_color_frame_shown(color, tm ? DROIDDECK_HDR_TONEMAPPED : DROIDDECK_HDR_COMPOSED, tm ? AHB_RGBA8 : g_hdr_pool_fmt);
static int said = -1;
if (said != tm) {
said = tm;
if (tm)
- banner_log("color", "tone-mapped picture on the game's display layer: %dx%d, %s 8-bit buffers, untagged "
+ droiddeck_log("color", "tone-mapped picture on the game's display layer: %dx%d, %s 8-bit buffers, untagged "
"(sRGB) - HDR output is switched off", rw, rh,
l->pool_modifier == MOD_QCOM_COMPRESSED ? "UBWC" : "linear");
else {
char cov[96];
coverage_text(l, cov, sizeof(cov));
- banner_log("color", "HDR picture on its own display layer: %dx%d, %s %s buffers, tagged %s%s%s", rw, rh,
+ droiddeck_log("color", "HDR picture on its own display layer: %dx%d, %s %s buffers, tagged %s%s%s", rw, rh,
l->pool_modifier == MOD_QCOM_COMPRESSED ? "UBWC" : "linear",
g_hdr_pool_fmt == AHB_RGB10A2 ? "10-bit" : "8-bit",
- color && color->dataspace == BANNER_ADATASPACE_BT2020_PQ ? "BT2020_PQ" : "HDR",
+ color && color->dataspace == DROIDDECK_ADATASPACE_BT2020_PQ ? "BT2020_PQ" : "HDR",
cov[0] ? ", " : "", cov);
}
}
@@ -1025,13 +1025,13 @@ int sc_layer_overlay_affordable(void) {
int first = g_overlay_declined < 0;
g_overlay_declined = want;
if (want)
- banner_log("layer", "overlay layer declined: this display rotates every layer %d° and the game "
+ droiddeck_log("layer", "overlay layer declined: this display rotates every layer %d° and the game "
"layer is scaled %dx%d -> %dx%d, and on that combination a second layer drops the "
"whole frame to GPU composition for the rest of the session (measured). The window "
"above the game goes on the copy path instead - same picture, one blit.",
deg, sr[0], sr[1], ds[0], ds[1]);
else if (!first)
- banner_log("layer", "overlay layer allowed again: the game layer is no longer both rotated and "
+ droiddeck_log("layer", "overlay layer allowed again: the game layer is no longer both rotated and "
"scaled, so a second display layer costs nothing here");
}
return ok;
@@ -1082,7 +1082,7 @@ void sc_layer_hide(void) {
* SurfaceControl, since it goes up and down with every effects/frame-generation toggle. */
if (g_layers[SC_LAYER_OVERLAY].sc) sc_layer_hide_overlay();
if (g_layers[SC_LAYER_GAME].shown) hide_layer(&g_layers[SC_LAYER_GAME]);
- if (said) banner_log("layer", "layers hidden (scene is not a single fullscreen window)");
+ if (said) droiddeck_log("layer", "layers hidden (scene is not a single fullscreen window)");
}
void sc_layer_hide_overlay(void) {
@@ -1098,7 +1098,7 @@ void sc_layer_hide_overlay(void) {
* buffers stay allocated for the next window. */
if (l->shown) hide_layer(l);
retire_sc(l);
- banner_log("layer", "%s: gone (nothing is above the game any more)", l->name);
+ droiddeck_log("layer", "%s: gone (nothing is above the game any more)", l->name);
/* ...and that is the half the measurement said is not enough: arm the game layer's
* SurfaceControl swap, which the next frame performs (swap_sc_begin). */
if (g_layers[SC_LAYER_GAME].sc) g_layers[SC_LAYER_GAME].recreate_pending = 1;
diff --git a/app/src/main/cpp/waylandcomp/src/sc_layer.h b/app/src/main/cpp/waylandcomp/src/sc_layer.h
index f2f12a704f..1d8e6a11e5 100644
--- a/app/src/main/cpp/waylandcomp/src/sc_layer.h
+++ b/app/src/main/cpp/waylandcomp/src/sc_layer.h
@@ -1,7 +1,7 @@
#ifndef SC_LAYER_H
#define SC_LAYER_H
/*
- * Layer mode (BANNER_WAYLAND_ZERO_COPY=1): the scene is handed to SurfaceFlinger as a small,
+ * Layer mode (DROIDDECK_WAYLAND_ZERO_COPY=1): the scene is handed to SurfaceFlinger as a small,
* deliberately ordered SET of Android display layers - ASurfaceControl children of the
* compositor's SurfaceView - instead of being blitted into the compositor's own swapchain.
*
@@ -12,8 +12,8 @@
* an ASurfaceControl has no input channel, so touch and mouse keep
* reaching the SurfaceView exactly as they did.
* +-- SurfaceView ..... the compositor's Vulkan swapchain; black while layer mode is up
- * +-- z=1 "banner_wayland_game" ...... the one fullscreen game window
- * +-- z=2 "banner_wayland_overlay" ... at most one window drawn ABOVE the game
+ * +-- z=1 "droiddeck_wayland_game" ...... the one fullscreen game window
+ * +-- z=2 "droiddeck_wayland_overlay" ... at most one window drawn ABOVE the game
*
* TWO layers is the hard cap (SC_LAYER_COUNT), and deliberately so: HWC composes only a few
* layers before SurfaceFlinger falls back to GPU client composition, which would throw away the
@@ -71,7 +71,7 @@
struct vkp_image;
struct vkp_draw;
-struct banner_color;
+struct droiddeck_color;
/* The layers, bottom first. The z-order is the array order (z = id + 1). */
enum sc_layer_id { SC_LAYER_GAME = 0, SC_LAYER_OVERLAY = 1, SC_LAYER_COUNT = 2 };
@@ -84,7 +84,7 @@ int sc_layer_available(void);
* Decides where a zero-copy acquire fence can come from; result goes to the session log. */
void sc_layer_probe_dmabuf_fd(int fd);
-/* HDR (banner_color.h): can a display layer be told its buffer's colour encoding here
+/* HDR (droiddeck_color.h): can a display layer be told its buffer's colour encoding here
* (ASurfaceTransaction_setBufferDataSpace, Android 10+)? Part of the HDR gate. */
int sc_layer_can_tag_hdr(void);
/* Which of the colour calls this libandroid has, for the gate's log line. */
@@ -100,7 +100,7 @@ void sc_layer_hdr_symbols(char *out, size_t size);
* free buffer), -1 = the layer path is unavailable this frame and the caller must draw the old way.
* The copy into the layer buffer is 8-bit: an HDR frame keeps its tag (its colours stay right), and
* loses precision. */
-int sc_layer_present(struct vkp_image *src, int scene_w, int scene_h, const struct banner_color *color);
+int sc_layer_present(struct vkp_image *src, int scene_w, int scene_h, const struct droiddeck_color *color);
/* GAME layer, screen effects on: run the compositor pass (composite `draws` + the effects chain,
* vkp_pass_begin) and put its result on the layer. Same return values as sc_layer_present. */
@@ -113,7 +113,7 @@ int sc_layer_present_pass(const struct vkp_draw *draws, int n, int scene_w, int
* Same return values as sc_layer_present. */
struct vkp_hdr_frame;
int sc_layer_present_hdr_scene(const struct vkp_draw *draws, int n, const struct vkp_hdr_frame *hf,
- int scene_w, int scene_h, const struct banner_color *color);
+ int scene_w, int scene_h, const struct droiddeck_color *color);
/* GAME layer, zero-copy (ahb_swapchain.c): show the game's own w x h AHardwareBuffer, gated by
* acquire_fd (a sync_file the layer waits on before reading; owned by the callee, -1 = none).
@@ -124,7 +124,7 @@ int sc_layer_present_hdr_scene(const struct vkp_draw *draws, int n, const struct
* frame (the caller draws the old way). `color` / `ahb_format`: the frame's image description (NULL =
* none) and the buffer's AHARDWAREBUFFER_FORMAT_*, for the dataspace and the HDR evidence. */
int sc_layer_present_ahb(AHardwareBuffer *ahb, int w, int h, int acquire_fd, void *token,
- int scene_w, int scene_h, const struct banner_color *color, uint32_t ahb_format);
+ int scene_w, int scene_h, const struct droiddeck_color *color, uint32_t ahb_format);
/* Vote a panel refresh rate for the layer the game presents on (VRR / refresh-rate matching), the
* same rate and compatibility the app votes on its own surface with Surface.setFrameRate; 0 = no
diff --git a/app/src/main/cpp/waylandcomp/src/vk_loader.c b/app/src/main/cpp/waylandcomp/src/vk_loader.c
index 3038d79ae2..ef939911ce 100644
--- a/app/src/main/cpp/waylandcomp/src/vk_loader.c
+++ b/app/src/main/cpp/waylandcomp/src/vk_loader.c
@@ -8,7 +8,7 @@
#include
#include
-#define TAG "BannerWayland"
+#define TAG "DroidDeckWayland"
struct vk_api g_vk;
static void *g_handle;
diff --git a/app/src/main/cpp/waylandcomp/src/vk_present.c b/app/src/main/cpp/waylandcomp/src/vk_present.c
index 7a2ecfd48b..3af9a8c254 100644
--- a/app/src/main/cpp/waylandcomp/src/vk_present.c
+++ b/app/src/main/cpp/waylandcomp/src/vk_present.c
@@ -8,7 +8,7 @@
#include "framegen_bridge.h"
#include "hdr_compose.h"
#include "blend_pass.h"
-#include "banner_color.h"
+#include "droiddeck_color.h"
#include
#include
#include
@@ -19,9 +19,9 @@
#include
#include
-#define TAG "BannerWayland"
+#define TAG "DroidDeckWayland"
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__)
-#define LOGE(...) banner_log("error", __VA_ARGS__)
+#define LOGE(...) droiddeck_log("error", __VA_ARGS__)
#define MOD_INVALID VKP_MOD_INVALID
struct vkp_image {
@@ -73,7 +73,7 @@ static VkImage *g_images;
static uint32_t g_nimg;
static VkExtent2D g_extent;
-static int g_first_frame_done; /* one-shot: fire banner_on_first_frame() on first present */
+static int g_first_frame_done; /* one-shot: fire droiddeck_on_first_frame() on first present */
/* The base surface under the display layers (vkp_base_black): 1 once a plain black frame has been
* presented on the CURRENT swapchain and nothing else since. Every other present clears it, and so does
@@ -179,7 +179,7 @@ static int64_t g_swap_retry_at_ns;
static int g_swap_fail_logged;
/* Implemented in waylandcomp_jni.c - notifies Java (dismiss launch overlay). */
-extern void banner_on_first_frame(void);
+extern void droiddeck_on_first_frame(void);
static char g_gpu_name[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
const char *vkp_gpu_name(void) { return g_gpu_name; }
@@ -276,7 +276,7 @@ int vkp_apply_window_request(void) {
g_window = w;
g_swap_retry_at_ns = 0;
g_swap_fail_logged = 0;
- banner_log("gpu", w ? "screen surface attached" : "screen surface gone: presenting paused");
+ droiddeck_log("gpu", w ? "screen surface attached" : "screen surface gone: presenting paused");
return 1;
}
@@ -353,7 +353,7 @@ static void update_map(int scene_w, int scene_h) {
g_map.off_y = (float)(g_map.ry + (int)((g_map.rh - scene_h * aspect) * 0.5f));
}
g_map.valid = 1;
- banner_log("screen", "%s, %s: %dx%d scene shown %dx%d at %d,%d on the %dx%d output",
+ droiddeck_log("screen", "%s, %s: %dx%d scene shown %dx%d at %d,%d on the %dx%d output",
mode_name(mode), align_name(align), scene_w, scene_h,
(int)(scene_w * g_map.kx + 0.5f), (int)(scene_h * g_map.ky + 0.5f),
(int)g_map.off_x, (int)g_map.off_y, W, H);
@@ -391,10 +391,10 @@ static int dev_init(void) {
const char *inst_exts[3] = {VK_KHR_SURFACE_EXTENSION_NAME,
VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, NULL};
uint32_t n_inst_exts = 2;
- /* HDR sessions only (banner_color.h): the colour-space extension lets the swapchain carry HDR10 for
+ /* HDR sessions only (droiddeck_color.h): the colour-space extension lets the swapchain carry HDR10 for
* frame generation. Asked for only when the loader has it, and only when HDR was asked for, so
* every other session creates exactly the instance it always did. */
- if (banner_color_requested() && g_vk.EnumerateInstanceExtensionProperties) {
+ if (droiddeck_color_requested() && g_vk.EnumerateInstanceExtensionProperties) {
uint32_t ne = 0;
g_vk.EnumerateInstanceExtensionProperties(NULL, &ne, NULL);
VkExtensionProperties *ie = ne ? calloc(ne, sizeof(*ie)) : NULL;
@@ -407,14 +407,14 @@ static int dev_init(void) {
}
}
free(ie);
- banner_log("color", "compositor instance %s VK_EXT_swapchain_colorspace (an HDR10 swapchain for frame "
+ droiddeck_log("color", "compositor instance %s VK_EXT_swapchain_colorspace (an HDR10 swapchain for frame "
"generation %s)", g_colorspace_ext ? "enables" : "has no",
g_colorspace_ext ? "is possible where the screen surface offers one" : "is not possible: tone-mapped instead");
}
/* 1.3 like the X11 renderer's instance: the frame-generation probe (framegen_engine.cpp)
* queries VkPhysicalDeviceVulkan12Features, and a 1.1 instance may be answered as 1.1. */
VkApplicationInfo app = {.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
- .pApplicationName = "banner-wayland-present",
+ .pApplicationName = "droiddeck-wayland-present",
.apiVersion = VK_API_VERSION_1_3};
VkInstanceCreateInfo ici = {.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
.pApplicationInfo = &app,
@@ -444,9 +444,9 @@ static int dev_init(void) {
VkPhysicalDeviceProperties props;
g_vk.GetPhysicalDeviceProperties(g_pd, &props);
snprintf(g_gpu_name, sizeof(g_gpu_name), "%s", props.deviceName);
- banner_log("gpu", "compositor renders on %s with %s", props.deviceName,
+ droiddeck_log("gpu", "compositor renders on %s with %s", props.deviceName,
g_library_name ? g_library_name : "the system Vulkan driver");
- if (g_driver_path) banner_log("gpu", "driver folder %s", g_driver_path);
+ if (g_driver_path) droiddeck_log("gpu", "driver folder %s", g_driver_path);
}
g_vk.GetPhysicalDeviceMemoryProperties(g_pd, &g_memprops);
@@ -464,7 +464,7 @@ static int dev_init(void) {
LOGE("present: driver MISSING %s (dmabuf import will fail)", dev_exts[i]);
/* HDR sessions only: the HDR10 swapchain (frame generation) can carry the game's metadata. */
int want_hdr_md = 0;
- if (banner_color_requested()) {
+ if (droiddeck_color_requested()) {
want_hdr_md = has_ext(exts, ne, VK_EXT_HDR_METADATA_EXTENSION_NAME);
if (want_hdr_md) dev_exts[n_dev_exts++] = VK_EXT_HDR_METADATA_EXTENSION_NAME;
}
@@ -487,7 +487,7 @@ static int dev_init(void) {
.enabledExtensionCount = n_dev_exts, .ppEnabledExtensionNames = dev_exts};
VkResult dr = g_vk.CreateDevice(g_pd, &dci, NULL, &g_dev);
if (dr != VK_SUCCESS && fg_features) {
- banner_log("framegen", "the driver refused the LSFG feature set (%s); device created without it",
+ droiddeck_log("framegen", "the driver refused the LSFG feature set (%s); device created without it",
vk_result_name(dr));
dci.pNext = NULL;
fg_features = NULL;
@@ -506,13 +506,13 @@ static int dev_init(void) {
g_wait_sem = VK_NULL_HANDLE;
}
}
- banner_log("perf", "layer buffers: the display's release fences are waited for %s",
+ droiddeck_log("perf", "layer buffers: the display's release fences are waited for %s",
g_import_sem_fd ? "on the GPU (VK_KHR_external_semaphore_fd)"
: "on the CPU (this driver has no VK_KHR_external_semaphore_fd)");
if (want_hdr_md)
g_set_hdr_metadata = (PFN_vkSetHdrMetadataEXT)g_vk.GetDeviceProcAddr(g_dev, "vkSetHdrMetadataEXT");
- if (banner_color_requested())
- banner_log("color", "compositor device %s VK_EXT_hdr_metadata (the HDR10 swapchain for frame generation %s)",
+ if (droiddeck_color_requested())
+ droiddeck_log("color", "compositor device %s VK_EXT_hdr_metadata (the HDR10 swapchain for frame generation %s)",
g_set_hdr_metadata ? "enables" : "has no",
g_set_hdr_metadata ? "carries the game's mastering metadata" : "goes without the game's metadata");
@@ -641,7 +641,7 @@ static void log_surface_formats(const VkSurfaceFormatKHR *f, uint32_t n) {
vk_colorspace_short(f[i].colorSpace));
else hdr_cut++;
}
- banner_log("color", "screen surface lists %u format/colour-space pairs (%s); HDR-capable: %s%s", n, per,
+ droiddeck_log("color", "screen surface lists %u format/colour-space pairs (%s); HDR-capable: %s%s", n, per,
hdr_n ? hdr : "none", hdr_cut ? " (+more)" : "");
}
@@ -678,7 +678,7 @@ static int swap_init_locked(void) {
}
VkSurfaceFormatKHR chosen = fmts[0];
const VkSurfaceFormatKHR sdr_choice = fmts[0];
- if (banner_color_requested() && (!g_surface_formats_said || g_swap_hdr_want)) {
+ if (droiddeck_color_requested() && (!g_surface_formats_said || g_swap_hdr_want)) {
g_surface_formats_said = 1;
log_surface_formats(fmts, nfmt);
}
@@ -702,13 +702,13 @@ static int swap_init_locked(void) {
g_swap_is_hdr = 1;
char fname[24];
vk_format_short(chosen.format, fname, sizeof(fname));
- banner_log("color", "screen swapchain built as HDR10 (format %d %s, HDR10_ST2084): frame-generated HDR "
+ droiddeck_log("color", "screen swapchain built as HDR10 (format %d %s, HDR10_ST2084): frame-generated HDR "
"frames reach the display as PQ BT.2020%s", (int)chosen.format, fname,
vk_format_bits(chosen.format) <= 8 ? " - an 8-bit swapchain: banding possible in smooth gradients"
: "");
} else {
g_swap_hdr_unavailable = 1;
- banner_log("color", "the screen surface lists no HDR10 swapchain format among its %u format/colour-space "
+ droiddeck_log("color", "the screen surface lists no HDR10 swapchain format among its %u format/colour-space "
"pairs (see the line above): frames with frame generation are tone-mapped to SDR instead",
nfmt);
}
@@ -748,7 +748,7 @@ static int swap_init_locked(void) {
if (cr != VK_SUCCESS && g_swap_is_hdr) {
/* The surface listed the HDR10 pair but refused the swapchain: say so, never ask again this
* surface, and build the ordinary one now (frames tone-mapped) - never a black screen. */
- banner_log("color", "the driver refused the HDR10 swapchain (%s): frames with frame generation are "
+ droiddeck_log("color", "the driver refused the HDR10 swapchain (%s): frames with frame generation are "
"tone-mapped to SDR instead", vk_result_name(cr));
g_swap_is_hdr = 0;
g_swap_hdr_unavailable = 1;
@@ -767,7 +767,7 @@ static int swap_init_locked(void) {
g_images = calloc(g_nimg, sizeof(VkImage));
g_vk.GetSwapchainImagesKHR(g_dev, g_swapchain, &g_nimg, g_images);
- banner_log("gpu", "screen output %ux%u, %u buffers, vsync%s", g_extent.width, g_extent.height, g_nimg,
+ droiddeck_log("gpu", "screen output %ux%u, %u buffers, vsync%s", g_extent.width, g_extent.height, g_nimg,
g_swap_extra ? " (frame generation: several presents per frame)" : "");
return 0;
}
@@ -833,7 +833,7 @@ static void init_black_image(void) {
g_vk.WaitForFences(g_dev, 1, &g_fence, VK_TRUE, 1000000000ULL) == VK_SUCCESS)
g_black_state = 1;
else
- banner_log("gpu", "letterbox black image unavailable: the whole output is cleared every copy-path frame");
+ droiddeck_log("gpu", "letterbox black image unavailable: the whole output is cleared every copy-path frame");
}
/* Blit the black image over everything of swapchain image `img` (in TRANSFER_DST_OPTIMAL) OUTSIDE the
@@ -971,7 +971,7 @@ struct vkp_image *vkp_image_import_dmabuf(int fd, uint32_t drm_format, uint64_t
LOGE("%s: vkCreateImage(%s, %dx%d, pitch %u, offset %u) -> %s%s", as_blit_dst ? "layer" : "dmabuf",
vkp_modifier_name(modifier), w, h, stride, offset, vk_result_name(cr),
(!as_blit_dst && modifier == VKP_MOD_QCOM_COMPRESSED)
- ? ": the game's UBWC layout was refused; BANNER_WAYLAND_UBWC=0 forces linear buffers" : "");
+ ? ": the game's UBWC layout was refused; DROIDDECK_WAYLAND_UBWC=0 forces linear buffers" : "");
free(img); return NULL;
}
@@ -1182,7 +1182,7 @@ static int ensure_scene_image(int w, int h) {
if (r != VK_SUCCESS) { LOGE("effects: scene image %dx%d: vkAllocateMemory %s", w, h, vk_result_name(r)); destroy_scene_image(); return -1; }
g_vk.BindImageMemory(g_dev, g_scene.img, g_scene.mem, 0);
g_scene.w = w; g_scene.h = h;
- banner_log("effects", "scene image %dx%d for the effect chain", w, h);
+ droiddeck_log("effects", "scene image %dx%d for the effect chain", w, h);
return 0;
}
@@ -1218,7 +1218,7 @@ static int ensure_img(struct vkp_img_slot *s, int w, int h, VkFormat fmt, VkImag
s->w = w; s->h = h; s->fmt = fmt;
char fname[24];
vk_format_short(fmt, fname, sizeof(fname));
- banner_log("color", "%s image %dx%d (%s)", what, w, h, fname);
+ droiddeck_log("color", "%s image %dx%d (%s)", what, w, h, fname);
return 0;
}
@@ -1249,7 +1249,7 @@ static int compose_hdr(VkCommandBuffer cmd, const struct vkp_draw *draws, int n,
.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT};
g_vk.CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1, &mb, 0, NULL, 0, NULL);
- struct hdrc_params p = {.mode = mode, .sdr_white_nits = banner_color_sdr_white(),
+ struct hdrc_params p = {.mode = mode, .sdr_white_nits = droiddeck_color_sdr_white(),
.peak_nits = hf->peak_nits > 0.0f ? hf->peak_nits : 1000.0f};
int lowest_hdr = -1;
for (int i = 0; i < n; i++) {
@@ -1272,7 +1272,7 @@ static int compose_hdr(VkCommandBuffer cmd, const struct vkp_draw *draws, int n,
}
if (i >= lowest_hdr && !truncated_said) {
truncated_said = 1;
- banner_log("color", "HDR composition: more than %d windows are stacked over the HDR game - the lowest "
+ droiddeck_log("color", "HDR composition: more than %d windows are stacked over the HDR game - the lowest "
"ones are treated as SDR", HDRC_MAX_RECTS);
}
}
@@ -1287,7 +1287,7 @@ static void device_lost(const char *where) {
g_dev_state = -2;
g_base_black = 0;
vkp_framegen_device_lost();
- banner_log("error", "GPU device lost (VK_ERROR_DEVICE_LOST in %s): the compositor has stopped presenting; "
+ droiddeck_log("error", "GPU device lost (VK_ERROR_DEVICE_LOST in %s): the compositor has stopped presenting; "
"restart the session", where);
for (uint32_t i = 0; i < g_nimg; i++) blendp_forget_image(g_images[i]);
if (g_swapchain) g_vk.DestroySwapchainKHR(g_dev, g_swapchain, NULL);
@@ -1385,12 +1385,12 @@ static int acquire_image(int k, int first, uint32_t *img, VkResult *ar_out) {
if (ar == VK_SUCCESS || ar == VK_SUBOPTIMAL_KHR) { *ar_out = ar; return 0; }
if (ar == VK_ERROR_DEVICE_LOST) { device_lost("acquire"); return -1; }
if (ar == VK_ERROR_OUT_OF_DATE_KHR || ar == VK_ERROR_SURFACE_LOST_KHR) {
- banner_log("gpu", "screen surface %s on acquire: rebuilding the swapchain", vk_result_name(ar));
+ droiddeck_log("gpu", "screen surface %s on acquire: rebuilding the swapchain", vk_result_name(ar));
destroy_swapchain();
if (first && attempt == 0) continue;
return -1;
}
- banner_log("error", "present: acquire %d failed (%s %d)", k, vk_result_name(ar), (int)ar);
+ droiddeck_log("error", "present: acquire %d failed (%s %d)", k, vk_result_name(ar), (int)ar);
if (ar == VK_TIMEOUT || ar == VK_NOT_READY) return -1;
destroy_swapchain(); /* anything else: start over next frame */
return -1;
@@ -1422,7 +1422,7 @@ static void check_surface_changed(void) {
if (caps.currentExtent.width == g_caps_extent.width && caps.currentExtent.height == g_caps_extent.height &&
caps.currentTransform == g_surface_transform)
return;
- banner_log("gpu", "screen surface changed (%ux%u -> %ux%u, transform %d -> %d): rebuilding the swapchain",
+ droiddeck_log("gpu", "screen surface changed (%ux%u -> %ux%u, transform %d -> %d): rebuilding the swapchain",
g_caps_extent.width, g_caps_extent.height, caps.currentExtent.width, caps.currentExtent.height,
(int)g_surface_transform, (int)caps.currentTransform);
destroy_swapchain();
@@ -1464,7 +1464,7 @@ static int take_wait_fd(int fd) {
static int said;
if (!said) {
said = 1;
- banner_log("perf", "layer buffers: importing a release fence as a GPU wait failed; waiting for it on the CPU");
+ droiddeck_log("perf", "layer buffers: importing a release fence as a GPU wait failed; waiting for it on the CPU");
}
}
struct pollfd p = {.fd = fd, .events = POLLIN};
@@ -1476,18 +1476,18 @@ static int take_wait_fd(int fd) {
/* The HDR10 swapchain's metadata: the game's SMPTE 2086 / CTA-861.3 values (its image description) via
* VK_EXT_hdr_metadata, once per swapchain and description. A game that gave none gets none. */
-static void send_hdr_metadata(const struct banner_color *c) {
+static void send_hdr_metadata(const struct droiddeck_color *c) {
static int said_none, said_nodesc;
if (!c) return;
if (!g_set_hdr_metadata) {
- if (!said_none) { said_none = 1; banner_log("color", "HDR10 swapchain without the game's metadata: this device "
+ if (!said_none) { said_none = 1; droiddeck_log("color", "HDR10 swapchain without the game's metadata: this device "
"has no VK_EXT_hdr_metadata (the display uses its defaults)"); }
return;
}
if (!c->has_st2086 && !c->has_cta861) {
if (said_nodesc != (int)c->identity) {
said_nodesc = (int)c->identity;
- banner_log("color", "HDR10 swapchain: image description #%u carries no HDR metadata (the game sent none), "
+ droiddeck_log("color", "HDR10 swapchain: image description #%u carries no HDR metadata (the game sent none), "
"so none is set - the display uses its defaults", c->identity);
}
return;
@@ -1506,7 +1506,7 @@ static void send_hdr_metadata(const struct banner_color *c) {
md.maxFrameAverageLightLevel = c->max_fall;
}
g_set_hdr_metadata(g_dev, 1, &g_swapchain, &md);
- banner_log("color", "HDR10 swapchain: the game's metadata set via VK_EXT_hdr_metadata (image description #%u: %s)",
+ droiddeck_log("color", "HDR10 swapchain: the game's metadata set via VK_EXT_hdr_metadata (image description #%u: %s)",
c->identity, c->text);
}
@@ -1522,7 +1522,7 @@ static int render_impl(int scene_w, int scene_h, const struct vkp_draw *draws, i
/* Frame generation queues several presents per scene frame and needs swapchain images for
* them: rebuild when that changes (armed, disarmed, another multiplier). */
if (g_swapchain && vkp_framegen_extra_images() != g_swap_extra) {
- banner_log("gpu", "frame generation now wants %d present%s per frame: rebuilding the swapchain",
+ droiddeck_log("gpu", "frame generation now wants %d present%s per frame: rebuilding the swapchain",
1 + vkp_framegen_extra_images(), vkp_framegen_extra_images() ? "s" : "");
destroy_swapchain();
}
@@ -1531,7 +1531,7 @@ static int render_impl(int scene_w, int scene_h, const struct vkp_draw *draws, i
* swapchain (only in HDR sessions: g_colorspace_ext). */
const int want_hdr = hf && !hf->tonemap && g_colorspace_ext && !g_swap_hdr_unavailable;
if (g_swapchain && want_hdr != g_swap_is_hdr) {
- banner_log("color", want_hdr ? "HDR frames with frame generation: rebuilding the screen swapchain as HDR10"
+ droiddeck_log("color", want_hdr ? "HDR frames with frame generation: rebuilding the screen swapchain as HDR10"
: hf ? "HDR output switched off: rebuilding the screen swapchain as SDR (frames tone-mapped)"
: "no HDR frames through the screen swapchain any more: rebuilding it as SDR");
destroy_swapchain();
@@ -1570,10 +1570,10 @@ static int render_impl(int scene_w, int scene_h, const struct vkp_draw *draws, i
char sw[24];
vk_format_short(g_swap_fmt, sw, sizeof(sw));
if (deep)
- banner_log("color", "frame generation runs on the HDR picture in FP16 (RGBA16F): more than 8 bits of PQ "
+ droiddeck_log("color", "frame generation runs on the HDR picture in FP16 (RGBA16F): more than 8 bits of PQ "
"through interpolation, into the HDR10 swapchain (%s)", sw);
else
- banner_log("color", "frame generation runs on the HDR picture in 8 bits (the engine cannot take FP16 here), "
+ droiddeck_log("color", "frame generation runs on the HDR picture in 8 bits (the engine cannot take FP16 here), "
"into the HDR10 swapchain (%s): banding possible in smooth gradients", sw);
}
}
@@ -1746,7 +1746,7 @@ static int render_impl(int scene_w, int scene_h, const struct vkp_draw *draws, i
if (k > 0) {
VkResult ark;
if (acquire_image(k, 0, &img, &ark) != 0) {
- banner_log("framegen", "present %d/%d: no swapchain image; the frame ends early", k + 1, presents);
+ droiddeck_log("framegen", "present %d/%d: no swapchain image; the frame ends early", k + 1, presents);
pr = VK_ERROR_OUT_OF_DATE_KHR;
break;
}
@@ -1791,7 +1791,7 @@ static int render_impl(int scene_w, int scene_h, const struct vkp_draw *draws, i
if (fr == VK_ERROR_DEVICE_LOST || pr == VK_ERROR_DEVICE_LOST) { device_lost("present"); return -1; }
if (pr == VK_ERROR_OUT_OF_DATE_KHR || pr == VK_ERROR_SURFACE_LOST_KHR) {
/* The surface changed or went away under this frame: rebuild before the next one. */
- banner_log("gpu", "screen surface %s on present: rebuilding the swapchain", vk_result_name(pr));
+ droiddeck_log("gpu", "screen surface %s on present: rebuilding the swapchain", vk_result_name(pr));
destroy_swapchain();
return -1;
} else if (pr == VK_SUBOPTIMAL_KHR || ar == VK_SUBOPTIMAL_KHR) {
@@ -1799,9 +1799,9 @@ static int render_impl(int scene_w, int scene_h, const struct vkp_draw *draws, i
* swap_init), so a rotated panel reports SUBOPTIMAL on every frame. Rebuilding would change
* nothing (and a rebuild per frame would be far worse), so present as is; say so once. */
static int said;
- if (!said) { said = 1; banner_log("gpu", "surface reports SUBOPTIMAL (panel rotation); presenting as is"); }
+ if (!said) { said = 1; droiddeck_log("gpu", "surface reports SUBOPTIMAL (panel rotation); presenting as is"); }
} else if (pr != VK_SUCCESS) {
- banner_log("error", "present: vkQueuePresentKHR failed (%s %d)", vk_result_name(pr), (int)pr);
+ droiddeck_log("error", "present: vkQueuePresentKHR failed (%s %d)", vk_result_name(pr), (int)pr);
destroy_swapchain();
return -1;
}
@@ -1815,7 +1815,7 @@ static int render_impl(int scene_w, int scene_h, const struct vkp_draw *draws, i
* launch/preloader overlay can dismiss (wayland has no XServer window-content hook). */
if (drawn && !g_first_frame_done) {
g_first_frame_done = 1;
- banner_on_first_frame();
+ droiddeck_on_first_frame();
}
if (how) *how = hdr_how;
return 0;
@@ -1856,7 +1856,7 @@ void vkp_reset_first_frame(void) {
void vkp_signal_first_frame(void) {
if (g_first_frame_done) return;
g_first_frame_done = 1;
- banner_on_first_frame();
+ droiddeck_on_first_frame();
}
int vkp_update_map(int scene_w, int scene_h) {
diff --git a/app/src/main/cpp/waylandcomp/src/vk_present.h b/app/src/main/cpp/waylandcomp/src/vk_present.h
index eef9c80cca..2a752c3439 100644
--- a/app/src/main/cpp/waylandcomp/src/vk_present.h
+++ b/app/src/main/cpp/waylandcomp/src/vk_present.h
@@ -122,12 +122,12 @@ int vkp_can_wait_sync_fd(void);
/* ---- HDR composition (hdr_compose.h) ----
* An HDR game that cannot be alone on its display layer: the scene is composed into ONE encoding. */
-struct banner_color;
+struct droiddeck_color;
struct vkp_hdr_frame {
const unsigned char *is_hdr; /* per draw: 1 = its image holds PQ BT.2020 (the surface's description) */
float peak_nits; /* the HDR content's peak, for a tone-map (max CLL / mastering max; 0 = 1000) */
int tonemap; /* 1 = the drawer's HDR output switch is off: tone-map to SDR, never PQ */
- const struct banner_color *color; /* the topmost HDR draw's description: an HDR10 swapchain's metadata */
+ const struct droiddeck_color *color; /* the topmost HDR draw's description: an HDR10 swapchain's metadata */
};
/* vkp_render for a scene with HDR draws (frame generation): composed into PQ and presented through an
* HDR10 swapchain where the surface offers one (and hf->tonemap is 0), else tone-mapped into the ordinary
@@ -184,6 +184,6 @@ int vkp_pass_copy_to(struct vkp_image *dst, int wait_fd);
void vkp_pass_abort(void);
// Session log (compositor.c): one line to Download/Wayland-logs and logcat.
-void banner_log(const char *tag, const char *fmt, ...) __attribute__((format(printf, 2, 3)));
+void droiddeck_log(const char *tag, const char *fmt, ...) __attribute__((format(printf, 2, 3)));
#endif
diff --git a/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c b/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c
index 414ca45b9d..4d11a54192 100644
--- a/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c
+++ b/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c
@@ -16,20 +16,20 @@
#include
#include
#include "vk_present.h"
-#include "banner_ext.h"
+#include "droiddeck_ext.h"
#include "ahb_swapchain.h"
#include "sc_layer.h"
#include "effects_chain.h"
-#include "banner_color.h"
+#include "droiddeck_color.h"
-extern int banner_wayland_run(void);
-extern void banner_wayland_send_pointer(int action, int x, int y);
-extern void banner_wayland_send_touch(int action, int pointer_id, int x, int y);
-extern int banner_cursor_snapshot(int *out, int cap);
-extern int banner_cursor_serial(void);
-extern void banner_wayland_send_key(int evdev, int state);
-extern void banner_wayland_send_scene_input(int type, int a, int b);
-extern void banner_wayland_vsync(int64_t frame_time_ns);
+extern int droiddeck_wayland_run(void);
+extern void droiddeck_wayland_send_pointer(int action, int x, int y);
+extern void droiddeck_wayland_send_touch(int action, int pointer_id, int x, int y);
+extern int droiddeck_cursor_snapshot(int *out, int cap);
+extern int droiddeck_cursor_serial(void);
+extern void droiddeck_wayland_send_key(int evdev, int state);
+extern void droiddeck_wayland_send_scene_input(int type, int a, int b);
+extern void droiddeck_wayland_vsync(int64_t frame_time_ns);
extern volatile int g_fps_limit;
extern volatile int g_hide_shell;
extern volatile int g_zero_copy;
@@ -39,7 +39,7 @@ extern volatile int g_no_render_node;
extern volatile int g_output_refresh_mhz;
extern volatile int g_output_w, g_output_h;
-#define TAG "BannerWayland"
+#define TAG "DroidDeckWayland"
static JavaVM *g_jvm;
static volatile pid_t g_comp_tid; /* the compositor thread, for the app's ADPF hint session */
@@ -80,7 +80,7 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
/* Called from vk_present.c on the compositor thread when the first client frame is
* presented. Attaches to the JVM (this thread is a bare pthread) and calls back into
* Java so the launch overlay can dismiss. Fires exactly once. */
-void banner_on_first_frame(void) {
+void droiddeck_on_first_frame(void) {
if (!g_jvm || !g_compositor_cls || !g_on_first_frame) return;
JNIEnv *env = NULL;
int attached = 0;
@@ -111,7 +111,7 @@ static JNIEnv *thread_env(void) {
}
/* A window started presenting GPU frames (window = its description), or NULL when it closed. */
-void banner_on_game_surface(const char *window, const char *gpu) {
+void droiddeck_on_game_surface(const char *window, const char *gpu) {
JNIEnv *env;
if (!g_compositor_cls || !g_on_game_surface || !(env = thread_env())) return;
jstring jw = window ? (*env)->NewStringUTF(env, window) : NULL;
@@ -124,7 +124,7 @@ void banner_on_game_surface(const char *window, const char *gpu) {
/* The program behind the game window that just started presenting: its Linux pid and executable name
* ("" = unknown). The app arms its launch-time CPU affinity on it. Compositor thread. */
-void banner_on_game_program(int pid, const char *program) {
+void droiddeck_on_game_program(int pid, const char *program) {
JNIEnv *env;
if (!g_compositor_cls || !g_on_game_program || !(env = thread_env())) return;
jstring jp = (*env)->NewStringUTF(env, program ? program : "");
@@ -134,7 +134,7 @@ void banner_on_game_program(int pid, const char *program) {
}
/* One GPU frame from that window. */
-void banner_on_game_frame(void) {
+void droiddeck_on_game_frame(void) {
JNIEnv *env;
if (!g_compositor_cls || !g_on_game_frame || !(env = thread_env())) return;
(*env)->CallStaticVoidMethod(env, g_compositor_cls, g_on_game_frame);
@@ -144,7 +144,7 @@ void banner_on_game_frame(void) {
/* A program locked the pointer (locked = 1; the app's input path switches to deltas) or the lock
* ended (locked = 0; x,y = where the pointer is now, in scene coordinates, for the app to re-sync
* its own pointer to). Compositor thread. */
-void banner_on_pointer_lock(int locked, int x, int y) {
+void droiddeck_on_pointer_lock(int locked, int x, int y) {
JNIEnv *env;
if (!g_compositor_cls || !g_on_pointer_lock || !(env = thread_env())) return;
(*env)->CallStaticVoidMethod(env, g_compositor_cls, g_on_pointer_lock, (jboolean)(locked != 0), (jint)x, (jint)y);
@@ -153,7 +153,7 @@ void banner_on_pointer_lock(int locked, int x, int y) {
/* A program copied text (UTF-8, not NUL-terminated for the app's sake - a byte[] so emoji and
* NULs survive JNI). Compositor thread. */
-void banner_on_clipboard_text(const char *utf8, int len) {
+void droiddeck_on_clipboard_text(const char *utf8, int len) {
JNIEnv *env;
if (!g_compositor_cls || !g_on_clipboard || !(env = thread_env())) return;
jbyteArray arr = (*env)->NewByteArray(env, len);
@@ -166,7 +166,7 @@ void banner_on_clipboard_text(const char *utf8, int len) {
/* A program started (enabled) or stopped accepting IME text; x,y,w,h = its caret rectangle in
* scene pixels (all 0 = unknown). Compositor thread. */
-void banner_on_text_input(int enabled, const char *program, int x, int y, int w, int h) {
+void droiddeck_on_text_input(int enabled, const char *program, int x, int y, int w, int h) {
JNIEnv *env;
if (!g_compositor_cls || !g_on_text_input || !(env = thread_env())) return;
jstring jp = (*env)->NewStringUTF(env, program ? program : "");
@@ -195,11 +195,11 @@ static void *comp_thread(void *arg) {
if (before > COMPOSITOR_NICE && setpriority(PRIO_PROCESS, tid, COMPOSITOR_NICE) != 0) refused = errno ? errno : -1;
const int after = getpriority(PRIO_PROCESS, tid);
if (refused)
- banner_log("perf", "compositor thread %d \"wl-compositor\": stays at nice %d, a higher priority was refused (%s)",
+ droiddeck_log("perf", "compositor thread %d \"wl-compositor\": stays at nice %d, a higher priority was refused (%s)",
(int)tid, after, refused > 0 ? strerror(refused) : "?");
else
- banner_log("perf", "compositor thread %d \"wl-compositor\": nice %d -> %d", (int)tid, before, after);
- banner_wayland_run();
+ droiddeck_log("perf", "compositor thread %d \"wl-compositor\": nice %d -> %d", (int)tid, before, after);
+ droiddeck_wayland_run();
__android_log_print(ANDROID_LOG_INFO, TAG, "compositor thread exited");
if (t_attached) (*g_jvm)->DetachCurrentThread(g_jvm);
t_env = NULL; t_attached = 0;
@@ -272,13 +272,13 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeStartWithSurface(
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSendPointer(
JNIEnv *env, jclass clazz, jint action, jint x, jint y) {
- banner_wayland_send_pointer(action, x, y);
+ droiddeck_wayland_send_pointer(action, x, y);
}
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSendTouch(
JNIEnv *env, jclass clazz, jint action, jint pointer_id, jint x, jint y) {
- banner_wayland_send_touch(action, pointer_id, x, y);
+ droiddeck_wayland_send_touch(action, pointer_id, x, y);
}
/* The client's pointer image and whether it wants one at all (wl_pointer.set_cursor).
@@ -291,7 +291,7 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeCursorSnapshot(
jint cap = (*env)->GetArrayLength(env, out);
jint *buf = (*env)->GetIntArrayElements(env, out, NULL);
if (!buf) return 0;
- int n = banner_cursor_snapshot((int *)buf, (int)cap);
+ int n = droiddeck_cursor_snapshot((int *)buf, (int)cap);
(*env)->ReleaseIntArrayElements(env, out, buf, 0);
return n;
}
@@ -300,27 +300,27 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeCursorSnapshot(
JNIEXPORT jint JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeCursorSerial(JNIEnv *env, jclass clazz) {
(void)env; (void)clazz;
- return banner_cursor_serial();
+ return droiddeck_cursor_serial();
}
/* Inject a key event. evdev = Linux input keycode (KEY_A=30…); state 1=down 0=up. */
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSendKey(
JNIEnv *env, jclass clazz, jint evdev, jint state) {
- banner_wayland_send_key(evdev, state);
+ droiddeck_wayland_send_key(evdev, state);
}
-/* App X-server input in scene (virtual desktop) coordinates; see banner_wayland_send_scene_input. */
+/* App X-server input in scene (virtual desktop) coordinates; see droiddeck_wayland_send_scene_input. */
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSendSceneInput(
JNIEnv *env, jclass clazz, jint type, jint a, jint b) {
- banner_wayland_send_scene_input(type, a, b);
+ droiddeck_wayland_send_scene_input(type, a, b);
}
/* One screen refresh (Choreographer frame callback, UI thread): the compositor draws once. */
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeVsync(JNIEnv *env, jclass clazz, jlong frameTimeNanos) {
- banner_wayland_vsync((int64_t)frameTimeNanos);
+ droiddeck_wayland_vsync((int64_t)frameTimeNanos);
}
/* Shortcut launches: don't draw explorer's windows (desktop, taskbar), like X11's unviewable classes. */
@@ -329,15 +329,15 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetHideShell(JNIEnv
g_hide_shell = hide ? 1 : 0;
}
-/* Zero-copy layer mode (BANNER_WAYLAND_ZERO_COPY=1 at launch, the drawer's switch live): one fullscreen
+/* Zero-copy layer mode (DROIDDECK_WAYLAND_ZERO_COPY=1 at launch, the drawer's switch live): one fullscreen
* window on its own Android layer instead of the swapchain blit (sc_layer.c / ahb_swapchain.c). Any
* thread, any time: before the compositor starts it is the launch default; afterwards the compositor
* thread flips the state, tells the bound games to rebuild their swapchains for it and redraws. */
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetZeroCopy(JNIEnv *env, jclass clazz, jboolean on) {
- int live = banner_get_display() != NULL;
+ int live = droiddeck_get_display() != NULL;
if (!live) g_zero_copy = on ? 1 : 0; /* read by ahb_swapchain_init before the queue drains */
- banner_host_zero_copy(on ? 1 : 0, live);
+ droiddeck_host_zero_copy(on ? 1 : 0, live);
__android_log_print(ANDROID_LOG_INFO, TAG, "zero-copy layer mode %s%s", on ? "on" : "off", live ? " (live)" : "");
}
@@ -355,7 +355,7 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeZeroCopyFrames(JNIEn
}
/* Compressed (UBWC) game buffers: advertise DRM_FORMAT_MOD_QCOM_COMPRESSED on zwp_linux_dmabuf_v1 when
- * the renderer's driver imports it (default on; BANNER_WAYLAND_UBWC=0 = off). Set before the compositor
+ * the renderer's driver imports it (default on; DROIDDECK_WAYLAND_UBWC=0 = off). Set before the compositor
* starts. */
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetUbwc(JNIEnv *env, jclass clazz, jboolean on) {
@@ -363,7 +363,7 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetUbwc(JNIEnv *env,
__android_log_print(ANDROID_LOG_INFO, TAG, "compressed (UBWC) game buffers %s", on ? "on" : "off");
}
-/* Debug: name no DRM device in the dma-buf feedback (BANNER_WAYLAND_NO_RENDER_NODE=1), the way a
+/* Debug: name no DRM device in the dma-buf feedback (DROIDDECK_WAYLAND_NO_RENDER_NODE=1), the way a
* phone that exposes no /dev/dri node to apps does. Set before the compositor starts. */
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetNoRenderNode(JNIEnv *env, jclass clazz, jboolean on) {
@@ -452,12 +452,12 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetScreenEffects(JNI
}
/* One "display" line in the session log, written from Java: facts that live in the Android
- * framework (the panel's HDR capability) rather than in the compositor. banner_log() mirrors to
+ * framework (the panel's HDR capability) rather than in the compositor. droiddeck_log() mirrors to
* logcat and appends to the session file when one is open, so this is safe at any point. */
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeLogDisplay(JNIEnv *env, jclass clazz, jstring message) {
char *s = dup_jstr(env, message);
- if (s) banner_log("display", "%s", s);
+ if (s) droiddeck_log("display", "%s", s);
free(s);
}
@@ -466,18 +466,18 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeLogDisplay(JNIEnv *e
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeLogPerf(JNIEnv *env, jclass clazz, jstring message) {
char *s = dup_jstr(env, message);
- if (s) banner_log("perf", "%s", s);
+ if (s) droiddeck_log("perf", "%s", s);
free(s);
}
-/* ---- HDR10 output, round 1 (banner_color.h / wl_color_mgmt.c) ---- */
+/* ---- HDR10 output, round 1 (droiddeck_color.h / wl_color_mgmt.c) ---- */
-/* The opt-in: mode 0 off, 1 BANNER_WAYLAND_HDR=1, 2 =force (testing). Before the compositor starts. */
+/* The opt-in: mode 0 off, 1 DROIDDECK_WAYLAND_HDR=1, 2 =force (testing). Before the compositor starts. */
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetHdrRequest(JNIEnv *env, jclass clazz, jint mode,
jstring source, jboolean dxvkHdr, jboolean zeroCopyForced) {
char *s = dup_jstr(env, source);
- banner_color_set_request((int)mode, s, dxvkHdr ? 1 : 0, zeroCopyForced ? 1 : 0);
+ droiddeck_color_set_request((int)mode, s, dxvkHdr ? 1 : 0, zeroCopyForced ? 1 : 0);
free(s);
}
@@ -487,7 +487,7 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetHdrDisplay(JNIEnv
jstring formats, jboolean hdr10, jfloat maxLum, jfloat maxAvg, jfloat minLum, jboolean ratioAvailable,
jfloat ratio, jint api) {
char *n = dup_jstr(env, name), *f = dup_jstr(env, formats);
- banner_color_set_display((int)id, n, f, hdr10 ? 1 : 0, (float)maxLum, (float)maxAvg, (float)minLum,
+ droiddeck_color_set_display((int)id, n, f, hdr10 ? 1 : 0, (float)maxLum, (float)maxAvg, (float)minLum,
ratioAvailable ? 1 : 0, (float)ratio, (int)api);
free(n); free(f);
}
@@ -496,38 +496,38 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetHdrDisplay(JNIEnv
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeHdrSdrRatioSample(JNIEnv *env, jclass clazz, jfloat ratio,
jboolean listener) {
- banner_color_ratio_sample((float)ratio, listener ? 1 : 0);
+ droiddeck_color_ratio_sample((float)ratio, listener ? 1 : 0);
}
/* ms since an HDR frame last reached a display layer, -1 = never this session. Any thread. */
JNIEXPORT jint JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeHdrLastFrameAgeMs(JNIEnv *env, jclass clazz) {
- return (jint)banner_color_last_frame_age_ms();
+ return (jint)droiddeck_color_last_frame_age_ms();
}
/* -1 = not decided yet, 0 = closed, 1 = open. Any thread. */
JNIEXPORT jint JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeHdrGateState(JNIEnv *env, jclass clazz) {
- return (jint)banner_color_gate_state();
+ return (jint)droiddeck_color_gate_state();
}
/* The session is ending: the "HDR on screen: ..." summary line. Any thread, once. */
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeHdrSessionEnd(JNIEnv *env, jclass clazz) {
- banner_color_session_end();
+ droiddeck_color_session_end();
}
/* HDR frames really on screen right now (the HUD badge). Any thread. */
JNIEXPORT jboolean JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeHdrOnScreen(JNIEnv *env, jclass clazz) {
- return banner_color_hdr_on_screen() ? JNI_TRUE : JNI_FALSE;
+ return droiddeck_color_hdr_on_screen() ? JNI_TRUE : JNI_FALSE;
}
/* One "color" line in the session log from Java. */
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeLogColor(JNIEnv *env, jclass clazz, jstring message) {
char *s = dup_jstr(env, message);
- if (s) banner_log("color", "%s", s);
+ if (s) droiddeck_log("color", "%s", s);
free(s);
}
@@ -536,7 +536,7 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeLogColor(JNIEnv *env
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeLog(JNIEnv *env, jclass clazz, jstring area, jstring message) {
char *a = dup_jstr(env, area), *s = dup_jstr(env, message);
- if (s) banner_log(a && a[0] ? a : "app", "%s", s);
+ if (s) droiddeck_log(a && a[0] ? a : "app", "%s", s);
free(a);
free(s);
}
@@ -544,65 +544,65 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeLog(JNIEnv *env, jcl
/* SDR content's level inside an HDR picture, in nits (default 203). */
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetHdrSdrWhite(JNIEnv *env, jclass clazz, jfloat nits) {
- banner_color_set_sdr_white((float)nits);
+ droiddeck_color_set_sdr_white((float)nits);
}
/* The drawer's live HDR output switch: on = HDR frames as HDR, off = the same frames tone-mapped to SDR.
* Applied on the compositor thread (logged there, with a redraw). */
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetHdrOutput(JNIEnv *env, jclass clazz, jboolean on) {
- if (banner_get_display()) banner_host_hdr_output(on ? 1 : 0);
- else banner_color_set_output(on ? 1 : 0); /* no compositor thread yet: nothing is drawing either */
+ if (droiddeck_get_display()) droiddeck_host_hdr_output(on ? 1 : 0);
+ else droiddeck_color_set_output(on ? 1 : 0); /* no compositor thread yet: nothing is drawing either */
}
JNIEXPORT jboolean JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeHdrOutput(JNIEnv *env, jclass clazz) {
- return banner_color_output() ? JNI_TRUE : JNI_FALSE;
+ return droiddeck_color_output() ? JNI_TRUE : JNI_FALSE;
}
/* Device evidence for the HDR lines: thermal status + headroom, brightness + mode. */
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeHdrEnvSample(JNIEnv *env, jclass clazz, jint thermal,
jfloat headroom, jint brightness, jint mode) {
- banner_color_env_sample((int)thermal, (float)headroom != (float)headroom ? -1.0f : (float)headroom,
+ droiddeck_color_env_sample((int)thermal, (float)headroom != (float)headroom ? -1.0f : (float)headroom,
(int)brightness, (int)mode);
}
/* Display.getHighestHdrSdrRatio() (Android 16+), <= 0 = not reported. */
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetHdrHighestRatio(JNIEnv *env, jclass clazz, jfloat ratio) {
- banner_color_set_highest_ratio((float)ratio == (float)ratio ? (float)ratio : -1.0f);
+ droiddeck_color_set_highest_ratio((float)ratio == (float)ratio ? (float)ratio : -1.0f);
}
/* The HDR headroom the screen surface should ask for (HDR10 swapchain frames in the last 1.5 s), 0 = none. */
JNIEXPORT jfloat JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeHdrScreenHeadroom(JNIEnv *env, jclass clazz) {
- return (jfloat)banner_color_screen_headroom(NULL, 0);
+ return (jfloat)droiddeck_color_screen_headroom(NULL, 0);
}
JNIEXPORT jstring JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeHdrScreenHeadroomWhy(JNIEnv *env, jclass clazz) {
char why[200];
- banner_color_screen_headroom(why, sizeof(why));
+ droiddeck_color_screen_headroom(why, sizeof(why));
return (*env)->NewStringUTF(env, why);
}
/* The app's screen-surface request, for the no-headroom lines: > 0 asked, 0 cleared, -1 not possible. */
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeHdrNoteHeadroomRequest(JNIEnv *env, jclass clazz, jfloat ratio) {
- banner_color_note_headroom_request((float)ratio);
+ droiddeck_color_note_headroom_request((float)ratio);
}
/* 0 none, 1 HDR frames on screen with headroom, 2 HDR frames on screen without headroom for 5 s+. */
JNIEXPORT jint JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeHdrState(JNIEnv *env, jclass clazz) {
- return (jint)banner_color_hdr_state();
+ return (jint)droiddeck_color_hdr_state();
}
/* An HDR game's frames were shown tone-mapped to SDR in the last 1.5 s (the drawer's status line). */
JNIEXPORT jboolean JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeHdrToneMappedOnScreen(JNIEnv *env, jclass clazz) {
- return banner_color_tonemapped_on_screen() ? JNI_TRUE : JNI_FALSE;
+ return droiddeck_color_tonemapped_on_screen() ? JNI_TRUE : JNI_FALSE;
}
/* The Look the controls currently match (null = Custom) - only named in the session log. */
@@ -651,7 +651,7 @@ JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetClipboardText(JNIEnv *env, jclass clazz, jbyteArray utf8) {
int len;
char *buf = dup_bytes(env, utf8, &len);
- banner_host_clipboard_text(buf ? buf : "", len);
+ droiddeck_host_clipboard_text(buf ? buf : "", len);
free(buf);
}
@@ -660,7 +660,7 @@ JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeTextInputCommit(JNIEnv *env, jclass clazz, jbyteArray utf8) {
int len;
char *buf = dup_bytes(env, utf8, &len);
- if (buf && len) banner_host_text_commit(buf, len);
+ if (buf && len) droiddeck_host_text_commit(buf, len);
free(buf);
}
@@ -670,14 +670,14 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeTextInputPreedit(JNI
jint cursorBegin, jint cursorEnd) {
int len;
char *buf = dup_bytes(env, utf8, &len);
- banner_host_text_preedit(buf ? buf : "", len, cursorBegin, cursorEnd);
+ droiddeck_host_text_preedit(buf ? buf : "", len, cursorBegin, cursorEnd);
free(buf);
}
/* The IME deleted characters around the caret. */
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeTextInputDelete(JNIEnv *env, jclass clazz, jint before, jint after) {
- banner_host_text_delete(before, after);
+ droiddeck_host_text_delete(before, after);
}
/* KGSL's power control, off (the GPU held at its top clock) or back on. The property is the
diff --git a/app/src/main/cpp/waylandcomp/src/wl_clipboard.c b/app/src/main/cpp/waylandcomp/src/wl_clipboard.c
index 0c6c57304d..7668090f75 100644
--- a/app/src/main/cpp/waylandcomp/src/wl_clipboard.c
+++ b/app/src/main/cpp/waylandcomp/src/wl_clipboard.c
@@ -16,7 +16,7 @@
*
* Guest → Android: when a program sets a selection with a text mime, the compositor asks for it
* once over a pipe on the event loop (non-blocking, 1 MiB cap, 3 s timeout) and hands the text
- * to the app (banner_on_clipboard_text → ClipboardManager). Android → guest: the app's text
+ * to the app (droiddeck_on_clipboard_text → ClipboardManager). Android → guest: the app's text
* becomes the HOST selection; receive requests are answered with a non-blocking writer.
*/
#define _GNU_SOURCE 1
@@ -25,7 +25,7 @@
#include
#include
#include
-#include "banner_ext.h"
+#include "droiddeck_ext.h"
#include "wlr-data-control-unstable-v1-server-protocol.h"
#define CLIP_MAX_BYTES (1024 * 1024)
@@ -130,7 +130,7 @@ static int on_writer_writable(int fd, uint32_t mask, void *data) {
static int on_writer_timeout(void *data) {
struct writer *w = data;
- banner_log("clipboard", "a program never read the clipboard text it asked for; giving up");
+ droiddeck_log("clipboard", "a program never read the clipboard text it asked for; giving up");
writer_free(w);
return 0;
}
@@ -179,11 +179,11 @@ static void reader_finish(struct reader *r) {
free(g_last_guest_text);
g_last_guest_text = copy;
g_last_guest_len = r->len;
- banner_log("clipboard", "guest copied %zu bytes (%s)", r->len, r->mime);
- banner_on_clipboard_text(copy, (int)r->len);
+ droiddeck_log("clipboard", "guest copied %zu bytes (%s)", r->len, r->mime);
+ droiddeck_on_clipboard_text(copy, (int)r->len);
}
} else {
- banner_log("clipboard", "guest copied an empty text; Android clipboard left alone");
+ droiddeck_log("clipboard", "guest copied an empty text; Android clipboard left alone");
}
reader_free(r);
}
@@ -192,7 +192,7 @@ static int on_reader_readable(int fd, uint32_t mask, void *data) {
struct reader *r = data;
for (;;) {
if (r->len >= CLIP_MAX_BYTES) {
- banner_log("clipboard", "guest text exceeds %d bytes; dropped", CLIP_MAX_BYTES);
+ droiddeck_log("clipboard", "guest text exceeds %d bytes; dropped", CLIP_MAX_BYTES);
reader_free(r);
return 0;
}
@@ -215,7 +215,7 @@ static int on_reader_readable(int fd, uint32_t mask, void *data) {
static int on_reader_timeout(void *data) {
struct reader *r = data;
- banner_log("clipboard", "timed out reading the guest's clipboard text (%zu bytes so far)", r->len);
+ droiddeck_log("clipboard", "timed out reading the guest's clipboard text (%zu bytes so far)", r->len);
reader_free(r);
return 0;
}
@@ -251,7 +251,7 @@ static void offer_receive(struct wl_client *c, struct wl_resource *r, const char
if (!o || o->gen != g_gen) { close(fd); return; } /* stale offer */
if (g_owner == OWNER_HOST) {
if (is_text_mime(mime)) {
- banner_log("clipboard", "Android clipboard → guest (%zu bytes) for %s", g_host_len, banner_client_name(c));
+ droiddeck_log("clipboard", "Android clipboard → guest (%zu bytes) for %s", g_host_len, droiddeck_client_name(c));
writer_start(fd, g_host_text, g_host_len);
} else {
close(fd);
@@ -327,7 +327,7 @@ static void broadcast_selection(void) {
wl_display_flush_clients(g_disp);
}
-void banner_clipboard_keyboard_focus(struct wl_client *client) {
+void droiddeck_clipboard_keyboard_focus(struct wl_client *client) {
struct device *d;
if (client == g_kb_client) return;
g_kb_client = client;
@@ -345,7 +345,7 @@ static void source_res_destroy(struct wl_resource *r) {
g_src = NULL;
g_owner = OWNER_NONE;
if (g_reader) reader_free(g_reader);
- banner_log("clipboard", "%s withdrew its clipboard contents", banner_client_name(wl_resource_get_client(r)));
+ droiddeck_log("clipboard", "%s withdrew its clipboard contents", droiddeck_client_name(wl_resource_get_client(r)));
broadcast_selection();
}
for (int i = 0; i < s->nmimes; i++) free(s->mimes[i]);
@@ -396,9 +396,9 @@ static void set_selection(struct wl_client *c, struct wl_resource *source_res) {
if (*list) strncat(list, ", ", sizeof(list) - strlen(list) - 1);
strncat(list, s->mimes[i], sizeof(list) - strlen(list) - 1);
}
- banner_log("clipboard", "selection set by %s (%s)", banner_client_name(c), *list ? list : "no mime types");
+ droiddeck_log("clipboard", "selection set by %s (%s)", droiddeck_client_name(c), *list ? list : "no mime types");
} else {
- banner_log("clipboard", "%s cleared the clipboard", banner_client_name(c));
+ droiddeck_log("clipboard", "%s cleared the clipboard", droiddeck_client_name(c));
}
broadcast_selection();
read_client_text();
@@ -415,7 +415,7 @@ static void device_res_destroy(struct wl_resource *r) {
static void device_start_drag(struct wl_client *c, struct wl_resource *r, struct wl_resource *source,
struct wl_resource *origin, struct wl_resource *icon, uint32_t serial) {
- banner_log("clipboard", "%s started a drag and drop; not supported, cancelled", banner_client_name(c));
+ droiddeck_log("clipboard", "%s started a drag and drop; not supported, cancelled", droiddeck_client_name(c));
if (source) {
struct source *s = wl_resource_get_user_data(source);
if (s && s != g_src) source_send_cancelled(s);
@@ -512,7 +512,7 @@ void clipboard_host_text(char *utf8, size_t len) {
if (!len) free(utf8);
g_host_len = len;
g_owner = len ? OWNER_HOST : OWNER_NONE;
- banner_log("clipboard", len ? "Android clipboard → guest (%zu bytes)" : "Android clipboard cleared (%zu bytes)", len);
+ droiddeck_log("clipboard", len ? "Android clipboard → guest (%zu bytes)" : "Android clipboard cleared (%zu bytes)", len);
broadcast_selection();
}
diff --git a/app/src/main/cpp/waylandcomp/src/wl_color_mgmt.c b/app/src/main/cpp/waylandcomp/src/wl_color_mgmt.c
index be4885fd54..f18aab9f4c 100644
--- a/app/src/main/cpp/waylandcomp/src/wl_color_mgmt.c
+++ b/app/src/main/cpp/waylandcomp/src/wl_color_mgmt.c
@@ -1,7 +1,7 @@
/*
* wp_color_manager_v1 (wayland-protocols staging color-management-v1, version 1) - the subset Mesa's
* Wayland WSI binds - plus the HDR gate, the per-surface image descriptions and the session log's
- * HDR evidence. See banner_color.h for the design and HDR_RECON.md for why it is shaped this way.
+ * HDR evidence. See droiddeck_color.h for the design and HDR_RECON.md for why it is shaped this way.
*
* Strictness policy. A protocol error disconnects the client, and the client here is a GAME, so
* errors are only raised where the protocol leaves no choice and a conforming client can never hit
@@ -12,8 +12,8 @@
* for the same surface replaces the first, a request on an inert object is ignored.
*/
#define _GNU_SOURCE
-#include "banner_color.h"
-#include "banner_ext.h"
+#include "droiddeck_color.h"
+#include "droiddeck_ext.h"
#include "ahb_swapchain.h"
#include "sc_layer.h"
#include "color-management-v1-server-protocol.h"
@@ -30,7 +30,7 @@ extern volatile int g_zero_copy;
#define TAG "color"
/* AHARDWAREBUFFER_FORMAT_* (android/hardware_buffer.h), for the log only. */
-const char *banner_ahb_format_name(uint32_t f) {
+const char *droiddeck_ahb_format_name(uint32_t f) {
static char other[32];
switch (f) {
case 1: return "RGBA8888 (8-bit)";
@@ -73,9 +73,9 @@ static const char *tf_name(uint32_t tf) {
static const char *dataspace_name(int32_t ds) {
switch (ds) {
- case BANNER_ADATASPACE_BT2020_PQ: return "BT2020_PQ";
- case BANNER_ADATASPACE_BT2020_HLG: return "BT2020_HLG";
- case BANNER_ADATASPACE_UNKNOWN: return "UNKNOWN (sRGB)";
+ case DROIDDECK_ADATASPACE_BT2020_PQ: return "BT2020_PQ";
+ case DROIDDECK_ADATASPACE_BT2020_HLG: return "BT2020_HLG";
+ case DROIDDECK_ADATASPACE_UNKNOWN: return "UNKNOWN (sRGB)";
default: return "other";
}
}
@@ -99,7 +99,7 @@ static _Atomic int g_gate = -1; /* -1 undecided, 0 closed, 1 open */
static char g_gate_why[320]; /* the closed gate's reason (for the summary) */
static _Atomic int g_output_on = 1; /* the drawer's HDR output switch (per session, starts on) */
-void banner_color_set_request(int mode, const char *source, int dxvk_hdr, int zero_copy_forced) {
+void droiddeck_color_set_request(int mode, const char *source, int dxvk_hdr, int zero_copy_forced) {
pthread_mutex_lock(&g_mu);
g_req.mode = mode < 0 ? 0 : mode > 2 ? 2 : mode;
snprintf(g_req.source, sizeof(g_req.source), "%s", source ? source : "environment");
@@ -109,7 +109,7 @@ void banner_color_set_request(int mode, const char *source, int dxvk_hdr, int ze
atomic_store(&g_output_on, 1); /* the drawer's switch is per session and starts on */
}
-void banner_color_set_display(int id, const char *name, const char *formats, int hdr10, float max_lum,
+void droiddeck_color_set_display(int id, const char *name, const char *formats, int hdr10, float max_lum,
float max_avg, float min_lum, int ratio_available, float ratio, int api) {
pthread_mutex_lock(&g_mu);
int was_known = g_req.display_known, was_hdr10 = g_req.hdr10, was_id = g_req.display_id;
@@ -127,17 +127,17 @@ void banner_color_set_display(int id, const char *name, const char *formats, int
* session is recorded, and what it means is said out loud. */
if (was_known && atomic_load(&g_gate) >= 0 && (was_hdr10 != (hdr10 ? 1 : 0) || was_id != id)) {
if (atomic_load(&g_gate) == 1 && !hdr10)
- banner_log(TAG, "the game is now on \"%s\" (display %d), which reports no HDR10: HDR frames stay tagged "
+ droiddeck_log(TAG, "the game is now on \"%s\" (display %d), which reports no HDR10: HDR frames stay tagged "
"BT2020_PQ and SurfaceFlinger tone-maps them for this display (the offer to games is fixed "
"for the session)", name ? name : "?", id);
else if (atomic_load(&g_gate) == 0 && hdr10)
- banner_log(TAG, "the game is now on \"%s\" (display %d), which reports HDR10 - HDR stays off for this "
+ droiddeck_log(TAG, "the game is now on \"%s\" (display %d), which reports HDR10 - HDR stays off for this "
"session (the gate is decided when the compositor starts); relaunch to use it", name ? name : "?", id);
}
}
-int banner_color_gate_state(void) { return atomic_load(&g_gate); }
-int banner_color_hdr_open(void) { return atomic_load(&g_gate) == 1; }
+int droiddeck_color_gate_state(void) { return atomic_load(&g_gate); }
+int droiddeck_color_hdr_open(void) { return atomic_load(&g_gate) == 1; }
/* ---------------------------------------------------------------- HDR evidence (summary) */
@@ -170,7 +170,7 @@ static struct {
static _Atomic int64_t g_last_frame_ns;
static _Atomic int64_t g_last_tm_ns; /* the last HDR frame shown tone-mapped to SDR */
-/* What the device says beside the headroom (the app, non-root APIs; banner_color_env_*). The Fold showed
+/* What the device says beside the headroom (the app, non-root APIs; droiddeck_color_env_*). The Fold showed
* three ways to lose HDR headroom with HDR frames on screen - a screen recording, heat under load, and
* (plausibly) the brightness slider at maximum - so every no-headroom line carries this. Under g_mu. */
static struct {
@@ -241,20 +241,20 @@ static _Atomic int g_screen_hr_x1000; /* the screen surface's wanted headr
static _Atomic int64_t g_screen_hr_ns; /* the last HDR10-swapchain frame */
static char g_screen_hr_why[200]; /* under g_mu */
-static float peak_of(const struct banner_color *c, float disp_max, const char **src) {
+static float peak_of(const struct droiddeck_color *c, float disp_max, const char **src) {
if (c->max_cll > 0.0f) { *src = "max CLL"; return c->max_cll; }
if (c->has_st2086 && c->max_lum > 0.0f) { *src = "mastering max"; return c->max_lum; }
if (disp_max > 0.0f) { *src = "the display's peak"; return disp_max; }
*src = "assumed"; return 1000.0f;
}
-float banner_color_desired_headroom(const struct banner_color *c, char *why, size_t n) {
+float droiddeck_color_desired_headroom(const struct droiddeck_color *c, char *why, size_t n) {
if (!c || !c->dataspace) { if (why && n) why[0] = 0; return 0.0f; }
pthread_mutex_lock(&g_mu);
const float disp_max = g_req.max_lum, highest = g_req.highest_ratio;
pthread_mutex_unlock(&g_mu);
const char *src;
- const float peak = peak_of(c, disp_max, &src), white = banner_color_sdr_white();
+ const float peak = peak_of(c, disp_max, &src), white = droiddeck_color_sdr_white();
if (highest > 0.0f && highest <= 1.01f) {
if (why && n) snprintf(why, n, "the display reports its highest HDR/SDR ratio as %.2f: no app can get a "
"boost here, so nothing is asked", highest);
@@ -273,24 +273,24 @@ float banner_color_desired_headroom(const struct banner_color *c, char *why, siz
return r;
}
-void banner_color_note_headroom_request(float ratio) {
+void droiddeck_color_note_headroom_request(float ratio) {
pthread_mutex_lock(&g_mu);
g_env.requested = ratio;
pthread_mutex_unlock(&g_mu);
}
-void banner_color_set_highest_ratio(float ratio) {
+void droiddeck_color_set_highest_ratio(float ratio) {
pthread_mutex_lock(&g_mu);
const float was = g_req.highest_ratio;
g_req.highest_ratio = ratio > 0.0f ? ratio : -1.0f;
pthread_mutex_unlock(&g_mu);
if (ratio > 0.0f && (was < 0.0f || was != ratio) && atomic_load(&g_gate) == 1)
- banner_log(TAG, "the display's highest HDR/SDR ratio is %.2f%s", ratio,
+ droiddeck_log(TAG, "the display's highest HDR/SDR ratio is %.2f%s", ratio,
ratio <= 1.01f ? " - it reports no HDR boost at all: no app can raise HDR highlights above SDR white here"
: " (the most HDR headroom it can give)");
}
-float banner_color_screen_headroom(char *why, size_t n) {
+float droiddeck_color_screen_headroom(char *why, size_t n) {
const int64_t t = atomic_load(&g_screen_hr_ns);
if (!t || now_ns() - t > 1500000000LL) { if (why && n) why[0] = 0; return 0.0f; }
if (why && n) {
@@ -301,7 +301,7 @@ float banner_color_screen_headroom(char *why, size_t n) {
return atomic_load(&g_screen_hr_x1000) / 1000.0f;
}
-int banner_color_last_frame_age_ms(void) {
+int droiddeck_color_last_frame_age_ms(void) {
int64_t t = atomic_load(&g_last_frame_ns);
if (!t) return -1;
int64_t age = (now_ns() - t) / 1000000LL;
@@ -408,34 +408,34 @@ static void log_verdict(int force) {
int changed = strcmp(v, g_hdr.verdict) != 0;
if (changed) snprintf(g_hdr.verdict, sizeof(g_hdr.verdict), "%s", v);
pthread_mutex_unlock(&g_mu);
- if (changed || force) banner_log(TAG, "HDR on screen: %s", v);
+ if (changed || force) droiddeck_log(TAG, "HDR on screen: %s", v);
}
-void banner_color_frame_shown(const struct banner_color *c, int path, uint32_t ahb_format) {
+void droiddeck_color_frame_shown(const struct droiddeck_color *c, int path, uint32_t ahb_format) {
if (!c || !c->dataspace) return;
int first8 = 0;
pthread_mutex_lock(&g_mu);
switch (path) {
- case BANNER_HDR_ZERO_COPY:
+ case DROIDDECK_HDR_ZERO_COPY:
if (ahb_format == 0x2b) g_hdr.layer_10bit++;
g_hdr.win_zc++;
- snprintf(g_hdr.layer_fmt, sizeof(g_hdr.layer_fmt), "%s", banner_ahb_format_name(ahb_format));
+ snprintf(g_hdr.layer_fmt, sizeof(g_hdr.layer_fmt), "%s", droiddeck_ahb_format_name(ahb_format));
break;
- case BANNER_HDR_LAYER_COPY:
+ case DROIDDECK_HDR_LAYER_COPY:
if (!g_hdr.layer_copy8) first8 = 1;
g_hdr.layer_copy8++; g_hdr.win_copy8++;
snprintf(g_hdr.layer_fmt, sizeof(g_hdr.layer_fmt), "RGBA8888 layer copy");
break;
- case BANNER_HDR_COMPOSED:
+ case DROIDDECK_HDR_COMPOSED:
g_hdr.composed++; g_hdr.win_composed++;
- snprintf(g_hdr.layer_fmt, sizeof(g_hdr.layer_fmt), "composed %s", banner_ahb_format_name(ahb_format));
+ snprintf(g_hdr.layer_fmt, sizeof(g_hdr.layer_fmt), "composed %s", droiddeck_ahb_format_name(ahb_format));
break;
- case BANNER_HDR_SWAPCHAIN:
+ case DROIDDECK_HDR_SWAPCHAIN:
g_hdr.swapchain++; g_hdr.win_swapchain++;
snprintf(g_hdr.layer_fmt, sizeof(g_hdr.layer_fmt), "HDR10 swapchain");
atomic_store(&g_screen_hr_ns, now_ns());
break;
- default: /* BANNER_HDR_TONEMAPPED: shown, but not as HDR */
+ default: /* DROIDDECK_HDR_TONEMAPPED: shown, but not as HDR */
g_hdr.tonemapped++; g_hdr.win_tonemapped++;
if (!atomic_load(&g_output_on)) g_hdr.tm_off++;
pthread_mutex_unlock(&g_mu);
@@ -446,7 +446,7 @@ void banner_color_frame_shown(const struct banner_color *c, int path, uint32_t a
g_hdr.win_layer++;
pthread_mutex_unlock(&g_mu);
atomic_store(&g_last_frame_ns, now_ns());
- if (path == BANNER_HDR_SWAPCHAIN) {
+ if (path == DROIDDECK_HDR_SWAPCHAIN) {
/* The screen surface's headroom request (the app applies it): worked out again when the
* description changes, else once a second. */
static uint32_t ident;
@@ -454,7 +454,7 @@ void banner_color_frame_shown(const struct banner_color *c, int path, uint32_t a
const int64_t t = now_ns();
if (c->identity != ident || t - calc_ns > 1000000000LL) {
char why[200];
- const float r = banner_color_desired_headroom(c, why, sizeof(why));
+ const float r = droiddeck_color_desired_headroom(c, why, sizeof(why));
ident = c->identity; calc_ns = t;
pthread_mutex_lock(&g_mu);
snprintf(g_screen_hr_why, sizeof(g_screen_hr_why), "%s", why);
@@ -463,12 +463,12 @@ void banner_color_frame_shown(const struct banner_color *c, int path, uint32_t a
}
}
if (first8)
- banner_log(TAG, "HDR frames are reaching the display layer through the compositor's 8-bit layer copy (the game's "
+ droiddeck_log(TAG, "HDR frames are reaching the display layer through the compositor's 8-bit layer copy (the game's "
"buffer is not a gralloc buffer this frame): colours stay correct (the frame keeps its BT2020_PQ tag), "
"precision drops to 8 bits (banding possible)");
}
-void banner_color_frame_copied(const char *who, const char *reason) {
+void droiddeck_color_frame_copied(const char *who, const char *reason) {
int first = 0;
pthread_mutex_lock(&g_mu);
g_hdr.copy_frames++;
@@ -479,14 +479,14 @@ void banner_color_frame_copied(const char *who, const char *reason) {
}
pthread_mutex_unlock(&g_mu);
if (first)
- banner_log(TAG, "HDR frames of %s go through the compositor's 8-bit SDR copy now, because %s: shown WITHOUT "
+ droiddeck_log(TAG, "HDR frames of %s go through the compositor's 8-bit SDR copy now, because %s: shown WITHOUT "
"tone mapping (washed out) until that changes", who ? who : "a window", reason ? reason : "?");
}
-void banner_color_ratio_sample(float ratio, int listener) {
+void droiddeck_color_ratio_sample(float ratio, int listener) {
if (atomic_load(&g_gate) != 1) return;
int64_t t = now_ns();
- int age = banner_color_last_frame_age_ms();
+ int age = droiddeck_color_last_frame_age_ms();
int live = age >= 0 && age < 1500;
int log_it = 0, periodic = 0, nohead_now = 0, head_back = 0;
float was;
@@ -536,28 +536,28 @@ void banner_color_ratio_sample(float ratio, int listener) {
}
pthread_mutex_unlock(&g_mu);
if (nohead_now)
- banner_log(TAG, "no HDR headroom for 5 s while HDR frames are on screen (display HDR/SDR ratio %.2f): %s - Android "
+ droiddeck_log(TAG, "no HDR headroom for 5 s while HDR frames are on screen (display HDR/SDR ratio %.2f): %s - Android "
"drops HDR headroom while the screen is recorded and when the device is hot, and some phones never "
"boost HDR for apps; HDR highlights look no brighter until that ends [%s]", ratio, causes, env);
if (head_back)
- banner_log(TAG, "HDR headroom is back: display HDR/SDR ratio %.2f with HDR frames on screen", ratio);
+ droiddeck_log(TAG, "HDR headroom is back: display HDR/SDR ratio %.2f with HDR frames on screen", ratio);
if (!log_it) return;
char when[64];
if (age < 0) snprintf(when, sizeof(when), "none yet this session");
else snprintf(when, sizeof(when), "%s, last one %d ms ago", live ? "yes" : "no", age);
if (periodic)
- banner_log(TAG, "display HDR/SDR ratio %.2f (steady; HDR frames on screen: %s)%s%s%s%s%s", ratio, when,
+ droiddeck_log(TAG, "display HDR/SDR ratio %.2f (steady; HDR frames on screen: %s)%s%s%s%s%s", ratio, when,
live && ratio <= 1.01f ? " - no HDR headroom: " : "", live && ratio <= 1.01f ? causes : "",
env[0] ? " [" : "", env, env[0] ? "]" : "");
else if (was > 0.0f)
- banner_log(TAG, "display HDR/SDR ratio %.2f (was %.2f; HDR frames on screen: %s) [%s]", ratio, was, when,
+ droiddeck_log(TAG, "display HDR/SDR ratio %.2f (was %.2f; HDR frames on screen: %s) [%s]", ratio, was, when,
listener ? "display listener" : "sampler");
else
- banner_log(TAG, "display HDR/SDR ratio %.2f (first reading; HDR frames on screen: %s) [%s]", ratio, when,
+ droiddeck_log(TAG, "display HDR/SDR ratio %.2f (first reading; HDR frames on screen: %s) [%s]", ratio, when,
listener ? "display listener" : "sampler");
}
-void banner_color_stats_tick(void) {
+void droiddeck_color_stats_tick(void) {
if (atomic_load(&g_gate) != 1) return;
char line[512];
int any;
@@ -582,13 +582,13 @@ void banner_color_stats_tick(void) {
g_hdr.win_zc = g_hdr.win_composed = g_hdr.win_swapchain = g_hdr.win_tonemapped = 0;
g_hdr.win_ratio_n = 0;
pthread_mutex_unlock(&g_mu);
- if (any) banner_log(TAG, "%s", line);
+ if (any) droiddeck_log(TAG, "%s", line);
log_verdict(0);
}
-int banner_color_hdr_state(void) {
+int droiddeck_color_hdr_state(void) {
if (atomic_load(&g_gate) != 1) return 0;
- int age = banner_color_last_frame_age_ms();
+ int age = droiddeck_color_last_frame_age_ms();
if (age < 0 || age >= 1500) return 0;
pthread_mutex_lock(&g_mu);
int confirmed = !g_hdr.ratio_n || g_hdr.ratio_last > 1.01f; /* no ratio on this display: the tag is all there is */
@@ -597,26 +597,26 @@ int banner_color_hdr_state(void) {
return confirmed ? 1 : nohead ? 2 : 0;
}
-int banner_color_hdr_on_screen(void) { return banner_color_hdr_state() == 1; }
+int droiddeck_color_hdr_on_screen(void) { return droiddeck_color_hdr_state() == 1; }
static _Atomic int g_sdr_white_x100 = 20300;
-void banner_color_set_sdr_white(float nits) {
+void droiddeck_color_set_sdr_white(float nits) {
if (!(nits >= 10.0f && nits <= 2000.0f)) return;
atomic_store(&g_sdr_white_x100, (int)(nits * 100.0f + 0.5f));
- banner_log(TAG, "SDR content inside an HDR picture is placed at %.0f nits (BANNER_WAYLAND_HDR_SDR_NITS)", nits);
+ droiddeck_log(TAG, "SDR content inside an HDR picture is placed at %.0f nits (DROIDDECK_WAYLAND_HDR_SDR_NITS)", nits);
}
-float banner_color_sdr_white(void) { return atomic_load(&g_sdr_white_x100) / 100.0f; }
+float droiddeck_color_sdr_white(void) { return atomic_load(&g_sdr_white_x100) / 100.0f; }
-int banner_color_requested(void) {
+int droiddeck_color_requested(void) {
pthread_mutex_lock(&g_mu);
int m = g_req.mode;
pthread_mutex_unlock(&g_mu);
return m != 0;
}
-int banner_color_output(void) { return atomic_load(&g_output_on); }
+int droiddeck_color_output(void) { return atomic_load(&g_output_on); }
-void banner_color_env_sample(int thermal, float headroom, int brightness, int bmode) {
+void droiddeck_color_env_sample(int thermal, float headroom, int brightness, int bmode) {
if (atomic_load(&g_gate) != 1) return; /* evidence for the HDR lines only */
char msg[2][200];
int nmsg = 0;
@@ -644,42 +644,42 @@ void banner_color_env_sample(int thermal, float headroom, int brightness, int bm
"brightness changes are logged as they happen)", e);
}
pthread_mutex_unlock(&g_mu);
- for (int i = 0; i < nmsg; i++) banner_log(TAG, "%s", msg[i]);
+ for (int i = 0; i < nmsg; i++) droiddeck_log(TAG, "%s", msg[i]);
}
-int banner_color_tonemapped_on_screen(void) {
+int droiddeck_color_tonemapped_on_screen(void) {
if (atomic_load(&g_gate) != 1) return 0;
int64_t t = atomic_load(&g_last_tm_ns);
return t && now_ns() - t < 1500000000LL;
}
-void banner_color_set_output(int on) {
+void droiddeck_color_set_output(int on) {
on = on ? 1 : 0;
if (atomic_load(&g_gate) != 1) {
/* The drawer only shows the switch in sessions whose gate is open; say so if it ever gets here. */
- banner_log(TAG, "HDR output switch (%s) ignored: HDR is not open in this session", on ? "on" : "off");
+ droiddeck_log(TAG, "HDR output switch (%s) ignored: HDR is not open in this session", on ? "on" : "off");
return;
}
if (atomic_exchange(&g_output_on, on) == on) return;
char who[160];
- int age = banner_color_last_frame_age_ms(), tm = banner_color_tonemapped_on_screen();
+ int age = droiddeck_color_last_frame_age_ms(), tm = droiddeck_color_tonemapped_on_screen();
pthread_mutex_lock(&g_mu);
if (!on) g_hdr.output_offs++;
snprintf(who, sizeof(who), "%s", g_hdr.applied_who[0] ? g_hdr.applied_who : "no HDR program yet");
pthread_mutex_unlock(&g_mu);
if (on)
- banner_log(TAG, "HDR output switched ON in the drawer: HDR frames go to the display as HDR again from the next "
+ droiddeck_log(TAG, "HDR output switched ON in the drawer: HDR frames go to the display as HDR again from the next "
"frame (%s; %s)", who, tm ? "they were being tone-mapped to SDR until now" : "none were on screen just now");
else
- banner_log(TAG, "HDR output switched OFF in the drawer: HDR frames are tone-mapped to SDR from the next frame "
+ droiddeck_log(TAG, "HDR output switched OFF in the drawer: HDR frames are tone-mapped to SDR from the next frame "
"(%s; %s). The game is not told - it keeps rendering HDR; its own HDR setting and DXVK_HDR are "
"untouched", who, age >= 0 && age < 1500 ? "HDR frames were on screen" : "no HDR frames on screen just now");
- banner_request_redraw(); /* a paused game commits nothing: show the change now */
+ droiddeck_request_redraw(); /* a paused game commits nothing: show the change now */
}
static _Atomic int g_session_ended;
-void banner_color_session_end(void) {
+void droiddeck_color_session_end(void) {
if (atomic_exchange(&g_session_ended, 1)) return;
if (atomic_load(&g_gate) < 0) return;
pthread_mutex_lock(&g_mu);
@@ -692,7 +692,7 @@ void banner_color_session_end(void) {
struct cm_desc {
int refs; /* protocol objects + surfaces (pending / current) */
- struct banner_color c;
+ struct droiddeck_color c;
/* Set on the output / preferred descriptions the compositor serves (never on one a game built
* from parameters): get_information is answered rather than refused, with these as the target. */
int informative;
@@ -727,7 +727,7 @@ static void image_description_get_information(struct wl_client *c, struct wl_res
wl_resource_get_version(r), id);
if (!info) { wl_client_post_no_memory(c); return; }
wl_resource_set_implementation(info, NULL, NULL, NULL); /* events only */
- const struct banner_color *col = &d->c;
+ const struct droiddeck_color *col = &d->c;
int32_t xy[8] = { (int32_t)(col->red[0] * 1e6f + 0.5f), (int32_t)(col->red[1] * 1e6f + 0.5f),
(int32_t)(col->green[0] * 1e6f + 0.5f), (int32_t)(col->green[1] * 1e6f + 0.5f),
(int32_t)(col->blue[0] * 1e6f + 0.5f), (int32_t)(col->blue[1] * 1e6f + 0.5f),
@@ -765,12 +765,12 @@ static void image_description_resource_destroy(struct wl_resource *r) {
static void make_output_description(struct wl_client *c, struct wl_resource *parent, uint32_t id, const char *what) {
struct cm_desc *d = calloc(1, sizeof(*d));
if (!d) { wl_client_post_no_memory(c); return; }
- struct banner_color *col = &d->c;
+ struct droiddeck_color *col = &d->c;
col->identity = g_next_identity++;
if (!g_next_identity) g_next_identity = 1;
col->primaries = WP_COLOR_MANAGER_V1_PRIMARIES_BT2020;
col->tf = WP_COLOR_MANAGER_V1_TRANSFER_FUNCTION_ST2084_PQ;
- col->dataspace = BANNER_ADATASPACE_BT2020_PQ;
+ col->dataspace = DROIDDECK_ADATASPACE_BT2020_PQ;
col->has_st2086 = 1;
col->red[0] = 0.708f; col->red[1] = 0.292f; col->green[0] = 0.170f; col->green[1] = 0.797f;
col->blue[0] = 0.131f; col->blue[1] = 0.046f; col->white[0] = 0.3127f; col->white[1] = 0.3290f;
@@ -788,8 +788,8 @@ static void make_output_description(struct wl_client *c, struct wl_resource *par
d->refs = 1;
wl_resource_set_implementation(r, &image_description_impl, d, image_description_resource_destroy);
wp_image_description_v1_send_ready(r, col->identity);
- banner_log(TAG, "%s asked for %s: answered the display's HDR10 volume (%s), ready and open to get_information",
- banner_client_name(c), what, col->text);
+ droiddeck_log(TAG, "%s asked for %s: answered the display's HDR10 volume (%s), ready and open to get_information",
+ droiddeck_client_name(c), what, col->text);
}
static void params_create(struct wl_client *client, struct wl_resource *r, uint32_t id) {
@@ -801,15 +801,15 @@ static void params_create(struct wl_client *client, struct wl_resource *r, uint3
}
struct cm_desc *d = calloc(1, sizeof(*d));
if (!d) { wl_client_post_no_memory(client); return; }
- struct banner_color *c = &d->c;
+ struct droiddeck_color *c = &d->c;
c->identity = g_next_identity++;
if (!g_next_identity) g_next_identity = 1;
c->primaries = p->primaries;
c->tf = p->tf;
if (p->primaries == WP_COLOR_MANAGER_V1_PRIMARIES_BT2020 && p->tf == WP_COLOR_MANAGER_V1_TRANSFER_FUNCTION_ST2084_PQ)
- c->dataspace = BANNER_ADATASPACE_BT2020_PQ;
+ c->dataspace = DROIDDECK_ADATASPACE_BT2020_PQ;
else if (p->primaries == WP_COLOR_MANAGER_V1_PRIMARIES_BT2020 && p->tf == WP_COLOR_MANAGER_V1_TRANSFER_FUNCTION_HLG)
- c->dataspace = BANNER_ADATASPACE_BT2020_HLG;
+ c->dataspace = DROIDDECK_ADATASPACE_BT2020_HLG;
/* HDR metadata, kept only when it makes sense. The PQ defaults stand in for what was not given
* (0.005 - 10000 cd/m², the target volume = the primary one); CTA-861.3 treats 0 as unknown. */
@@ -870,12 +870,12 @@ static void params_create(struct wl_client *client, struct wl_resource *r, uint3
g_hdr.descs++;
pthread_mutex_unlock(&g_mu);
}
- banner_log(TAG, "image description #%u from %s: %s -> ready (on a display layer: dataspace %s)", c->identity,
- banner_client_name(client), c->text, dataspace_name(c->dataspace));
+ droiddeck_log(TAG, "image description #%u from %s: %s -> ready (on a display layer: dataspace %s)", c->identity,
+ droiddeck_client_name(client), c->text, dataspace_name(c->dataspace));
if (dropped[0]) {
size_t l = strlen(dropped);
if (l && dropped[l - 1] == ',') dropped[l - 1] = 0;
- banner_log(TAG, "image description #%u: dropped HDR metadata that breaks the protocol's rules:%s "
+ droiddeck_log(TAG, "image description #%u: dropped HDR metadata that breaks the protocol's rules:%s "
"(Android gets the rest)", c->identity, dropped);
}
wl_resource_destroy(r); /* create is the creator's destructor */
@@ -982,7 +982,7 @@ static struct cm_surf *surf_of(struct wl_resource *surface) {
static void describe_surface(struct wl_resource *surface, char *out, size_t size) {
struct surface *s = surface ? wl_resource_get_user_data(surface) : NULL;
- if (s) banner_surface_describe(s, out, size);
+ if (s) droiddeck_surface_describe(s, out, size);
else snprintf(out, size, "a closed window");
}
@@ -1002,8 +1002,8 @@ static void cm_surface_set_image_description(struct wl_client *c, struct wl_reso
struct cm_surf *cs = wl_resource_get_user_data(r);
struct cm_desc *d = desc_res ? wl_resource_get_user_data(desc_res) : NULL;
if (!cs) {
- banner_log(TAG, "%s set an image description on a colour-management object whose surface is gone: ignored",
- banner_client_name(c));
+ droiddeck_log(TAG, "%s set an image description on a colour-management object whose surface is gone: ignored",
+ droiddeck_client_name(c));
return;
}
if (!d) {
@@ -1045,7 +1045,7 @@ static void cm_surface_resource_destroy(struct wl_resource *r) {
cs->pending_dirty = 1;
}
-void banner_color_commit(struct wl_resource *surface) {
+void droiddeck_color_commit(struct wl_resource *surface) {
if (atomic_load(&g_gate) != 1) return;
struct cm_surf *cs = surf_of(surface);
if (!cs || !cs->pending_dirty) return;
@@ -1056,7 +1056,7 @@ void banner_color_commit(struct wl_resource *surface) {
char who[160];
describe_surface(surface, who, sizeof(who));
if (cs->current) {
- banner_log(TAG, "%s: image description #%u now applies to its frames (%s; perceptual intent)", who,
+ droiddeck_log(TAG, "%s: image description #%u now applies to its frames (%s; perceptual intent)", who,
cs->current->c.identity, cs->current->c.text);
if (cs->current->c.dataspace) {
pthread_mutex_lock(&g_mu);
@@ -1064,16 +1064,16 @@ void banner_color_commit(struct wl_resource *surface) {
snprintf(g_hdr.applied_who, sizeof(g_hdr.applied_who), "%s", who);
pthread_mutex_unlock(&g_mu);
if (!g_zero_copy)
- banner_log(TAG, "%s: zero-copy presentation is OFF, so its HDR frames are composed into the HDR picture "
+ droiddeck_log(TAG, "%s: zero-copy presentation is OFF, so its HDR frames are composed into the HDR picture "
"(one extra pass per frame) - switch Zero-copy presentation on for the direct path", who);
}
} else if (old) {
- banner_log(TAG, "%s: image description #%u removed - its frames are sRGB again", who, old->c.identity);
+ droiddeck_log(TAG, "%s: image description #%u removed - its frames are sRGB again", who, old->c.identity);
}
desc_unref(old);
}
-const struct banner_color *banner_color_of(struct wl_resource *surface) {
+const struct droiddeck_color *droiddeck_color_of(struct wl_resource *surface) {
if (atomic_load(&g_gate) != 1) return NULL;
struct cm_surf *cs = surf_of(surface);
return cs && cs->current ? &cs->current->c : NULL;
@@ -1125,14 +1125,14 @@ static void cm_get_surface(struct wl_client *c, struct wl_resource *r, uint32_t
describe_surface(surface, who, sizeof(who));
if (cs->owner) {
/* The protocol says surface_exists; a game would be disconnected for it. The newer object wins. */
- banner_log(TAG, "%s: a second colour-management object for the same surface - the newer one takes over "
+ droiddeck_log(TAG, "%s: a second colour-management object for the same surface - the newer one takes over "
"(protocol error surface_exists not raised)", who);
wl_resource_set_user_data(cs->owner, NULL);
}
cs->owner = o;
wl_resource_set_implementation(o, &cm_surface_impl, cs, cm_surface_resource_destroy);
- banner_log(TAG, "%s: colour-management surface created by %s (its Vulkan swapchain asks for a colour space "
- "other than sRGB)", who, banner_client_name(c));
+ droiddeck_log(TAG, "%s: colour-management surface created by %s (its Vulkan swapchain asks for a colour space "
+ "other than sRGB)", who, droiddeck_client_name(c));
}
static void cm_get_surface_feedback(struct wl_client *c, struct wl_resource *r, uint32_t id, struct wl_resource *surface) {
@@ -1186,16 +1186,16 @@ static void bind_cm(struct wl_client *c, void *data, uint32_t ver, uint32_t id)
/* One line per program: Mesa binds again for every surface-format query. */
if (last_named != c) {
last_named = c;
- banner_log(TAG, "%s bound wp_color_manager_v1 version %u (offered: perceptual intent; parametric descriptions "
+ droiddeck_log(TAG, "%s bound wp_color_manager_v1 version %u (offered: perceptual intent; parametric descriptions "
"with mastering metadata; BT.2020 primaries; ST 2084 PQ) - its Vulkan driver can now list "
- "VK_COLOR_SPACE_HDR10_ST2084_EXT", banner_client_name(c), ver > 1 ? 1u : ver);
+ "VK_COLOR_SPACE_HDR10_ST2084_EXT", droiddeck_client_name(c), ver > 1 ? 1u : ver);
}
}
-void banner_color_client_gone(struct wl_client *client) {
+void droiddeck_color_client_gone(struct wl_client *client) {
if (atomic_load(&g_gate) != 1 || atomic_load(&g_session_ended)) return;
/* A program that presented HDR has left: say where the session stands now, while it is fresh. */
- const char *name = banner_client_name(client);
+ const char *name = droiddeck_client_name(client);
int mine;
pthread_mutex_lock(&g_mu);
mine = g_hdr.applied_who[0] && name && strstr(g_hdr.applied_who, name) != NULL;
@@ -1205,7 +1205,7 @@ void banner_color_client_gone(struct wl_client *client) {
/* ---------------------------------------------------------------- the gate */
-void banner_color_init(struct wl_display *display) {
+void droiddeck_color_init(struct wl_display *display) {
char why[320] = "";
int mode, dxvk_hdr, zc_forced, known, hdr10, id, ratio_avail, api;
char name[96], formats[96], source[64];
@@ -1229,14 +1229,14 @@ void banner_color_init(struct wl_display *display) {
/* What asked for HDR, in the words the user knows it by: the editors' setting, or the env override. */
char asked[128];
- if (mode == 2) snprintf(asked, sizeof(asked), "BANNER_WAYLAND_HDR=force (%s)", source);
- else if (strstr(source, "env")) snprintf(asked, sizeof(asked), "BANNER_WAYLAND_HDR=1 (%s)", source);
+ if (mode == 2) snprintf(asked, sizeof(asked), "DROIDDECK_WAYLAND_HDR=force (%s)", source);
+ else if (strstr(source, "env")) snprintf(asked, sizeof(asked), "DROIDDECK_WAYLAND_HDR=1 (%s)", source);
else snprintf(asked, sizeof(asked), "HDR output is on (%s)", source);
int layer_ok = sc_layer_can_tag_hdr();
int ahb_ok = ahb_swapchain_advertised();
char off_why[128];
- if (strstr(source, "env")) snprintf(off_why, sizeof(off_why), "BANNER_WAYLAND_HDR=0 in the %s overrides the setting", source);
+ if (strstr(source, "env")) snprintf(off_why, sizeof(off_why), "DROIDDECK_WAYLAND_HDR=0 in the %s overrides the setting", source);
else snprintf(off_why, sizeof(off_why), "the HDR output setting is off");
if (mode == 0)
snprintf(why, sizeof(why), "HDR output is off (%s)", off_why);
@@ -1255,16 +1255,16 @@ void banner_color_init(struct wl_display *display) {
snprintf(g_gate_why, sizeof(g_gate_why), "%s", why);
atomic_store(&g_gate, 0);
if (mode) {
- banner_log(TAG, "HDR gate CLOSED: %s. Nothing is advertised (no wp_color_manager_v1, no 10-bit dma-buf "
+ droiddeck_log(TAG, "HDR gate CLOSED: %s. Nothing is advertised (no wp_color_manager_v1, no 10-bit dma-buf "
"formats): games see an SDR display, exactly as without the switch", why);
if (dxvk_hdr)
- banner_log(TAG, "DXVK_HDR=1 is set: DXGI will still claim an HDR display that no swapchain can get here "
+ droiddeck_log(TAG, "DXVK_HDR=1 is set: DXGI will still claim an HDR display that no swapchain can get here "
"(games that check fall back to SDR; some show washed-out colours) - remove it on this display");
log_verdict(1);
} else if (dxvk_hdr || (known && hdr10)) {
/* Off, and silent unless it is worth a line: a display that could show HDR10, or a DXVK
* switch that promises games an HDR display they cannot get. */
- banner_log(TAG, "HDR output off for this session (%s)%s%s", off_why,
+ droiddeck_log(TAG, "HDR output off for this session (%s)%s%s", off_why,
(known && hdr10) ? " - this display lists HDR10, so switching HDR output on for this game would "
"offer it to games" : "",
dxvk_hdr ? " - but DXVK_HDR=1 is set, so DXGI claims an HDR display the game cannot get a "
@@ -1276,25 +1276,25 @@ void banner_color_init(struct wl_display *display) {
if (!wl_global_create(display, &wp_color_manager_v1_interface, 1, NULL, bind_cm)) {
snprintf(g_gate_why, sizeof(g_gate_why), "creating the wp_color_manager_v1 global failed");
atomic_store(&g_gate, 0);
- banner_log("error", "color: wp_color_manager_v1 global creation failed - HDR gate closed");
+ droiddeck_log("error", "color: wp_color_manager_v1 global creation failed - HDR gate closed");
log_verdict(1);
return;
}
atomic_store(&g_gate, 1);
char syms[160];
sc_layer_hdr_symbols(syms, sizeof(syms));
- banner_log(TAG, "HDR gate %s: %s and %s. Offering games HDR10: wp_color_manager_v1 version 1 (BT.2020 primaries "
+ droiddeck_log(TAG, "HDR gate %s: %s and %s. Offering games HDR10: wp_color_manager_v1 version 1 (BT.2020 primaries "
"+ ST 2084 PQ, parametric descriptions with mastering metadata) and 10-bit AB30/XB30 dma-buf formats; HDR "
"frames go on the game's own display layer as BT2020_PQ (%s)",
mode == 2 ? "FORCED OPEN (testing)" : "OPEN", asked, disp, syms);
if (mode == 2 && !hdr10)
- banner_log(TAG, "BANNER_WAYLAND_HDR=force on a display without HDR10 - testing only: SurfaceFlinger will tone-map "
+ droiddeck_log(TAG, "DROIDDECK_WAYLAND_HDR=force on a display without HDR10 - testing only: SurfaceFlinger will tone-map "
"the game layer for this panel (expect GPU/CLIENT composition for it), nothing looks HDR");
if (zc_forced)
- banner_log(TAG, "zero-copy presentation turned on for this session: the HDR game's own 10-bit frames go straight "
+ droiddeck_log(TAG, "zero-copy presentation turned on for this session: the HDR game's own 10-bit frames go straight "
"to its display layer (the best path; anything that needs the compositor gets the composed HDR picture)");
if (!dxvk_hdr)
- banner_log(TAG, "DXVK_HDR=1 is not in the game's environment: DXVK games will not see an HDR display in DXGI "
+ droiddeck_log(TAG, "DXVK_HDR=1 is not in the game's environment: DXVK games will not see an HDR display in DXGI "
"(dxgi.enableHDR in a dxvk.conf does the same) - add DXVK_HDR=1 to the container's or shortcut's "
"environment variables");
(void)max_avg; (void)min_lum;
diff --git a/app/src/main/cpp/waylandcomp/src/wl_dmabuf.c b/app/src/main/cpp/waylandcomp/src/wl_dmabuf.c
index bdda9d75ef..2f8552f1ed 100644
--- a/app/src/main/cpp/waylandcomp/src/wl_dmabuf.c
+++ b/app/src/main/cpp/waylandcomp/src/wl_dmabuf.c
@@ -16,8 +16,8 @@
#include "linux-dmabuf-v1-server-protocol.h"
#include "vk_present.h"
-#include "banner_ext.h"
-#include "banner_color.h"
+#include "droiddeck_ext.h"
+#include "droiddeck_color.h"
#include "compositor_internal.h"
/* ------------------------------------------------------------ zwp_linux_dmabuf_v1 */
@@ -112,7 +112,7 @@ static const struct zwp_linux_dmabuf_v1_interface dmabuf_impl = {
/* The advertised format/modifier table, built at the first bind from what the renderer's driver
* can import (vkp_dmabuf_modifiers). INVALID is always offered too (Mesa drops it; other clients
* may use it for the implicit path). Without a renderer the list is LINEAR + INVALID, as before. */
-/* The last two rows are HDR10's (banner_color.h): A2B10G10R10 as AB30 (alpha) + XB30 (opaque) - Mesa
+/* The last two rows are HDR10's (droiddeck_color.h): A2B10G10R10 as AB30 (alpha) + XB30 (opaque) - Mesa
* lists a VkFormat only when both are advertised, and it is the one 10-bit layout our zero-copy WSI
* can put in a gralloc buffer (AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM). They are advertised ONLY
* while the HDR gate is open, and after the 8-bit rows, so every other session - and every client that
@@ -132,7 +132,7 @@ static void dmabuf_build_formats(void) {
char line[320];
int pos = 0, compressed = 0;
g_dmabuf_fmts_ready = 1;
- g_dmabuf_nfmt = banner_color_hdr_open() ? DMABUF_NFMT_MAX : DMABUF_NFMT_SDR;
+ g_dmabuf_nfmt = droiddeck_color_hdr_open() ? DMABUF_NFMT_MAX : DMABUF_NFMT_SDR;
for (int f = 0; f < g_dmabuf_nfmt; f++) {
uint64_t got[DMABUF_NMOD];
int n = vkp_dmabuf_modifiers(g_dmabuf_fmts[f].fmt, got, DMABUF_NMOD), k = 0;
@@ -155,10 +155,10 @@ static void dmabuf_build_formats(void) {
vkp_modifier_name(g_dmabuf_fmts[f].mods[i]));
if (pos >= (int)sizeof(line)) pos = (int)sizeof(line) - 1;
}
- banner_log("dmabuf", "formats: %s%s", line,
- !g_ubwc ? " (BANNER_WAYLAND_UBWC=0: qcom_compressed not advertised)" : "");
+ droiddeck_log("dmabuf", "formats: %s%s", line,
+ !g_ubwc ? " (DROIDDECK_WAYLAND_UBWC=0: qcom_compressed not advertised)" : "");
if (g_ubwc && !compressed)
- banner_log("dmabuf", "the compositor's driver (%s) reports no importable qcom_compressed layout: "
+ droiddeck_log("dmabuf", "the compositor's driver (%s) reports no importable qcom_compressed layout: "
"game swapchains stay linear", vkp_gpu_name());
if (g_dmabuf_nfmt > DMABUF_NFMT_SDR) {
/* The rows above always carry LINEAR; say what the compositor's own driver can really import
@@ -166,7 +166,7 @@ static void dmabuf_build_formats(void) {
uint64_t got[DMABUF_NMOD];
int n = vkp_dmabuf_modifiers(DRM_XBGR2101010, got, DMABUF_NMOD), ubwc10 = 0;
for (int i = 0; i < n; i++) if (got[i] == VKP_MOD_QCOM_COMPRESSED) ubwc10 = 1;
- banner_log("color", "10-bit dma-buf formats AB30/XB30 advertised for HDR10; the compositor's driver (%s) "
+ droiddeck_log("color", "10-bit dma-buf formats AB30/XB30 advertised for HDR10; the compositor's driver (%s) "
"imports XB30 %s", vkp_gpu_name(),
n == 0 ? "with no layout it reports (copy path unlikely; display layer only)"
: ubwc10 ? "linear and UBWC" : "linear only (UBWC 10-bit frames: display layer only)");
@@ -237,7 +237,7 @@ static void dmabuf_build_feedback(void) {
}
if (!n) return;
- int fd = (int)syscall(__NR_memfd_create, "banner-dmabuf-formats",
+ int fd = (int)syscall(__NR_memfd_create, "droiddeck-dmabuf-formats",
MFD_CLOEXEC | MFD_ALLOW_SEALING);
if (fd < 0) { WLOGE("dmabuf feedback: memfd_create failed (%s)", strerror(errno)); return; }
size_t size = (size_t)n * sizeof(entries[0]);
@@ -251,14 +251,14 @@ static void dmabuf_build_feedback(void) {
g_fmt_table_fd = fd;
g_fmt_table_size = size;
g_fmt_table_n = (uint16_t)n;
- banner_log("dmabuf", "feedback ready: %d format/modifier pairs, main device %u:%u",
+ droiddeck_log("dmabuf", "feedback ready: %d format/modifier pairs, main device %u:%u",
n, (unsigned)major(g_main_device), (unsigned)minor(g_main_device));
/* Vulkan games never need the node. Mesa's EGL did until Wayland layer versionCode 9: without
* one it fell back to a software path that draws nothing here (black window, sound plays). */
if (!g_main_device)
- banner_log("dmabuf", "%s: OpenGL games need Wayland layer versionCode 9 or newer, "
+ droiddeck_log("dmabuf", "%s: OpenGL games need Wayland layer versionCode 9 or newer, "
"which runs OpenGL on the GPU without a DRM node; older layers show a black window",
- g_no_render_node ? "no DRM device named (forced by BANNER_WAYLAND_NO_RENDER_NODE=1)"
+ g_no_render_node ? "no DRM device named (forced by DROIDDECK_WAYLAND_NO_RENDER_NODE=1)"
: "this device gives apps no display (DRM) device (/dev/dri)");
}
diff --git a/app/src/main/cpp/waylandcomp/src/wl_text_input.c b/app/src/main/cpp/waylandcomp/src/wl_text_input.c
index 1c424c83ce..631167e916 100644
--- a/app/src/main/cpp/waylandcomp/src/wl_text_input.c
+++ b/app/src/main/cpp/waylandcomp/src/wl_text_input.c
@@ -5,7 +5,7 @@
* Focus model. winewayland enables its text input as soon as our `enter` names a surface and
* routes every IME update to that surface's window - inside that window's process (the update
* list is per process). Keyboard focus in this compositor sits on the desktop surface (the
- * desktop owner's process), so text input can't follow it; it follows banner_ime_target():
+ * desktop owner's process), so text input can't follow it; it follows droiddeck_ime_target():
* the program window last clicked, else the topmost program window. Clicking into notepad
* moves the text-input focus to notepad's process, which is where the edit control lives.
*
@@ -13,7 +13,7 @@
* them (enable resets the state as the protocol says). We answer with `done(serial)` only when
* we sent events (preedit/commit strings), never for every commit.
*
- * Host side. banner_on_text_input(enabled, program, cursor rect in scene pixels) tells the app
+ * Host side. droiddeck_on_text_input(enabled, program, cursor rect in scene pixels) tells the app
* when a program starts/stops accepting IME text or moves its caret (Wine reports the rect only
* when an edit control positions its IME composition window, via ImmSetCompositionWindow).
* Typed text arrives through text_input_host_*: preedit_string / commit_string + done.
@@ -23,7 +23,7 @@
#define _GNU_SOURCE 1
#include
#include
-#include "banner_ext.h"
+#include "droiddeck_ext.h"
#include "text-input-unstable-v3-server-protocol.h"
#ifndef KEY_BACKSPACE
@@ -58,7 +58,7 @@ static struct wl_resource *g_target; /* surface text input is focused
static int g_told_enabled, g_told_rect[4];
static struct text_input *g_told_ti;
-static const char *ti_program(struct text_input *ti) { return banner_client_name(ti->client); }
+static const char *ti_program(struct text_input *ti) { return droiddeck_client_name(ti->client); }
/* The enabled text input focused on the current target, if any. */
static struct text_input *active_input(void) {
@@ -74,22 +74,22 @@ static void tell_app(void) {
int enabled = ti != NULL, rect[4] = {0, 0, 0, 0};
if (ti) {
int ox = 0, oy = 0;
- banner_surface_scene_origin(ti->entered, &ox, &oy);
+ droiddeck_surface_scene_origin(ti->entered, &ox, &oy);
rect[0] = ti->rect[0] + ox; rect[1] = ti->rect[1] + oy;
rect[2] = ti->rect[2]; rect[3] = ti->rect[3];
}
if (enabled == g_told_enabled && ti == g_told_ti && !memcmp(rect, g_told_rect, sizeof(rect))) return;
if (enabled && (!g_told_enabled || ti != g_told_ti))
- banner_log("text-input", "text input enabled by %s (cursor rect %d,%d %dx%d)", ti_program(ti),
+ droiddeck_log("text-input", "text input enabled by %s (cursor rect %d,%d %dx%d)", ti_program(ti),
rect[0], rect[1], rect[2], rect[3]);
else if (enabled)
- banner_log("text-input", "cursor rect from %s: %d,%d %dx%d", ti_program(ti), rect[0], rect[1], rect[2], rect[3]);
+ droiddeck_log("text-input", "cursor rect from %s: %d,%d %dx%d", ti_program(ti), rect[0], rect[1], rect[2], rect[3]);
else
- banner_log("text-input", "text input disabled%s%s", g_told_ti ? " by " : "", g_told_ti ? ti_program(g_told_ti) : "");
+ droiddeck_log("text-input", "text input disabled%s%s", g_told_ti ? " by " : "", g_told_ti ? ti_program(g_told_ti) : "");
g_told_enabled = enabled;
g_told_ti = ti;
memcpy(g_told_rect, rect, sizeof(rect));
- banner_on_text_input(enabled, enabled ? ti_program(ti) : "", rect[0], rect[1], rect[2], rect[3]);
+ droiddeck_on_text_input(enabled, enabled ? ti_program(ti) : "", rect[0], rect[1], rect[2], rect[3]);
}
/* ------------------------------------------------------------------ focus */
@@ -102,8 +102,8 @@ static void send_leave(struct text_input *ti) {
ti->has_preedit = 0;
}
-void banner_text_input_refocus(void) {
- struct wl_resource *t = banner_ime_target();
+void droiddeck_text_input_refocus(void) {
+ struct wl_resource *t = droiddeck_ime_target();
struct text_input *ti;
if (t == g_target) return;
wl_list_for_each(ti, &g_inputs, link)
@@ -121,7 +121,7 @@ void banner_text_input_refocus(void) {
wl_display_flush_clients(g_disp);
}
-void banner_text_input_surface_gone(struct wl_resource *surface) {
+void droiddeck_text_input_surface_gone(struct wl_resource *surface) {
struct text_input *ti;
wl_list_for_each(ti, &g_inputs, link)
if (ti->entered == surface) { ti->entered = NULL; ti->enabled = 0; ti->has_preedit = 0; }
@@ -136,7 +136,7 @@ static void ti_res_destroy(struct wl_resource *r) {
if (!ti) return;
wl_list_remove(&ti->link);
if (g_told_ti == ti) { g_told_ti = NULL; g_told_enabled = 0; memset(g_told_rect, 0, sizeof(g_told_rect));
- banner_on_text_input(0, "", 0, 0, 0, 0); }
+ droiddeck_on_text_input(0, "", 0, 0, 0, 0); }
free(ti);
}
@@ -235,13 +235,13 @@ static int32_t utf8_offset(const char *s, size_t len, int chars) {
void text_input_host_commit(const char *utf8, size_t len) {
struct text_input *ti = active_input();
if (!ti) {
- banner_log("text-input", "typed text (%zu chars) dropped: no program accepts text input", utf8_chars(utf8, len));
+ droiddeck_log("text-input", "typed text (%zu chars) dropped: no program accepts text input", utf8_chars(utf8, len));
return;
}
if (ti->has_preedit) { zwp_text_input_v3_send_preedit_string(ti->res, "", 0, 0); ti->has_preedit = 0; }
zwp_text_input_v3_send_commit_string(ti->res, utf8);
zwp_text_input_v3_send_done(ti->res, ti->serial);
- banner_log("text-input", "committed %zu chars to %s", utf8_chars(utf8, len), ti_program(ti));
+ droiddeck_log("text-input", "committed %zu chars to %s", utf8_chars(utf8, len), ti_program(ti));
}
void text_input_host_preedit(const char *utf8, size_t len, int cursor_begin, int cursor_end) {
@@ -264,9 +264,9 @@ void text_input_host_delete(int before, int after) {
zwp_text_input_v3_send_done(ti->res, ti->serial);
ti->has_preedit = 0;
}
- for (int i = 0; i < before; i++) { banner_inject_key(KEY_BACKSPACE, 1); banner_inject_key(KEY_BACKSPACE, 0); }
- for (int i = 0; i < after; i++) { banner_inject_key(KEY_DELETE, 1); banner_inject_key(KEY_DELETE, 0); }
- banner_log("text-input", "deleted %d before / %d after the caret (as key presses)", before, after);
+ for (int i = 0; i < before; i++) { droiddeck_inject_key(KEY_BACKSPACE, 1); droiddeck_inject_key(KEY_BACKSPACE, 0); }
+ for (int i = 0; i < after; i++) { droiddeck_inject_key(KEY_DELETE, 1); droiddeck_inject_key(KEY_DELETE, 0); }
+ droiddeck_log("text-input", "deleted %d before / %d after the caret (as key presses)", before, after);
}
void text_input_init(struct wl_display *display) {
diff --git a/app/src/main/cpp/waylandcomp/src/wl_toplevel_icon.c b/app/src/main/cpp/waylandcomp/src/wl_toplevel_icon.c
index 17a9f59e08..ce1cd0e5fb 100644
--- a/app/src/main/cpp/waylandcomp/src/wl_toplevel_icon.c
+++ b/app/src/main/cpp/waylandcomp/src/wl_toplevel_icon.c
@@ -4,7 +4,7 @@
* missing. We send no icon_size (any size is fine) and `done` at bind, as the protocol asks.
*/
#include
-#include "banner_ext.h"
+#include "droiddeck_ext.h"
#include "xdg-toplevel-icon-v1-server-protocol.h"
static void icon_destroy(struct wl_client *c, struct wl_resource *r) { wl_resource_destroy(r); }
diff --git a/app/src/main/java/com/droiddeck/launcher/ComponentsMenu.kt b/app/src/main/java/com/droiddeck/launcher/ComponentsMenu.kt
index 87c3f27906..5857101eae 100644
--- a/app/src/main/java/com/droiddeck/launcher/ComponentsMenu.kt
+++ b/app/src/main/java/com/droiddeck/launcher/ComponentsMenu.kt
@@ -6,6 +6,7 @@ import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import com.droiddeck.launcher.session.ComponentsManager
+import com.droiddeck.launcher.session.ProtonDefault
/**
* The Components page's state and work: the Protons and their DXVK/VKD3D sets, the Nightlies
@@ -20,6 +21,7 @@ internal class ComponentsMenu(private val activity: android.app.Activity, privat
var compChecking by mutableStateOf(false)
var compBusy by mutableStateOf(null)
var compDownloads by mutableStateOf