Expose socket interruption

On Linux, socket functions are unblocked by shutdown(), but on Windows they are unblocked by closesocket(). Expose net_interrupt() and net_close() to abstract these differences: - net_interrupt() calls shutdown() on Linux and closesocket() on Windows (if not already called); - net_close() calls close() on Linux and closesocket() on Windows (if not already called). This simplifies the server code, and prevents a data race on close (reported by TSAN) on Linux (but does not fix it on Windows): WARNING: ThreadSanitizer: data race (pid=836124) Write of size 8 at 0x7ba0000000d0 by main thread: #0 close ../../../../src/libsanitizer/tsan/tsan_interceptors_posix.cpp:1690 (libtsan.so.0+0x359d8) #1 net_close ../app/src/util/net.c:211 (scrcpy+0x1c76b) #2 close_socket ../app/src/server.c:330 (scrcpy+0x19442) #3 server_stop ../app/src/server.c:522 (scrcpy+0x19e33) #4 scrcpy ../app/src/scrcpy.c:532 (scrcpy+0x156fc) #5 main ../app/src/main.c:92 (scrcpy+0x622a) Previous read of size 8 at 0x7ba0000000d0 by thread T6: #0 recv ../../../../src/libsanitizer/sanitizer_common/sanitizer_common_interceptors.inc:6603 (libtsan.so.0+0x4f4a6) #1 net_recv ../app/src/util/net.c:167 (scrcpy+0x1c5a7) #2 run_receiver ../app/src/receiver.c:76 (scrcpy+0x12819) #3 <null> <null> (libSDL2-2.0.so.0+0x84f40)
2021-10-26 23:01:51 +02:00
121 changed files with 2528 additions and 6362 deletions
--- a/BUILD.md
+++ b/BUILD.md
@ -270,10 +270,10 @@ install` must be run as root)._

 #### Option 2: Use prebuilt server

- - [`scrcpy-server-v1.20`][direct-scrcpy-server]  
-   _(SHA-256: b20aee4951f99b060c4a44000ba94de973f9604758ef62beb253b371aad3df34)_
+ - [`scrcpy-server-v1.19`][direct-scrcpy-server]  
+   _(SHA-256: 876f9322182e6aac6a58db1334f4225855ef3a17eaebc80aab6601d9d1ecb867)_

-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.20/scrcpy-server-v1.20
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.19/scrcpy-server-v1.19

 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
--- a/FAQ.it.md
+++ b/FAQ.it.md
@ -140,24 +140,6 @@ Potresti anche dover configurare il [comportamento di ridimensionamento][scaling
 [scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723


-### Problema con Wayland
-
-Per impostazione predefinita, SDL utilizza x11 su Linux. Il [video driver] può essere cambiato attraversio la variabile d'ambiente `SDL_VIDEODRIVER`:
-
-[video driver]: https://wiki.libsdl.org/FAQUsingSDL#how_do_i_choose_a_specific_video_driver
-
-```bash
-export SDL_VIDEODRIVER=wayland
-scrcpy
-```
-
-Su alcune distribuzioni (almeno Fedora), il pacchetto `libdecor` deve essere installato manualmente.
-
-Vedi le issues [#2554] e [#2559].
-
-[#2554]: https://github.com/Genymobile/scrcpy/issues/2554
-[#2559]: https://github.com/Genymobile/scrcpy/issues/2559
-

 ### Crash del compositore KWin

--- a/FAQ.md
+++ b/FAQ.md
@ -222,27 +222,6 @@ scrcpy -m 800
 You could also try another [encoder](README.md#encoder).


-If you encounter this exception on Android 12, then just upgrade to scrcpy >=
-1.18 (see [#2129]):
-
-```
-> ERROR: Exception on thread Thread[main,5,main]
-java.lang.AssertionError: java.lang.reflect.InvocationTargetException
-    at com.genymobile.scrcpy.wrappers.SurfaceControl.setDisplaySurface(SurfaceControl.java:75)
-    ...
-Caused by: java.lang.reflect.InvocationTargetException
-    at java.lang.reflect.Method.invoke(Native Method)
-    at com.genymobile.scrcpy.wrappers.SurfaceControl.setDisplaySurface(SurfaceControl.java:73)
-    ... 7 more
-Caused by: java.lang.IllegalArgumentException: displayToken must not be null
-    at android.view.SurfaceControl$Transaction.setDisplaySurface(SurfaceControl.java:3067)
-    at android.view.SurfaceControl.setDisplaySurface(SurfaceControl.java:2147)
-    ... 9 more
-```
-
-[#2129]: https://github.com/Genymobile/scrcpy/issues/2129
-
-
 ## Command line on Windows

 Some Windows users are not familiar with the command line. Here is how to open a
@ -283,6 +262,6 @@ to add some arguments.

 This FAQ is available in other languages:

- - [Italiano (Italiano, `it`) - v1.19](FAQ.it.md)
+ - [Italiano (Italiano, `it`) - v1.17](FAQ.it.md)
 - [한국어 (Korean, `ko`) - v1.11](FAQ.ko.md)
 - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.18](FAQ.zh-Hans.md)
--- a/README.it.md
+++ b/README.it.md
@ -1,6 +1,6 @@
 _Apri il [README](README.md) originale e sempre aggiornato._

-# scrcpy (v1.19)
+# scrcpy (v1.17)

 Questa applicazione fornisce la visualizzazione e il controllo dei dispositivi Android collegati via USB (o [via TCP/IP][article-tcpip]). Non richiede alcun accesso _root_.
 Funziona su _GNU/Linux_, _Windows_ e _macOS_.
@ -205,11 +205,10 @@ Se anche `--max-size` è specificata, il ridimensionamento è applicato dopo il
 Per bloccare l'orientamento della trasmissione:

 ```bash
-scrcpy --lock-video-orientation     # orientamento iniziale (corrente)
-scrcpy --lock-video-orientation=0   # orientamento naturale
-scrcpy --lock-video-orientation=1   # 90° antiorario
-scrcpy --lock-video-orientation=2   # 180°
-scrcpy --lock-video-orientation=3   # 90° orario
+scrcpy --lock-video-orientation 0   # orientamento naturale
+scrcpy --lock-video-orientation 1   # 90° antiorario
+scrcpy --lock-video-orientation 2   # 180°
+scrcpy --lock-video-orientation 3   # 90° orario
 ```

 Questo influisce sull'orientamento della registrazione.
@ -232,9 +231,7 @@ Per elencare i codificatori disponibili puoi immettere un nome di codificatore n
 scrcpy --encoder _
 ```

-### Cattura
-
-#### Registrazione
+### Registrazione

 È possibile registrare lo schermo durante la trasmissione:

@ -256,75 +253,6 @@ I "fotogrammi saltati" sono registrati nonostante non siano mostrati in tempo re
 [packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation


-#### v4l2loopback
-
-Su Linux è possibile inviare il flusso video ad un dispositivo v4l2 loopback, cosicchè un dispositivo Android possa essere aperto come una webcam da qualsiasi strumento compatibile con v4l2.
-
-Il modulo `v4l2loopback` deve essere installato:
-
-```bash
-sudo apt install v4l2loopback-dkms
-```
-
-Per creare un dispositvo v4l2:
-
-```bash
-sudo modprobe v4l2loopback
-```
-
-Questo creerà un nuovo dispositivo video in `/dev/videoN` dove `N` è un intero (più [opzioni](https://github.com/umlaeute/v4l2loopback#options) sono disponibili per crere più dispositivi o dispositivi con ID specifici).
-
-Per elencare i dispositvi attivati:
-
-```bash
-# necessita del pacchetto v4l-utils
-v4l2-ctl --list-devices
-
-# semplice ma potrebbe essere sufficiente
-ls /dev/video*
-```
-
-Per avviare scrcpy utilizzando un v4l2 sink:
-
-```bash
-scrcpy --v4l2-sink=/dev/videoN
-scrcpy --v4l2-sink=/dev/videoN --no-display  # disabilita la finestra di trasmissione
-scrcpy --v4l2-sink=/dev/videoN -N            # versione corta
-```
-
-(sostituisci `N` con l'ID del dispositivo, controlla con `ls /dev/video*`)
-
-Una volta abilitato, puoi aprire il tuo flusso video con uno strumento compatibile con v4l2:
-
-```bash
-ffplay -i /dev/videoN
-vlc v4l2:///dev/videoN   # VLC potrebbe aggiungere del ritardo per il buffer
-```
-
-Per esempio potresti catturare il video in [OBS].
-
-[OBS]: https://obsproject.com/
-
-
-#### Buffering
-
-È possibile aggiungere del buffer. Questo aumenta la latenza ma riduce il jitter (vedi [#2464]).
-
-[#2464]: https://github.com/Genymobile/scrcpy/issues/2464
-
-L'opzione è disponibile per il buffer della visualizzazione:
-
-```bash
-scrcpy --display-buffer=50  # aggiungi 50 ms di buffer per la visualizzazione
-```
-
-e per il V4L2 sink:
-
-```bash
-scrcpy --v4l2-buffer=500    #  aggiungi 50 ms di buffer per il v4l2 sink
-```
-
-
 ### Connessione

 #### Wireless
@ -551,6 +479,15 @@ scrcpy --turn-screen-off --stay-awake
 scrcpy -Sw
 ```

+#### Renderizzare i fotogrammi scaduti
+
+Per minimizzare la latenza _scrcpy_ renderizza sempre l'ultimo fotogramma decodificato disponibile in maniera predefinita e tralascia quelli precedenti.
+
+Per forzare la renderizzazione di tutti i fotogrammi (a costo di una possibile latenza superiore), utilizzare:
+
+```bash
+scrcpy --render-expired-frames
+```

 #### Mostrare i tocchi

@ -670,14 +607,14 @@ Non c'è alcuna risposta visiva, un log è stampato nella console.

 #### Trasferimento di file verso il dispositivo

-Per trasferire un file in `/sdcard/Download` del dispositivo trascina e rilascia un file (non APK) nella finestra di _scrcpy_.
+Per trasferire un file in `/sdcard/` del dispositivo trascina e rilascia un file (non APK) nella finestra di _scrcpy_.

 Non c'è alcuna risposta visiva, un log è stampato nella console.

 La cartella di destinazione può essere cambiata all'avvio:

 ```bash
-scrcpy --push-target=/sdcard/Movies/
+scrcpy --push-target=/sdcard/Download/
 ```


@ -716,10 +653,10 @@ _<kbd>[Super]</kbd> è il pulsante <kbd>Windows</kbd> o <kbd>Cmd</kbd>._
 | Rotazione schermo a sinistra                         | <kbd>MOD</kbd>+<kbd>←</kbd> _(sinistra)_
 | Rotazione schermo a destra                        | <kbd>MOD</kbd>+<kbd>→</kbd> _(destra)_
 | Ridimensiona finestra a 1:1 (pixel-perfect)        | <kbd>MOD</kbd>+<kbd>g</kbd>
- | Ridimensiona la finestra per rimuovere i bordi neri       | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Doppio click sinistro¹_
+ | Ridimensiona la finestra per rimuovere i bordi neri       | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Doppio click¹_
 | Premi il tasto `HOME`                             | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Click centrale_
 | Premi il tasto `BACK`                             | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Click destro²_
- | Premi il tasto `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4° click³_
+ | Premi il tasto `APP_SWITCH`                       | <kbd>MOD</kbd>+<kbd>s</kbd>
 | Premi il tasto `MENU` (sblocca lo schermo)             | <kbd>MOD</kbd>+<kbd>m</kbd>
 | Premi il tasto `VOLUME_UP`                        | <kbd>MOD</kbd>+<kbd>↑</kbd> _(su)_
 | Premi il tasto `VOLUME_DOWN`                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(giù)_
@ -728,26 +665,18 @@ _<kbd>[Super]</kbd> è il pulsante <kbd>Windows</kbd> o <kbd>Cmd</kbd>._
 | Spegni lo schermo del dispositivo (continua a trasmettere)     | <kbd>MOD</kbd>+<kbd>o</kbd>
 | Accendi lo schermo del dispositivo                       | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
 | Ruota lo schermo del dispositivo                        | <kbd>MOD</kbd>+<kbd>r</kbd>
- | Espandi il pannello delle notifiche                   | <kbd>MOD</kbd>+<kbd>n</kbd> \| _5° click³_
- | Espandi il pannello delle impostazioni                   | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Doppio 5° click³_
- | Chiudi pannelli                 | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | Copia negli appunti⁴                          | <kbd>MOD</kbd>+<kbd>c</kbd>
- | Taglia negli appunti⁴                           | <kbd>MOD</kbd>+<kbd>x</kbd>
- | Sincronizza gli appunti e incolla⁴           | <kbd>MOD</kbd>+<kbd>v</kbd>
+ | Espandi il pannello delle notifiche                   | <kbd>MOD</kbd>+<kbd>n</kbd>
+ | Chiudi il pannello delle notifiche                 | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
+ | Copia negli appunti³                          | <kbd>MOD</kbd>+<kbd>c</kbd>
+ | Taglia negli appunti³                           | <kbd>MOD</kbd>+<kbd>x</kbd>
+ | Sincronizza gli appunti e incolla³           | <kbd>MOD</kbd>+<kbd>v</kbd>
 | Inietta il testo degli appunti del computer              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
 | Abilita/Disabilita il contatore FPS (su stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
 | Pizzica per zoomare                               | <kbd>Ctrl</kbd>+_click e trascina_

 _¹Doppio click sui bordi neri per rimuoverli._  
 _²Il tasto destro accende lo schermo se era spento, preme BACK in caso contrario._  
-_³4° e 5° pulsante del mouse, se il tuo mouse ne dispone._  
-_⁴Solo in Android >= 7._
-
-Le scorciatoie con pulsanti ripetuti sono eseguite rilasciando e premendo il pulsante una seconda volta. Per esempio, per eseguire "Espandi il pannello delle impostazioni":
-
-1. Premi e tieni premuto <kbd>MOD</kbd>.
-2. Poi premi due volte <kbd>n</kbd>.
-3. Infine rilascia <kbd>MOD</kbd>.
+_³Solo in Android >= 7._

 Tutte le scorciatoie <kbd>Ctrl</kbd>+_tasto_ sono inoltrate al dispositivo, così sono gestite dall'applicazione attiva.

--- a/README.jp.md
+++ b/README.jp.md
@ -1,6 +1,6 @@
 _Only the original [README](README.md) is guaranteed to be up-to-date._

-# scrcpy (v1.19)
+# scrcpy (v1.17)

 このアプリケーションはUSB(もしくは[TCP/IP経由][article-tcpip])で接続されたAndroidデバイスの表示と制御を提供します。このアプリケーションは _root_ でのアクセスを必要としません。このアプリケーションは _GNU/Linux_ 、 _Windows_ そして _macOS_ 上で動作します。

@ -103,22 +103,19 @@ scoop install adb    # まだ入手していない場合
 brew install scrcpy
 ```

-`PATH`からアクセス可能な`adb`が必要です。もし持っていない場合はインストールしてください。
+`PATH`から`adb`へのアクセスが必要です。もしまだ持っていない場合:

 ```bash
-brew install android-platform-tools
+# Homebrew >= 2.6.0
+brew install --cask android-platform-tools
+
+# Homebrew < 2.6.0
+brew cask install android-platform-tools
 ```

-`adb`は[MacPorts]からでもインストールできます。
-
-```bash
-sudo port install scrcpy
-```
-
-[MacPorts]: https://www.macports.org/
-
 また、[アプリケーションをビルド][BUILD]することも可能です。

+
 ## 実行

 Androidデバイスを接続し、実行:
@ -187,11 +184,10 @@ scrcpy --crop 1224:1440:0:0   # オフセット位置(0,0)で1224x1440
 ミラーリングの向きをロックするには:

 ```bash
-scrcpy --lock-video-orientation     # 現在の向き
-scrcpy --lock-video-orientation=0   # 自然な向き
-scrcpy --lock-video-orientation=1   # 90°反時計回り
-scrcpy --lock-video-orientation=2   # 180°
-scrcpy --lock-video-orientation=3   # 90°時計回り
+scrcpy --lock-video-orientation 0   # 自然な向き
+scrcpy --lock-video-orientation 1   # 90°反時計回り
+scrcpy --lock-video-orientation 2   # 180°
+scrcpy --lock-video-orientation 3   # 90°時計回り
 ```

 この設定は録画の向きに影響します。
@ -214,9 +210,7 @@ scrcpy --encoder OMX.qcom.video.encoder.avc
 scrcpy --encoder _
 ```

-### キャプチャ
-
-#### 録画
+### 録画

 ミラーリング中に画面の録画をすることが可能です:

@ -239,77 +233,6 @@ scrcpy -Nr file.mkv

 [パケット遅延のバリエーション]: https://en.wikipedia.org/wiki/Packet_delay_variation

-#### v4l2loopback
-
-Linuxでは、ビデオストリームをv4l2ループバックデバイスに送信することができます。
-v4l2loopbackのデバイスにビデオストリームを送信することで、Androidデバイスをウェブカメラのようにv4l2対応ツールで開くこともできます。
-
-`v4l2loopback` モジュールのインストールが必要です。
-
-```bash
-sudo apt install v4l2loopback-dkms
-```
-
-v4l2デバイスを作成する。
-
-```bash
-sudo modprobe v4l2loopback
-```
-
-これにより、新しいビデオデバイスが `/dev/videoN` に作成されます。（`N` は整数）
-(複数のデバイスや特定のIDのデバイスを作成するために、より多くの[オプション](https://github.com/umlaeute/v4l2loopback#options)が利用可能です。
-多くの[オプション]()が利用可能で複数のデバイスや特定のIDのデバイスを作成できます。
-
-
-有効なデバイスを一覧表示する:
-
-```bash
-# v4l-utilsパッケージが必要
-v4l2-ctl --list-devices
-
-# シンプルですが十分これで確認できます
-ls /dev/video*
-```
-
-v4l2シンクを使用してscrcpyを起動する。
-
-```bash
-scrcpy --v4l2-sink=/dev/videoN
-scrcpy --v4l2-sink=/dev/videoN --no-display  # ミラーリングウィンドウを無効化する
-scrcpy --v4l2-sink=/dev/videoN -N            # 短縮版
-```
-
-(`N` をデバイス ID に置き換えて、`ls /dev/video*` で確認してください)
-有効にすると、v4l2対応のツールでビデオストリームを開けます。
-
-```bash
-ffplay -i /dev/videoN
-vlc v4l2:///dev/videoN   # VLCではバッファリングの遅延が発生する場合があります
-```
-
-例えばですが [OBS]の中にこの映像を取り込めことができます。
-
-[OBS]: https://obsproject.com/
-
-
-#### Buffering
-
-バッファリングを追加することも可能です。これによりレイテンシーは増加しますが、ジッターは減少します。（参照
-[#2464])
-
-[#2464]: https://github.com/Genymobile/scrcpy/issues/2464
-
-このオプションでディスプレイバッファリングを設定できます。
-
-```bash
-scrcpy --display-buffer=50  # ディスプレイに50msのバッファリングを追加する
-```
-
-V4L2の場合はこちらのオプションで設定できます。
-
-```bash
-scrcpy --v4l2-buffer=500    # add 500 ms buffering for v4l2 sink
-```

 ### 接続

@ -534,6 +457,16 @@ scrcpy -Sw
 ```


+#### 期限切れフレームをレンダリングする
+
+初期状態では、待ち時間を最小限にするために、_scrcpy_ は最後にデコードされたフレームをレンダリングし、前のフレームを削除します。
+
+全フレームのレンダリングを強制するには(待ち時間が長くなる可能性があります):
+
+```bash
+scrcpy --render-expired-frames
+```
+
 #### タッチを表示

 プレゼンテーションの場合(物理デバイス上で)物理的なタッチを表示すると便利な場合があります。
@ -653,14 +586,14 @@ APKをインストールするには、(`.apk`で終わる)APKファイルを _s

 #### デバイスにファイルを送る

-デバイスの`/sdcard/Download`ディレクトリにファイルを送るには、(APKではない)ファイルを _scrcpy_ の画面にドラッグ&ドロップします。
+デバイスの`/sdcard/`ディレクトリにファイルを送るには、(APKではない)ファイルを _scrcpy_ の画面にドラッグ&ドロップします。

 見た目のフィードバックはありません。コンソールにログが出力されます。

 転送先ディレクトリを起動時に変更することができます:

 ```bash
-scrcpy --push-target=/sdcard/Movies/
+scrcpy --push-target /sdcard/foo/bar/
 ```


@ -701,7 +634,7 @@ _<kbd>[Super]</kbd>は通常<kbd>Windows</kbd>もしくは<kbd>Cmd</kbd>キー
 | ウィンドウサイズを変更して黒い境界線を削除      | <kbd>MOD</kbd>+<kbd>w</kbd> \| _ダブルクリック¹_
 | `HOME`をクリック                             | <kbd>MOD</kbd>+<kbd>h</kbd> \| _真ん中クリック_
 | `BACK`をクリック                             | <kbd>MOD</kbd>+<kbd>b</kbd> \| _右クリック²_
- | `APP_SWITCH`をクリック                       | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4クリック³_
+ | `APP_SWITCH`をクリック                       | <kbd>MOD</kbd>+<kbd>s</kbd>
 | `MENU` (画面のアンロック)をクリック            | <kbd>MOD</kbd>+<kbd>m</kbd>
 | `VOLUME_UP`をクリック                        | <kbd>MOD</kbd>+<kbd>↑</kbd> _(上)_
 | `VOLUME_DOWN`をクリック                      | <kbd>MOD</kbd>+<kbd>↓</kbd> _(下)_
@ -710,8 +643,7 @@ _<kbd>[Super]</kbd>は通常<kbd>Windows</kbd>もしくは<kbd>Cmd</kbd>キー
 | デバイス画面をオフにする(ミラーリングしたまま)  | <kbd>MOD</kbd>+<kbd>o</kbd>
 | デバイス画面をオンにする                      | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
 | デバイス画面を回転する                        | <kbd>MOD</kbd>+<kbd>r</kbd>
- | 通知パネルを展開する                          | <kbd>MOD</kbd>+<kbd>n</kbd> \| _5ボタンクリック³_
- | 設定パネルを展開する                          | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _5ダブルクリック³_
+ | 通知パネルを展開する                          | <kbd>MOD</kbd>+<kbd>n</kbd>
 | 通知パネルを折りたたむ                        | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
 | クリップボードへのコピー³                     | <kbd>MOD</kbd>+<kbd>c</kbd>
 | クリップボードへのカット³                     | <kbd>MOD</kbd>+<kbd>x</kbd>
@ -722,17 +654,11 @@ _<kbd>[Super]</kbd>は通常<kbd>Windows</kbd>もしくは<kbd>Cmd</kbd>キー

 _¹黒い境界線を削除するため、境界線上でダブルクリック_  
 _²もしスクリーンがオフの場合、右クリックでスクリーンをオンする。それ以外の場合はBackを押します._  
-_³4と5はマウスのボタンです、もしあなたのマウスにボタンがあれば使えます._  
-_⁴Android 7以上のみ._
-
-キーを繰り返すショートカットはキーを離して2回目を押したら実行されます。例えば「設定パネルを展開する」を実行する場合は以下のように操作する。
-
- 1. <kbd>MOD</kbd> キーを押し、押したままにする.
- 2. その後に <kbd>n</kbd>キーを2回押す.
- 3. 最後に <kbd>MOD</kbd>キーを離す.
+_³Android 7以上のみ._

 全ての<kbd>Ctrl</kbd>+_キー_ ショートカットはデバイスに転送されます、そのためアクティブなアプリケーションによって処理されます。

+
 ## カスタムパス

 特定の _adb_ バイナリを使用する場合、そのパスを環境変数`ADB`で構成します:
--- a/README.md
+++ b/README.md
@ -1,37 +1,26 @@
-# scrcpy (v1.20)
+# scrcpy (v1.19)

-<img src="data/icon.svg" width="128" height="128" alt="scrcpy" align="right" />
+![icon](data/icon.png)

 [Read in another language](#translations)

-This application provides display and control of Android devices connected via
-USB (or [over TCP/IP](#tcpip-wireless)). It does not require any _root_ access.
+This application provides display and control of Android devices connected on
+USB (or [over TCP/IP][article-tcpip]). It does not require any _root_ access.
 It works on _GNU/Linux_, _Windows_ and _macOS_.

 ![screenshot](assets/screenshot-debian-600.jpg)

 It focuses on:

- - **lightness**: native, displays only the device screen
- - **performance**: 30~120fps, depending on the device
- - **quality**: 1920×1080 or above
- - **low latency**: [35~70ms][lowlatency]
- - **low startup time**: ~1 second to display the first image
- - **non-intrusiveness**: nothing is left installed on the device
- - **user benefits**: no account, no ads, no internet required
- - **freedom**: free and open source software
+ - **lightness** (native, displays only the device screen)
+ - **performance** (30~60fps)
+ - **quality** (1920×1080 or above)
+ - **low latency** ([35~70ms][lowlatency])
+ - **low startup time** (~1 second to display the first image)
+ - **non-intrusiveness** (nothing is left installed on the device)

 [lowlatency]: https://github.com/Genymobile/scrcpy/pull/646

-Its features include:
- - [recording](#recording)
- - mirroring with [device screen off](#turn-screen-off)
- - [copy-paste](#copy-paste) in both directions
- - [configurable quality](#capture-configuration)
- - device screen [as a webcam (V4L2)](#v4l2loopback) (Linux-only)
- - [physical keyboard simulation (HID)](#physical-keyboard-simulation-hid)
-   (Linux-only)
- - and more…

 ## Requirements

@ -101,10 +90,10 @@ process][BUILD_simple]).
 For Windows, for simplicity, a prebuilt archive with all the dependencies
 (including `adb`) is available:

- - [`scrcpy-win64-v1.20.zip`][direct-win64]  
-   _(SHA-256: 548532b616288bcaeceff6881ad5e6f0928e5ae2b48c380385f03627401cfdba)_
+ - [`scrcpy-win64-v1.19.zip`][direct-win64]  
+   _(SHA-256: 383d6483f25ac0092d4bb9fef6c967351ecd50fc248e0c82932db97d6d32f11b)_

-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.20/scrcpy-win64-v1.20.zip
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.19/scrcpy-win64-v1.19.zip

 It is also available in [Chocolatey]:

@ -337,9 +326,7 @@ For example, you could capture the video within [OBS].
 #### Buffering

 It is possible to add buffering. This increases latency but reduces jitter (see
-[#2464]).
-
-[#2464]: https://github.com/Genymobile/scrcpy/issues/2464
+#2464).

 The option is available for display buffering:

@ -356,38 +343,10 @@ scrcpy --v4l2-buffer=500    # add 500 ms buffering for v4l2 sink

 ### Connection

-#### TCP/IP (wireless)
+#### Wireless

 _Scrcpy_ uses `adb` to communicate with the device, and `adb` can [connect] to a
-device over TCP/IP.
-
-##### Automatic
-
-An option `--tcpip` allows to configure the connection automatically. There are
-two variants.
-
-If the device (accessible at 192.168.1.1 in this example) already listens on a
-port (typically 5555) for incoming adb connections, then run:
-
-```bash
-scrcpy --tcpip=192.168.1.1       # default port is 5555
-scrcpy --tcpip=192.168.1.1:5555
-```
-
-If the device TCP/IP mode is disabled (or if you don't know the IP address),
-connect the device over USB, then run:
-
-```bash
-scrcpy --tcpip    # without arguments
-```
-
-It will automatically find the device IP address, enable TCP/IP mode, then
-connect to the device before starting.
-
-##### Manual
-
-Alternatively, it is possible to enable the TCP/IP connection manually using
-`adb`:
+device over TCP/IP:

 1. Connect the device to the same Wi-Fi as your computer.
 2. Get your device IP address, in Settings → About phone → Status, or by
@ -440,66 +399,21 @@ autoadb scrcpy -s '{}'

 [AutoAdb]: https://github.com/rom1v/autoadb

-#### Tunnels
+#### SSH tunnel

 To connect to a remote device, it is possible to connect a local `adb` client to
 a remote `adb` server (provided they use the same version of the _adb_
-protocol).
-
-##### Remote ADB server
-
-To connect to a remote ADB server, make the server listen on all interfaces:
+protocol):

 ```bash
-adb kill-server
-adb -a nodaemon server start
+adb kill-server    # kill the local adb server on 5037
+ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # keep this open
 ```

-**Warning: all communications between clients and ADB server are unencrypted.**
-
-Suppose that this server is accessible at 192.168.1.2. Then, from another
-terminal, run scrcpy:
+From another terminal:

 ```bash
-export ADB_SERVER_SOCKET=tcp:192.168.1.2:5037
-scrcpy --tunnel-host=192.168.1.2
-```
-
-By default, scrcpy uses the local port used for `adb forward` tunnel
-establishment (typically `27183`, see `--port`). It is also possible to force a
-different tunnel port (it may be useful in more complex situations, when more
-redirections are involved):
-
-```
-scrcpy --tunnel-port=1234
-```
-
-
-##### SSH tunnel
-
-To communicate with a remote ADB server securely, it is preferable to use a SSH
-tunnel.
-
-First, make sure the ADB server is running on the remote computer:
-
-```bash
-adb start-server
-```
-
-Then, establish a SSH tunnel:
-
-```bash
-# local  5038 --> remote  5037
-# local 27183 <-- remote 27183
-ssh -CN -L5038:localhost:5037 -R27183:localhost:27183 your_remote_computer
-# keep this open
-```
-
-From another terminal, run scrcpy:
-
-```bash
-export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy
 ```

@ -507,16 +421,14 @@ To avoid enabling remote port forwarding, you could force a forward connection
 instead (notice the `-L` instead of `-R`):

 ```bash
-# local  5038 --> remote  5037
-# local 27183 --> remote 27183
-ssh -CN -L5038:localhost:5037 -L27183:localhost:27183 your_remote_computer
+adb kill-server    # kill the local adb server on 5037
+ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # keep this open
 ```

-From another terminal, run scrcpy:
+From another terminal:

 ```bash
-export ADB_SERVER_SOCKET=tcp:localhost:5038
 scrcpy --force-adb-forward
 ```

@ -670,14 +582,6 @@ scrcpy --turn-screen-off --stay-awake
 scrcpy -Sw
 ```

-#### Power off on close
-
-To turn the device screen off when closing scrcpy:
-
-```bash
-scrcpy --power-off-on-close
-```
-

 #### Show touches

@ -758,9 +662,6 @@ of <kbd>Ctrl</kbd>+<kbd>v</kbd> and <kbd>MOD</kbd>+<kbd>v</kbd> so that they
 also inject the computer clipboard text as a sequence of key events (the same
 way as <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>).

-To disable automatic clipboard synchronization, use
-`--no-clipboard-autosync`.
-
 #### Pinch-to-zoom

 To simulate "pinch-to-zoom": <kbd>Ctrl</kbd>+_click-and-move_.
@ -777,7 +678,7 @@ a location inverted through the center of the screen.
 By default, scrcpy uses Android key or text injection: it works everywhere, but
 is limited to ASCII.

-On Linux, scrcpy can simulate a physical USB keyboard on Android to provide a
+On Linux, scrcpy can simulate a USB physical keyboard on Android to provide a
 better input experience (using [USB HID over AOAv2][hid-aoav2]): the virtual
 keyboard is disabled and it works for all characters and IME.

@ -929,7 +830,7 @@ _<kbd>[Super]</kbd> is typically the <kbd>Windows</kbd> or <kbd>Cmd</kbd> key._
 | Turn device screen on                       | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
 | Rotate device screen                        | <kbd>MOD</kbd>+<kbd>r</kbd>
 | Expand notification panel                   | <kbd>MOD</kbd>+<kbd>n</kbd> \| _5th-click³_
- | Expand settings panel                       | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Double-5th-click³_
+ | Expand settings panel                       |  <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Double-5th-click³_
 | Collapse panels                             | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
 | Copy to clipboard⁴                          | <kbd>MOD</kbd>+<kbd>c</kbd>
 | Cut to clipboard⁴                           | <kbd>MOD</kbd>+<kbd>x</kbd>
@ -937,8 +838,6 @@ _<kbd>[Super]</kbd> is typically the <kbd>Windows</kbd> or <kbd>Cmd</kbd> key._
 | Inject computer clipboard text              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
 | Enable/disable FPS counter (on stdout)      | <kbd>MOD</kbd>+<kbd>i</kbd>
 | Pinch-to-zoom                               | <kbd>Ctrl</kbd>+_click-and-move_
- | Drag & drop APK file                        | Install APK from computer
- | Drag & drop non-APK file                    | [Push file to device](#push-file-to-device)

 _¹Double-click on black borders to remove them._  
 _²Right-click turns the screen on if it was off, presses BACK otherwise._  
@ -1028,10 +927,10 @@ Read the [developers page].
 This README is available in other languages:

 - [Indonesian (Indonesia, `id`) - v1.16](README.id.md)
- [Italiano (Italiano, `it`) - v1.19](README.it.md)
- [日本語 (Japanese, `jp`) - v1.19](README.jp.md)
+- [Italiano (Italiano, `it`) - v1.17](README.it.md)
+- [日本語 (Japanese, `jp`) - v1.17](README.jp.md)
 - [한국어 (Korean, `ko`) - v1.11](README.ko.md)
- [Português Brasileiro (Brazilian Portuguese, `pt-BR`) - v1.19](README.pt-br.md)
+- [português brasileiro (Brazilian Portuguese, `pt-BR`) - v1.17](README.pt-br.md)
 - [Español (Spanish, `sp`) - v1.17](README.sp.md)
 - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.17](README.zh-Hans.md)
 - [繁體中文 (Traditional Chinese, `zh-Hant`) - v1.15](README.zh-Hant.md)
--- a/README.pt-br.md
+++ b/README.pt-br.md
@ -1,6 +1,6 @@
 _Apenas o [README](README.md) original é garantido estar atualizado._

-# scrcpy (v1.19)
+# scrcpy (v1.17)

 Esta aplicação fornece exibição e controle de dispositivos Android conectados via
 USB (ou [via TCP/IP][article-tcpip]). Não requer nenhum acesso _root_.
@ -38,18 +38,6 @@ controlá-lo usando teclado e mouse.

 <a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>

-### Sumário
-
- - Linux: `apt install scrcpy`
- - Windows: [baixar][direct-win64]
- - macOS: `brew install scrcpy`
-
-  Compilar pelos arquivos fontes: [BUILD] ([processo simplificado][BUILD_simple])
-
-[BUILD]: BUILD.md
-[BUILD_simple]: BUILD.md#simple
-
-
 ### Linux

 No Debian (_testing_ e _sid_ por enquanto) e Ubuntu (20.04):
@ -79,7 +67,9 @@ Para Gentoo, uma [Ebuild] está disponível: [`scrcpy/`][ebuild-link].
 [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy

-Você também pode [compilar o app manualmente][BUILD] ([processo simplificado][BUILD_simple]).
+Você também pode [compilar o app manualmente][BUILD] (não se preocupe, não é tão
+difícil).
+


 ### Windows
@ -123,18 +113,13 @@ brew install scrcpy
 Você precisa do `adb`, acessível pelo seu `PATH`. Se você ainda não o tem:

 ```bash
-brew install android-platform-tools
+# Homebrew >= 2.6.0
+brew install --cask android-platform-tools
+
+# Homebrew < 2.6.0
+brew cask install android-platform-tools
 ```

-Está também disponivel em [MacPorts], que prepara o adb para você:
-
-```bash
-sudo port install scrcpy
-```
-
-[MacPorts]: https://www.macports.org/
-
-
 Você também pode [compilar o app manualmente][BUILD].


@ -210,11 +195,10 @@ Se `--max-size` também for especificado, o redimensionamento é aplicado após
 Para travar a orientação do espelhamento:

 ```bash
-scrcpy --lock-video-orientation     # orientação inicial (Atual)
-scrcpy --lock-video-orientation=0   # orientação natural
-scrcpy --lock-video-orientation=1   # 90° sentido anti-horário
-scrcpy --lock-video-orientation=2   # 180°
-scrcpy --lock-video-orientation=3   # 90° sentido horário
+scrcpy --lock-video-orientation 0   # orientação natural
+scrcpy --lock-video-orientation 1   # 90° sentido anti-horário
+scrcpy --lock-video-orientation 2   # 180°
+scrcpy --lock-video-orientation 3   # 90° sentido horário
 ```

 Isso afeta a orientação de gravação.
@ -238,9 +222,7 @@ erro dará os encoders disponíveis:
 scrcpy --encoder _
 ```

-### Captura
-
-#### Gravando
+### Gravando

 É possível gravar a tela enquanto ocorre o espelhamento:

@ -264,79 +246,6 @@ pacotes][packet delay variation] não impacta o arquivo gravado.
 [packet delay variation]: https://en.wikipedia.org/wiki/Packet_delay_variation


-#### v4l2loopback
-
-Em Linux, é possível enviar a transmissão do video para um disposiivo v4l2 loopback, assim
-o dispositivo Android pode ser aberto como uma webcam por qualquer ferramneta capaz de v4l2
-
-The module `v4l2loopback` must be installed:
-
-```bash
-sudo apt install v4l2loopback-dkms
-```
-
-Para criar um dispositivo v4l2:
-
-```bash
-sudo modprobe v4l2loopback
-```
-
-Isso criara um novo dispositivo de vídeo em `/dev/videoN`, onde `N` é uma integer
-(mais [opções](https://github.com/umlaeute/v4l2loopback#options) estão disponiveis
-para criar varios dispositivos ou dispositivos com IDs específicas).
-
-Para listar os dispositivos disponíveis:
-
-```bash
-# requer o pacote v4l-utils
-v4l2-ctl --list-devices
-
-# simples, mas pode ser suficiente
-ls /dev/video*
-```
-
-Para iniciar o scrcpy usando o coletor v4l2 (sink):
-
-```bash
-scrcpy --v4l2-sink=/dev/videoN
-scrcpy --v4l2-sink=/dev/videoN --no-display  # desativa a janela espelhada
-scrcpy --v4l2-sink=/dev/videoN -N            # versão curta
-```
-
-(troque `N` pelo ID do dipositivo, verifique com `ls /dev/video*`)
-
-Uma vez ativado, você pode abrir suas trasmissões de videos com uma ferramenta capaz de v4l2:
-
-```bash
-ffplay -i /dev/videoN
-vlc v4l2:///dev/videoN   # VLC pode adicionar um pouco de atraso de buffering
-```
-
-Por exemplo, você pode capturar o video dentro do [OBS].
-
-[OBS]: https://obsproject.com/
-
-
-#### Buffering
-
-É possivel adicionar buffering. Isso aumenta a latência, mas reduz a tenção (jitter) (veja
-[#2464]).
-
-[#2464]: https://github.com/Genymobile/scrcpy/issues/2464
-
-A opção éta disponivel para buffering de exibição:
-
-```bash
-scrcpy --display-buffer=50  # adiciona 50 ms de buffering para a exibição
-```
-
-e coletor V4L2:
-
-```bash
-scrcpy --v4l2-buffer=500    # adiciona 500 ms de buffering para coletor V4L2
-```
-
-,
 ### Conexão

 #### Sem fio
@ -579,6 +488,18 @@ scrcpy -Sw
 ```


+#### Renderizar frames expirados
+
+Por padrão, para minimizar a latência, _scrcpy_ sempre renderiza o último frame decodificado
+disponível, e descarta o anterior.
+
+Para forçar a renderização de todos os frames (com o custo de um possível aumento de
+latência), use:
+
+```bash
+scrcpy --render-expired-frames
+```
+
 #### Mostrar toques

 Para apresentações, pode ser útil mostrar toques físicos (no dispositivo
@ -726,7 +647,7 @@ Não existe feedback visual, um log é imprimido no console.

 #### Enviar arquivo para dispositivo

-Para enviar um arquivo para `/sdcard/Download/` no dispositivo, arraste e solte um arquivo (não-APK) para a
+Para enviar um arquivo para `/sdcard/` no dispositivo, arraste e solte um arquivo (não-APK) para a
 janela do _scrcpy_.

 Não existe feedback visual, um log é imprimido no console.
@ -773,12 +694,12 @@ _<kbd>[Super]</kbd> é tipicamente a tecla <kbd>Windows</kbd> ou <kbd>Cmd</kbd>.
 | Mudar modo de tela cheia                    | <kbd>MOD</kbd>+<kbd>f</kbd>
 | Rotacionar display para esquerda            | <kbd>MOD</kbd>+<kbd>←</kbd> _(esquerda)_
 | Rotacionar display para direita             | <kbd>MOD</kbd>+<kbd>→</kbd> _(direita)_
- | Redimensionar janela para 1:1 (pixel-perfeito) | <kbd>MOD</kbd>+<kbd>g</kbd>
- | Redimensionar janela para remover bordas pretas | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Clique-duplo-esquerdo¹_
+ | Redimensionar janela para 1:1 (pixel-perfect) | <kbd>MOD</kbd>+<kbd>g</kbd>
+ | Redimensionar janela para remover bordas pretas | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Clique-duplo¹_
 | Clicar em `HOME`                            | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Clique-do-meio_
 | Clicar em `BACK`                            | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Clique-direito²_
- | Clicar em `APP_SWITCH`                      | <kbd>MOD</kbd>+<kbd>s</kbd> \| _Clique-do-4.°³_
- | Clicar em `MENU` (desbloquear tela)         | <kbd>MOD</kbd>+<kbd>m</kbd>
+ | Clicar em `APP_SWITCH`                      | <kbd>MOD</kbd>+<kbd>s</kbd>
+ | Clicar em `MENU` (desbloquear tela          | <kbd>MOD</kbd>+<kbd>m</kbd>
 | Clicar em `VOLUME_UP`                       | <kbd>MOD</kbd>+<kbd>↑</kbd> _(cima)_
 | Clicar em `VOLUME_DOWN`                     | <kbd>MOD</kbd>+<kbd>↓</kbd> _(baixo)_
 | Clicar em `POWER`                           | <kbd>MOD</kbd>+<kbd>p</kbd>
@ -786,27 +707,18 @@ _<kbd>[Super]</kbd> é tipicamente a tecla <kbd>Windows</kbd> ou <kbd>Cmd</kbd>.
 | Desligar tela do dispositivo (continuar espelhando) | <kbd>MOD</kbd>+<kbd>o</kbd>
 | Ligar tela do dispositivo                   | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
 | Rotacionar tela do dispositivo              | <kbd>MOD</kbd>+<kbd>r</kbd>
- | Expandir painel de notificação              | <kbd>MOD</kbd>+<kbd>n</kbd> \| _Clique-do-5.°³_
- | Expandir painel de configurção              | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Clique-duplo-do-5.°³_
- | Colapsar paineis                            | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
- | Copiar para área de transferência⁴          | <kbd>MOD</kbd>+<kbd>c</kbd>
- | Recortar para área de transferência⁴        | <kbd>MOD</kbd>+<kbd>x</kbd>
- | Sincronizar áreas de transferência e colar⁴ | <kbd>MOD</kbd>+<kbd>v</kbd>
+ | Expandir painel de notificação              | <kbd>MOD</kbd>+<kbd>n</kbd>
+ | Colapsar painel de notificação              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
+ | Copiar para área de transferência³          | <kbd>MOD</kbd>+<kbd>c</kbd>
+ | Recortar para área de transferência³        | <kbd>MOD</kbd>+<kbd>x</kbd>
+ | Sincronizar áreas de transferência e colar³ | <kbd>MOD</kbd>+<kbd>v</kbd>
 | Injetar texto da área de transferência do computador | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
 | Ativar/desativar contador de FPS (em stdout) | <kbd>MOD</kbd>+<kbd>i</kbd>
- | Pinçar para dar zoom                        | <kbd>Ctrl</kbd>+_Clicar-e-mover_
+ | Pinçar para dar zoom                        | <kbd>Ctrl</kbd>+_clicar-e-mover_

-_¹Clique-duplo-esquerdo na borda preta para remove-la._  
-_²Clique-direito liga a tela caso esteja desligada, pressione BACK caso contrário._  
-_³4.° and 5.° botões do mouse, caso o mouse possua._  
-_⁴Apenas em Android >= 7._
-
-Atalhos com teclas reptidas são executados soltando e precionando a tecla
-uma segunda vez. Por exemplo, para executar "Expandir painel de Configurção":
-
- 1. Mantenha pressionado <kbd>MOD</kbd>.
- 2. Depois click duas vezes <kbd>n</kbd>.
- 3. Finalmente, solte <kbd>MOD</kbd>.
+_¹Clique-duplo em bordas pretas para removê-las._  
+_²Clique-direito liga a tela se ela estiver desligada, pressiona BACK caso contrário._
+_³Apenas em Android >= 7._

 Todos os atalhos <kbd>Ctrl</kbd>+_tecla_ são encaminhados para o dispositivo, para que eles sejam
 tratados pela aplicação ativa.
@ -817,9 +729,7 @@ tratados pela aplicação ativa.
 Para usar um binário _adb_ específico, configure seu caminho na variável de ambiente
 `ADB`:

-```bash
-ADB=/caminho/para/adb scrcpy
-```
+    ADB=/caminho/para/adb scrcpy

 Para sobrepor o caminho do arquivo `scrcpy-server`, configure seu caminho em
 `SCRCPY_SERVER_PATH`.
@ -841,6 +751,8 @@ Um colega me desafiou a encontrar um nome tão impronunciável quanto [gnirehtet

 Veja [BUILD].

+[BUILD]: BUILD.md
+

 ## Problemas comuns

--- a/app/meson.build
+++ b/app/meson.build
@ -1,8 +1,6 @@
 src = [
    'src/main.c',
    'src/adb.c',
-    'src/adb_parser.c',
-    'src/adb_tunnel.c',
    'src/cli.c',
    'src/clock.c',
    'src/compat.c',
@ -18,7 +16,6 @@ src = [
    'src/keyboard_inject.c',
    'src/mouse_inject.c',
    'src/opengl.c',
-    'src/options.c',
    'src/receiver.c',
    'src/recorder.c',
    'src/scrcpy.c',
@ -26,42 +23,18 @@ src = [
    'src/server.c',
    'src/stream.c',
    'src/video_buffer.c',
-    'src/util/acksync.c',
-    'src/util/file.c',
-    'src/util/intr.c',
    'src/util/log.c',
    'src/util/net.c',
-    'src/util/net_intr.c',
    'src/util/process.c',
-    'src/util/process_intr.c',
-    'src/util/strbuf.c',
-    'src/util/str.c',
-    'src/util/term.c',
+    'src/util/str_util.c',
    'src/util/thread.c',
    'src/util/tick.c',
 ]

-conf = configuration_data()
-
-conf.set('_POSIX_C_SOURCE', '200809L')
-conf.set('_XOPEN_SOURCE', '700')
-conf.set('_GNU_SOURCE', true)
-
 if host_machine.system() == 'windows'
-    src += [
-        'src/sys/win/file.c',
-        'src/sys/win/process.c',
-    ]
-    conf.set('_WIN32_WINNT', '0x0600')
-    conf.set('WINVER', '0x0600')
+    src += [ 'src/sys/win/process.c' ]
 else
-    src += [
-        'src/sys/unix/file.c',
-        'src/sys/unix/process.c',
-    ]
-    if host_machine.system() == 'darwin'
-        conf.set('_DARWIN_C_SOURCE', true)
-    endif
+    src += [ 'src/sys/unix/process.c' ]
 endif

 v4l2_support = host_machine.system() == 'linux'
@ -77,6 +50,10 @@ if aoa_hid_support
    ]
 endif

+check_functions = [
+    'strdup'
+]
+
 cc = meson.get_compiler('c')

 if not get_option('crossbuild_windows')
@ -137,11 +114,7 @@ if host_machine.system() == 'windows'
    dependencies += cc.find_library('ws2_32')
 endif

-check_functions = [
-    'strdup',
-    'asprintf',
-    'vasprintf',
-]
+conf = configuration_data()

 foreach f : check_functions
  if cc.has_function(f)
@ -150,9 +123,6 @@ foreach f : check_functions
  endif
 endforeach

-conf.set('HAVE_SOCK_CLOEXEC', host_machine.system() != 'windows' and
-                              cc.has_header_symbol('sys/socket.h', 'SOCK_CLOEXEC'))
-
 # the version, updated on release
 conf.set_quoted('SCRCPY_VERSION', meson.project_version())

@ -205,14 +175,8 @@ install_data('../data/icon.png',
 # do not build tests in release (assertions would not be executed at all)
 if get_option('buildtype') == 'debug'
    tests = [
-        ['test_adb_parser', [
-            'tests/test_adb_parser.c',
-            'src/adb_parser.c',
-            'src/util/str.c',
-            'src/util/strbuf.c',
-        ]],
        ['test_buffer_util', [
-            'tests/test_buffer_util.c',
+            'tests/test_buffer_util.c'
        ]],
        ['test_cbuf', [
            'tests/test_cbuf.c',
@ -220,11 +184,7 @@ if get_option('buildtype') == 'debug'
        ['test_cli', [
            'tests/test_cli.c',
            'src/cli.c',
-            'src/options.c',
-            'src/util/net.c',
-            'src/util/str.c',
-            'src/util/strbuf.c',
-            'src/util/term.c',
+            'src/util/str_util.c',
        ]],
        ['test_clock', [
            'tests/test_clock.c',
@ -233,8 +193,7 @@ if get_option('buildtype') == 'debug'
        ['test_control_msg_serialize', [
            'tests/test_control_msg_serialize.c',
            'src/control_msg.c',
-            'src/util/str.c',
-            'src/util/strbuf.c',
+            'src/util/str_util.c',
        ]],
        ['test_device_msg_deserialize', [
            'tests/test_device_msg_deserialize.c',
@ -243,14 +202,9 @@ if get_option('buildtype') == 'debug'
        ['test_queue', [
            'tests/test_queue.c',
        ]],
-        ['test_strbuf', [
-            'tests/test_strbuf.c',
-            'src/util/strbuf.c',
-        ]],
-        ['test_str', [
-            'tests/test_str.c',
-            'src/util/str.c',
-            'src/util/strbuf.c',
+        ['test_strutil', [
+            'tests/test_strutil.c',
+            'src/util/str_util.c',
        ]],
    ]

--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@ -114,12 +114,6 @@ Limit both the width and height of the video to \fIvalue\fR. The other dimension

 Default is 0 (unlimited).

-.TP
-.B \-\-no\-clipboard\-autosync
-By default, scrcpy automatically synchronizes the computer clipboard to the device clipboard before injecting Ctrl+v, and the device clipboard to the computer clipboard whenever it changes.
-
-This option disables this automatic synchronization.
-
 .TP
 .B \-n, \-\-no\-control
 Disable device control (mirror the device in read\-only).
@ -142,10 +136,6 @@ Set the TCP port (range) used by the client to listen.

 Default is 27183:27199.

-.TP
-.B \-\-power\-off\-on\-close
-Turn the device screen off when closing scrcpy.
-
 .TP
 .B \-\-prefer\-text
 Inject alpha characters and space as text events instead of key events.
@ -199,14 +189,6 @@ For example, to use either LCtrl+LAlt or LSuper for scrcpy shortcuts, pass "lctr

 Default is "lalt,lsuper" (left-Alt or left-Super).

-.TP
-.BI "\-\-tcpip[=ip[:port]]
-Configure and reconnect the device over TCP/IP.
-
-If a destination address is provided, then scrcpy connects to this address before starting. The device must listen on the given TCP port (default is 5555).
-
-If no destination address is provided, then scrcpy attempts to find the IP address of the current device (typically connected over USB), enables TCP/IP mode, then connects to this address before starting.
-
 .TP
 .B \-S, \-\-turn\-screen\-off
 Turn the device screen off immediately.
@ -217,18 +199,6 @@ Enable "show touches" on start, restore the initial value on exit.

 It only shows physical touches (not clicks from scrcpy).

-.TP
-.BI "\-\-tunnel\-host " ip
-Set the IP address of the adb tunnel to reach the scrcpy server. This option automatically enables --force-adb-forward.
-
-Default is localhost.
-
-.TP
-.BI "\-\-tunnel\-port " port
-Set the TCP port of the adb tunnel to reach the scrcpy server. This option automatically enables --force-adb-forward.
-
-Default is 0 (not forced): the local port used for establishing the tunnel will be used.
-
 .TP
 .BI "\-\-v4l2-sink " /dev/videoN
 Output to v4l2loopback device.
@ -394,10 +364,6 @@ Pinch-to-zoom from the center of the screen
 .B Drag & drop APK file
 Install APK from computer

-.TP
-.B Drag & drop non-APK file
-Push file to device (see \fB\-\-push\-target\fR)
-

 .SH Environment variables

--- a/app/src/adb.c
+++ b/app/src/adb.c
@ -5,11 +5,8 @@
 #include <stdlib.h>
 #include <string.h>

-#include "adb_parser.h"
-#include "util/file.h"
 #include "util/log.h"
-#include "util/process_intr.h"
-#include "util/str.h"
+#include "util/str_util.h"

 static const char *adb_command;

@ -71,7 +68,7 @@ show_adb_installation_msg() {
        {"pacman", "pacman -S android-tools"},
    };
    for (size_t i = 0; i < ARRAY_LEN(pkg_managers); ++i) {
-        if (sc_file_executable_exists(pkg_managers[i].binary)) {
+        if (search_executable(pkg_managers[i].binary)) {
            LOGI("You may install 'adb' by \"%s\"", pkg_managers[i].command);
            return;
        }
@ -83,28 +80,27 @@ show_adb_installation_msg() {
 }

 static void
-show_adb_err_msg(enum sc_process_result err, const char *const argv[]) {
+show_adb_err_msg(enum process_result err, const char *const argv[]) {
 #define MAX_COMMAND_STRING_LEN 1024
    char *buf = malloc(MAX_COMMAND_STRING_LEN);
    if (!buf) {
-        LOG_OOM();
-        LOGE("Failed to execute");
+        LOGE("Failed to execute (could not allocate error message)");
        return;
    }

    switch (err) {
-        case SC_PROCESS_ERROR_GENERIC:
+        case PROCESS_ERROR_GENERIC:
            argv_to_string(argv, buf, MAX_COMMAND_STRING_LEN);
            LOGE("Failed to execute: %s", buf);
            break;
-        case SC_PROCESS_ERROR_MISSING_BINARY:
+        case PROCESS_ERROR_MISSING_BINARY:
            argv_to_string(argv, buf, MAX_COMMAND_STRING_LEN);
            LOGE("Command not found: %s", buf);
            LOGE("(make 'adb' accessible from your PATH or define its full"
                 "path in the ADB environment variable)");
            show_adb_installation_msg();
            break;
-        case SC_PROCESS_SUCCESS:
+        case PROCESS_SUCCESS:
            // do nothing
            break;
    }
@ -112,61 +108,19 @@ show_adb_err_msg(enum sc_process_result err, const char *const argv[]) {
    free(buf);
 }

-static bool
-process_check_success_internal(sc_pid pid, const char *name, bool close,
-                               unsigned flags) {
-    bool log_errors = !(flags & SC_ADB_NO_LOGERR);
+process_t
+adb_execute_redirect(const char *serial, const char *const adb_cmd[],
+                     size_t len, pipe_t *pipe_stdin, pipe_t *pipe_stdout,
+                     pipe_t *pipe_stderr) {
+    int i;
+    process_t process;

-    if (pid == SC_PROCESS_NONE) {
-        if (log_errors) {
-            LOGE("Could not execute \"%s\"", name);
-        }
-        return false;
-    }
-    sc_exit_code exit_code = sc_process_wait(pid, close);
-    if (exit_code) {
-        if (log_errors) {
-            if (exit_code != SC_EXIT_CODE_NONE) {
-                LOGE("\"%s\" returned with value %" SC_PRIexitcode, name,
-                     exit_code);
-            } else {
-                LOGE("\"%s\" exited unexpectedly", name);
-            }
-        }
-        return false;
-    }
-    return true;
-}
-
-static bool
-process_check_success_intr(struct sc_intr *intr, sc_pid pid, const char *name,
-                           unsigned flags) {
-    if (!sc_intr_set_process(intr, pid)) {
-        // Already interrupted
-        return false;
-    }
-
-    // Always pass close=false, interrupting would be racy otherwise
-    bool ret = process_check_success_internal(pid, name, false, flags);
-
-    sc_intr_set_process(intr, SC_PROCESS_NONE);
-
-    // Close separately
-    sc_process_close(pid);
-
-    return ret;
-}
-
-static const char **
-adb_create_argv(const char *serial, const char *const adb_cmd[], size_t len) {
    const char **argv = malloc((len + 4) * sizeof(*argv));
    if (!argv) {
-        LOG_OOM();
-        return NULL;
+        return PROCESS_NONE;
    }

    argv[0] = get_adb_command();
-    int i;
    if (serial) {
        argv[1] = "-s";
        argv[2] = serial;
@ -177,295 +131,149 @@ adb_create_argv(const char *serial, const char *const adb_cmd[], size_t len) {

    memcpy(&argv[i], adb_cmd, len * sizeof(const char *));
    argv[len + i] = NULL;
-    return argv;
-}
-
-static sc_pid
-adb_execute_p(const char *serial, const char *const adb_cmd[], size_t len,
-              unsigned flags, sc_pipe *pout) {
-    const char **argv = adb_create_argv(serial, adb_cmd, len);
-    if (!argv) {
-        return SC_PROCESS_NONE;
-    }
-
-    unsigned process_flags = 0;
-    if (flags & SC_ADB_NO_STDOUT) {
-        process_flags |= SC_PROCESS_NO_STDOUT;
-    }
-    if (flags & SC_ADB_NO_STDERR) {
-        process_flags |= SC_PROCESS_NO_STDERR;
-    }
-
-    sc_pid pid;
-    enum sc_process_result r =
-        sc_process_execute_p(argv, &pid, process_flags, NULL, pout, NULL);
-    if (r != SC_PROCESS_SUCCESS) {
-        // If the execution itself failed (not the command exit code), log the
-        // error in all cases
+    enum process_result r =
+        process_execute_redirect(argv, &process, pipe_stdin, pipe_stdout,
+                                 pipe_stderr);
+    if (r != PROCESS_SUCCESS) {
        show_adb_err_msg(r, argv);
-        pid = SC_PROCESS_NONE;
+        process = PROCESS_NONE;
    }

    free(argv);
-    return pid;
+    return process;
 }

-sc_pid
-adb_execute(const char *serial, const char *const adb_cmd[], size_t len,
-            unsigned flags) {
-    return adb_execute_p(serial, adb_cmd, len, flags, NULL);
+process_t
+adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {
+    return adb_execute_redirect(serial, adb_cmd, len, NULL, NULL, NULL);
 }

-bool
-adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
-            const char *device_socket_name, unsigned flags) {
+process_t
+adb_forward(const char *serial, uint16_t local_port,
+            const char *device_socket_name) {
    char local[4 + 5 + 1]; // tcp:PORT
    char remote[108 + 14 + 1]; // localabstract:NAME
    sprintf(local, "tcp:%" PRIu16, local_port);
    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
    const char *const adb_cmd[] = {"forward", local, remote};
-
-    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
-    return process_check_success_intr(intr, pid, "adb forward", flags);
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }

-bool
-adb_forward_remove(struct sc_intr *intr, const char *serial,
-                   uint16_t local_port, unsigned flags) {
+process_t
+adb_forward_remove(const char *serial, uint16_t local_port) {
    char local[4 + 5 + 1]; // tcp:PORT
    sprintf(local, "tcp:%" PRIu16, local_port);
    const char *const adb_cmd[] = {"forward", "--remove", local};
-
-    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
-    return process_check_success_intr(intr, pid, "adb forward --remove", flags);
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }

-bool
-adb_reverse(struct sc_intr *intr, const char *serial,
-            const char *device_socket_name, uint16_t local_port,
-            unsigned flags) {
+process_t
+adb_reverse(const char *serial, const char *device_socket_name,
+            uint16_t local_port) {
    char local[4 + 5 + 1]; // tcp:PORT
    char remote[108 + 14 + 1]; // localabstract:NAME
    sprintf(local, "tcp:%" PRIu16, local_port);
    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
    const char *const adb_cmd[] = {"reverse", remote, local};
-
-    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
-    return process_check_success_intr(intr, pid, "adb reverse", flags);
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }

-bool
-adb_reverse_remove(struct sc_intr *intr, const char *serial,
-                   const char *device_socket_name, unsigned flags) {
+process_t
+adb_reverse_remove(const char *serial, const char *device_socket_name) {
    char remote[108 + 14 + 1]; // localabstract:NAME
    snprintf(remote, sizeof(remote), "localabstract:%s", device_socket_name);
    const char *const adb_cmd[] = {"reverse", "--remove", remote};
-
-    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
-    return process_check_success_intr(intr, pid, "adb reverse --remove", flags);
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }

-bool
-adb_push(struct sc_intr *intr, const char *serial, const char *local,
-         const char *remote, unsigned flags) {
+process_t
+adb_push(const char *serial, const char *local, const char *remote) {
 #ifdef __WINDOWS__
    // Windows will parse the string, so the paths must be quoted
    // (see sys/win/command.c)
-    local = sc_str_quote(local);
+    local = strquote(local);
    if (!local) {
-        return SC_PROCESS_NONE;
+        return PROCESS_NONE;
    }
-    remote = sc_str_quote(remote);
+    remote = strquote(remote);
    if (!remote) {
        free((void *) local);
-        return SC_PROCESS_NONE;
+        return PROCESS_NONE;
    }
 #endif

    const char *const adb_cmd[] = {"push", local, remote};
-    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
+    process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));

 #ifdef __WINDOWS__
    free((void *) remote);
    free((void *) local);
 #endif

-    return process_check_success_intr(intr, pid, "adb push", flags);
+    return proc;
 }

-bool
-adb_install(struct sc_intr *intr, const char *serial, const char *local,
-            unsigned flags) {
+process_t
+adb_install(const char *serial, const char *local) {
 #ifdef __WINDOWS__
    // Windows will parse the string, so the local name must be quoted
    // (see sys/win/command.c)
-    local = sc_str_quote(local);
+    local = strquote(local);
    if (!local) {
-        return SC_PROCESS_NONE;
+        return PROCESS_NONE;
    }
 #endif

    const char *const adb_cmd[] = {"install", "-r", local};
-    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
+    process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));

 #ifdef __WINDOWS__
    free((void *) local);
 #endif

-    return process_check_success_intr(intr, pid, "adb install", flags);
+    return proc;
 }

-bool
-adb_tcpip(struct sc_intr *intr, const char *serial, uint16_t port,
-          unsigned flags) {
-    char port_string[5 + 1];
-    sprintf(port_string, "%" PRIu16, port);
-    const char *const adb_cmd[] = {"tcpip", port_string};
+static ssize_t
+adb_execute_for_output(const char *serial, const char *const adb_cmd[],
+                       size_t adb_cmd_len, char *buf, size_t buf_len,
+                       const char *name) {
+    pipe_t pipe_stdout;
+    process_t proc = adb_execute_redirect(serial, adb_cmd, adb_cmd_len, NULL,
+                                          &pipe_stdout, NULL);

-    sc_pid pid = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags);
-    return process_check_success_intr(intr, pid, "adb tcpip", flags);
+    ssize_t r = read_pipe_all(pipe_stdout, buf, buf_len);
+    close_pipe(pipe_stdout);
+
+    if (!process_check_success(proc, name, true)) {
+        return -1;
+    }
+
+    return r;
 }

-bool
-adb_connect(struct sc_intr *intr, const char *ip_port, unsigned flags) {
-    const char *const adb_cmd[] = {"connect", ip_port};
-
-    sc_pipe pout;
-    sc_pid pid = adb_execute_p(NULL, adb_cmd, ARRAY_LEN(adb_cmd), flags, &pout);
-    if (pid == SC_PROCESS_NONE) {
-        LOGE("Could not execute \"adb connect\"");
-        return false;
+static size_t
+truncate_first_line(char *data, size_t len) {
+    data[len - 1] = '\0';
+    char *eol = strpbrk(data, "\r\n");
+    if (eol) {
+        *eol = '\0';
+        len = eol - data;
    }
-
-    // "adb connect" always returns successfully (with exit code 0), even in
-    // case of failure. As a workaround, check if its output starts with
-    // "connected".
-    char buf[128];
-    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf));
-    sc_pipe_close(pout);
-
-    bool ok = process_check_success_intr(intr, pid, "adb connect", flags);
-    if (!ok) {
-        return false;
-    }
-
-    if (r == -1) {
-        return false;
-    }
-
-    ok = !strncmp("connected", buf, sizeof("connected") - 1);
-    if (!ok && !(flags & SC_ADB_NO_STDERR)) {
-        // "adb connect" also prints errors to stdout. Since we capture it,
-        // re-print the error to stderr.
-        sc_str_truncate(buf, r, "\r\n");
-        fprintf(stderr, "%s\n", buf);
-    }
-    return ok;
-}
-
-bool
-adb_disconnect(struct sc_intr *intr, const char *ip_port, unsigned flags) {
-    const char *const adb_cmd[] = {"disconnect", ip_port};
-    size_t len = ip_port ? ARRAY_LEN(adb_cmd)
-                         : ARRAY_LEN(adb_cmd) - 1;
-
-    sc_pid pid = adb_execute(NULL, adb_cmd, len, flags);
-    return process_check_success_intr(intr, pid, "adb disconnect", flags);
+    return len;
 }

 char *
-adb_getprop(struct sc_intr *intr, const char *serial, const char *prop,
-            unsigned flags) {
-    const char *const adb_cmd[] = {"shell", "getprop", prop};
-
-    sc_pipe pout;
-    sc_pid pid =
-        adb_execute_p(serial, adb_cmd, ARRAY_LEN(adb_cmd), flags, &pout);
-    if (pid == SC_PROCESS_NONE) {
-        LOGE("Could not execute \"adb getprop\"");
-        return NULL;
-    }
-
+adb_get_serialno(void) {
    char buf[128];
-    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf));
-    sc_pipe_close(pout);

-    bool ok = process_check_success_intr(intr, pid, "adb getprop", flags);
-    if (!ok) {
-        return NULL;
-    }
-
-    if (r == -1) {
-        return NULL;
-    }
-
-    sc_str_truncate(buf, r, " \r\n");
-
-    return strdup(buf);
-}
-
-char *
-adb_get_serialno(struct sc_intr *intr, unsigned flags) {
    const char *const adb_cmd[] = {"get-serialno"};
-
-    sc_pipe pout;
-    sc_pid pid = adb_execute_p(NULL, adb_cmd, ARRAY_LEN(adb_cmd), flags, &pout);
-    if (pid == SC_PROCESS_NONE) {
-        LOGE("Could not execute \"adb get-serialno\"");
+    ssize_t r = adb_execute_for_output(NULL, adb_cmd, ARRAY_LEN(adb_cmd),
+                                       buf, sizeof(buf), "get-serialno");
+    if (r <= 0) {
        return NULL;
    }

-    char buf[128];
-    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf));
-    sc_pipe_close(pout);
-
-    bool ok = process_check_success_intr(intr, pid, "adb get-serialno", flags);
-    if (!ok) {
-        return NULL;
-    }
-
-    if (r == -1) {
-        return false;
-    }
-
-    sc_str_truncate(buf, r, " \r\n");
-
+    truncate_first_line(buf, r);
    return strdup(buf);
 }
-
-char *
-adb_get_device_ip(struct sc_intr *intr, const char *serial, unsigned flags) {
-    const char *const cmd[] = {"shell", "ip", "route"};
-
-    sc_pipe pout;
-    sc_pid pid = adb_execute_p(serial, cmd, ARRAY_LEN(cmd), flags, &pout);
-    if (pid == SC_PROCESS_NONE) {
-        LOGD("Could not execute \"ip route\"");
-        return NULL;
-    }
-
-    // "adb shell ip route" output should contain only a few lines
-    char buf[1024];
-    ssize_t r = sc_pipe_read_all_intr(intr, pid, pout, buf, sizeof(buf));
-    sc_pipe_close(pout);
-
-    bool ok = process_check_success_intr(intr, pid, "ip route", flags);
-    if (!ok) {
-        return NULL;
-    }
-
-    if (r == -1) {
-        return false;
-    }
-
-    assert((size_t) r <= sizeof(buf));
-    if (r == sizeof(buf) && buf[sizeof(buf) - 1] != '\0')  {
-        // The implementation assumes that the output of "ip route" fits in the
-        // buffer in a single pass
-        LOGW("Result of \"ip route\" does not fit in 1Kb. "
-             "Please report an issue.\n");
-        return NULL;
-    }
-
-    return sc_adb_parse_device_ip_from_output(buf, r);
-}
--- a/app/src/adb.h
+++ b/app/src/adb.h
@ -6,89 +6,38 @@
 #include <stdbool.h>
 #include <inttypes.h>

-#include "util/intr.h"
+#include "util/process.h"

-#define SC_ADB_NO_STDOUT (1 << 0)
-#define SC_ADB_NO_STDERR (1 << 1)
-#define SC_ADB_NO_LOGERR (1 << 2)
+process_t
+adb_execute(const char *serial, const char *const adb_cmd[], size_t len);

-#define SC_ADB_SILENT (SC_ADB_NO_STDOUT | SC_ADB_NO_STDERR | SC_ADB_NO_LOGERR)
+process_t
+adb_execute_redirect(const char *serial, const char *const adb_cmd[],
+                     size_t len, pipe_t *pipe_stdin, pipe_t *pipe_stdout,
+                     pipe_t *pipe_stderr);

-sc_pid
-adb_execute(const char *serial, const char *const adb_cmd[], size_t len,
-            unsigned flags);
+process_t
+adb_forward(const char *serial, uint16_t local_port,
+            const char *device_socket_name);

-bool
-adb_forward(struct sc_intr *intr, const char *serial, uint16_t local_port,
-            const char *device_socket_name, unsigned flags);
+process_t
+adb_forward_remove(const char *serial, uint16_t local_port);

-bool
-adb_forward_remove(struct sc_intr *intr, const char *serial,
-                   uint16_t local_port, unsigned flags);
+process_t
+adb_reverse(const char *serial, const char *device_socket_name,
+            uint16_t local_port);

-bool
-adb_reverse(struct sc_intr *intr, const char *serial,
-            const char *device_socket_name, uint16_t local_port,
-            unsigned flags);
+process_t
+adb_reverse_remove(const char *serial, const char *device_socket_name);

-bool
-adb_reverse_remove(struct sc_intr *intr, const char *serial,
-                   const char *device_socket_name, unsigned flags);
+process_t
+adb_push(const char *serial, const char *local, const char *remote);

-bool
-adb_push(struct sc_intr *intr, const char *serial, const char *local,
-         const char *remote, unsigned flags);
+process_t
+adb_install(const char *serial, const char *local);

-bool
-adb_install(struct sc_intr *intr, const char *serial, const char *local,
-            unsigned flags);
-
-/**
- * Execute `adb tcpip <port>`
- */
-bool
-adb_tcpip(struct sc_intr *intr, const char *serial, uint16_t port,
-          unsigned flags);
-
-/**
- * Execute `adb connect <ip_port>`
- *
- * `ip_port` may not be NULL.
- */
-bool
-adb_connect(struct sc_intr *intr, const char *ip_port, unsigned flags);
-
-/**
- * Execute `adb disconnect [<ip_port>]`
- *
- * If `ip_port` is NULL, execute `adb disconnect`.
- * Otherwise, execute `adb disconnect <ip_port>`.
- */
-bool
-adb_disconnect(struct sc_intr *intr, const char *ip_port, unsigned flags);
-
-/**
- * Execute `adb getprop <prop>`
- */
+// Return the result of "adb get-serialno".
 char *
-adb_getprop(struct sc_intr *intr, const char *serial, const char *prop,
-            unsigned flags);
-
-/**
- * Execute `adb get-serialno`
- *
- * Return the result, to be freed by the caller, or NULL on error.
- */
-char *
-adb_get_serialno(struct sc_intr *intr, unsigned flags);
-
-/**
- * Attempt to retrieve the device IP
- *
- * Return the IP as a string of the form "xxx.xxx.xxx.xxx", to be freed by the
- * caller, or NULL on error.
- */
-char *
-adb_get_device_ip(struct sc_intr *intr, const char *serial, unsigned flags);
+adb_get_serialno(void);

 #endif
--- a/app/src/adb_parser.c
+++ b/app/src/adb_parser.c
@ -1,65 +0,0 @@
-#include "adb_parser.h"
-
-#include <assert.h>
-#include <string.h>
-
-#include "util/log.h"
-#include "util/str.h"
-
-static char *
-sc_adb_parse_device_ip_from_line(char *line, size_t len) {
-    // One line from "ip route" looks lile:
-    // "192.168.1.0/24 dev wlan0  proto kernel  scope link  src 192.168.1.x"
-
-    // Get the location of the device name (index of "wlan0" in the example)
-    ssize_t idx_dev_name = sc_str_index_of_column(line, 2, " ");
-    if (idx_dev_name == -1) {
-        return NULL;
-    }
-
-    // Get the location of the ip address (column 8, but column 6 if we start
-    // from column 2). Must be computed before truncating individual columns.
-    ssize_t idx_ip = sc_str_index_of_column(&line[idx_dev_name], 6, " ");
-    if (idx_ip == -1) {
-        return NULL;
-    }
-    // idx_ip is searched from &line[idx_dev_name]
-    idx_ip += idx_dev_name;
-
-    char *dev_name = &line[idx_dev_name];
-    sc_str_truncate(dev_name, len - idx_dev_name + 1, " \t");
-
-    char *ip = &line[idx_ip];
-    sc_str_truncate(ip, len - idx_ip + 1, " \t");
-
-    // Only consider lines where the device name starts with "wlan"
-    if (strncmp(dev_name, "wlan", sizeof("wlan") - 1)) {
-        LOGD("Device ip lookup: ignoring %s (%s)", ip, dev_name);
-        return NULL;
-    }
-
-    return strdup(ip);
-}
-
-char *
-sc_adb_parse_device_ip_from_output(char *buf, size_t buf_len) {
-    size_t idx_line = 0;
-    while (idx_line < buf_len && buf[idx_line] != '\0') {
-        char *line = &buf[idx_line];
-        size_t len = sc_str_truncate(line, buf_len - idx_line, "\n");
-
-        // The same, but without any trailing '\r'
-        size_t line_len = sc_str_remove_trailing_cr(line, len);
-
-        char *ip = sc_adb_parse_device_ip_from_line(line, line_len);
-        if (ip) {
-            // Found
-            return ip;
-        }
-
-        // The next line starts after the '\n' (replaced by `\0`)
-        idx_line += len + 1;
-    }
-
-    return NULL;
-}
--- a/app/src/adb_parser.h
+++ b/app/src/adb_parser.h
@ -1,14 +0,0 @@
-#ifndef SC_ADB_PARSER_H
-#define SC_ADB_PARSER_H
-
-#include "common.h"
-
-#include "stddef.h"
-
-/**
- * Parse the ip from the output of `adb shell ip route`
- */
-char *
-sc_adb_parse_device_ip_from_output(char *buf, size_t buf_len);
-
-#endif
--- a/app/src/adb_tunnel.c
+++ b/app/src/adb_tunnel.c
@ -1,169 +0,0 @@
-#include "adb_tunnel.h"
-
-#include <assert.h>
-
-#include "adb.h"
-#include "util/log.h"
-#include "util/net_intr.h"
-#include "util/process_intr.h"
-
-#define SC_SOCKET_NAME "scrcpy"
-
-static bool
-listen_on_port(struct sc_intr *intr, sc_socket socket, uint16_t port) {
-    return net_listen_intr(intr, socket, IPV4_LOCALHOST, port, 1);
-}
-
-static bool
-enable_tunnel_reverse_any_port(struct sc_adb_tunnel *tunnel,
-                               struct sc_intr *intr, const char *serial,
-                               struct sc_port_range port_range) {
-    uint16_t port = port_range.first;
-    for (;;) {
-        if (!adb_reverse(intr, serial, SC_SOCKET_NAME, port,
-                         SC_ADB_NO_STDOUT)) {
-            // the command itself failed, it will fail on any port
-            return false;
-        }
-
-        // At the application level, the device part is "the server" because it
-        // serves video stream and control. However, at the network level, the
-        // client listens and the server connects to the client. That way, the
-        // client can listen before starting the server app, so there is no
-        // need to try to connect until the server socket is listening on the
-        // device.
-        sc_socket server_socket = net_socket();
-        if (server_socket != SC_SOCKET_NONE) {
-            bool ok = listen_on_port(intr, server_socket, port);
-            if (ok) {
-                // success
-                tunnel->server_socket = server_socket;
-                tunnel->local_port = port;
-                tunnel->enabled = true;
-                return true;
-            }
-
-            net_close(server_socket);
-        }
-
-        if (sc_intr_is_interrupted(intr)) {
-            // Stop immediately
-            return false;
-        }
-
-        // failure, disable tunnel and try another port
-        if (!adb_reverse_remove(intr, serial, SC_SOCKET_NAME,
-                                SC_ADB_NO_STDOUT)) {
-            LOGW("Could not remove reverse tunnel on port %" PRIu16, port);
-        }
-
-        // check before incrementing to avoid overflow on port 65535
-        if (port < port_range.last) {
-            LOGW("Could not listen on port %" PRIu16", retrying on %" PRIu16,
-                 port, (uint16_t) (port + 1));
-            port++;
-            continue;
-        }
-
-        if (port_range.first == port_range.last) {
-            LOGE("Could not listen on port %" PRIu16, port_range.first);
-        } else {
-            LOGE("Could not listen on any port in range %" PRIu16 ":%" PRIu16,
-                 port_range.first, port_range.last);
-        }
-        return false;
-    }
-}
-
-static bool
-enable_tunnel_forward_any_port(struct sc_adb_tunnel *tunnel,
-                               struct sc_intr *intr, const char *serial,
-                               struct sc_port_range port_range) {
-    tunnel->forward = true;
-
-    uint16_t port = port_range.first;
-    for (;;) {
-        if (adb_forward(intr, serial, port, SC_SOCKET_NAME, SC_ADB_NO_STDOUT)) {
-            // success
-            tunnel->local_port = port;
-            tunnel->enabled = true;
-            return true;
-        }
-
-        if (sc_intr_is_interrupted(intr)) {
-            // Stop immediately
-            return false;
-        }
-
-        if (port < port_range.last) {
-            LOGW("Could not forward port %" PRIu16", retrying on %" PRIu16,
-                 port, (uint16_t) (port + 1));
-            port++;
-            continue;
-        }
-
-        if (port_range.first == port_range.last) {
-            LOGE("Could not forward port %" PRIu16, port_range.first);
-        } else {
-            LOGE("Could not forward any port in range %" PRIu16 ":%" PRIu16,
-                 port_range.first, port_range.last);
-        }
-        return false;
-    }
-}
-
-void
-sc_adb_tunnel_init(struct sc_adb_tunnel *tunnel) {
-    tunnel->enabled = false;
-    tunnel->forward = false;
-    tunnel->server_socket = SC_SOCKET_NONE;
-    tunnel->local_port = 0;
-}
-
-bool
-sc_adb_tunnel_open(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
-                   const char *serial, struct sc_port_range port_range,
-                   bool force_adb_forward) {
-    assert(!tunnel->enabled);
-
-    if (!force_adb_forward) {
-        // Attempt to use "adb reverse"
-        if (enable_tunnel_reverse_any_port(tunnel, intr, serial, port_range)) {
-            return true;
-        }
-
-        // if "adb reverse" does not work (e.g. over "adb connect"), it
-        // fallbacks to "adb forward", so the app socket is the client
-
-        LOGW("'adb reverse' failed, fallback to 'adb forward'");
-    }
-
-    return enable_tunnel_forward_any_port(tunnel, intr, serial, port_range);
-}
-
-bool
-sc_adb_tunnel_close(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
-                    const char *serial) {
-    assert(tunnel->enabled);
-
-    bool ret;
-    if (tunnel->forward) {
-        ret = adb_forward_remove(intr, serial, tunnel->local_port,
-                                 SC_ADB_NO_STDOUT);
-    } else {
-        ret = adb_reverse_remove(intr, serial, SC_SOCKET_NAME,
-                                 SC_ADB_NO_STDOUT);
-
-        assert(tunnel->server_socket != SC_SOCKET_NONE);
-        if (!net_close(tunnel->server_socket)) {
-            LOGW("Could not close server socket");
-        }
-
-        // server_socket is never used anymore
-    }
-
-    // Consider tunnel disabled even if the command failed
-    tunnel->enabled = false;
-
-    return ret;
-}
--- a/app/src/adb_tunnel.h
+++ b/app/src/adb_tunnel.h
@ -1,47 +0,0 @@
-#ifndef SC_ADB_TUNNEL_H
-#define SC_ADB_TUNNEL_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stdint.h>
-
-#include "options.h"
-#include "util/intr.h"
-#include "util/net.h"
-
-struct sc_adb_tunnel {
-    bool enabled;
-    bool forward; // use "adb forward" instead of "adb reverse"
-    sc_socket server_socket; // only used if !forward
-    uint16_t local_port;
-};
-
-/**
- * Initialize the adb tunnel struct to default values
- */
-void
-sc_adb_tunnel_init(struct sc_adb_tunnel *tunnel);
-
-/**
- * Open a tunnel
- *
- * Blocking calls may be interrupted asynchronously via `intr`.
- *
- * If `force_adb_forward` is not set, then attempts to set up an "adb reverse"
- * tunnel first. Only if it fails (typical on old Android version connected via
- * TCP/IP), use "adb forward".
- */
-bool
-sc_adb_tunnel_open(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
-                   const char *serial, struct sc_port_range port_range,
-                   bool force_adb_forward);
-
-/**
- * Close the tunnel
- */
-bool
-sc_adb_tunnel_close(struct sc_adb_tunnel *tunnel, struct sc_intr *intr,
-                    const char *serial);
-
-#endif
--- a/app/src/aoa_hid.c
+++ b/app/src/aoa_hid.c
@ -4,7 +4,6 @@
 #include <stdio.h>

 #include "aoa_hid.h"
-#include "util/log.h"

 // See <https://source.android.com/devices/accessories/aoa2#hid-support>.
 #define ACCESSORY_REGISTER_HID 54
@ -21,7 +20,6 @@ sc_hid_event_log(const struct sc_hid_event *event) {
    unsigned buffer_size = event->size * 3 + 1;
    char *buffer = malloc(buffer_size);
    if (!buffer) {
-        LOG_OOM();
        return;
    }
    for (unsigned i = 0; i < event->size; ++i) {
@ -37,7 +35,7 @@ sc_hid_event_init(struct sc_hid_event *hid_event, uint16_t accessory_id,
    hid_event->accessory_id = accessory_id;
    hid_event->buffer = buffer;
    hid_event->size = buffer_size;
-    hid_event->ack_to_wait = SC_SEQUENCE_INVALID;
+    hid_event->delay = 0;
 }

 void
@ -120,10 +118,7 @@ sc_aoa_open_usb_handle(libusb_device *device, libusb_device_handle **handle) {
 }

 bool
-sc_aoa_init(struct sc_aoa *aoa, const char *serial,
-            struct sc_acksync *acksync) {
-    assert(acksync);
-
+sc_aoa_init(struct sc_aoa *aoa, const char *serial) {
    cbuf_init(&aoa->queue);

    if (!sc_mutex_init(&aoa->mutex)) {
@ -160,7 +155,6 @@ sc_aoa_init(struct sc_aoa *aoa, const char *serial,
    }

    aoa->stopped = false;
-    aoa->acksync = acksync;

    return true;
 }
@ -338,28 +332,23 @@ run_aoa_thread(void *data) {
        assert(non_empty);
        (void) non_empty;

-        uint64_t ack_to_wait = event.ack_to_wait;
-        sc_mutex_unlock(&aoa->mutex);
-
-        if (ack_to_wait != SC_SEQUENCE_INVALID) {
-            LOGD("Waiting ack from server sequence=%" PRIu64_, ack_to_wait);
-            // Do not block the loop indefinitely if the ack never comes (it should
-            // never happen)
-            sc_tick deadline = sc_tick_now() + SC_TICK_FROM_MS(500);
-            enum sc_acksync_wait_result result =
-                sc_acksync_wait(aoa->acksync, ack_to_wait, deadline);
-
-            if (result == SC_ACKSYNC_WAIT_TIMEOUT) {
-                LOGW("Ack not received after 500ms, discarding HID event");
-                sc_hid_event_destroy(&event);
-                continue;
-            } else if (result == SC_ACKSYNC_WAIT_INTR) {
-                // stopped
-                sc_hid_event_destroy(&event);
+        assert(event.delay >= 0);
+        if (event.delay) {
+            // Wait during the specified delay before injecting the HID event
+            sc_tick deadline = sc_tick_now() + event.delay;
+            bool timed_out = false;
+            while (!aoa->stopped && !timed_out) {
+                timed_out = !sc_cond_timedwait(&aoa->event_cond, &aoa->mutex,
+                                               deadline);
+            }
+            if (aoa->stopped) {
+                sc_mutex_unlock(&aoa->mutex);
                break;
            }
        }

+        sc_mutex_unlock(&aoa->mutex);
+
        bool ok = sc_aoa_send_hid_event(aoa, &event);
        sc_hid_event_destroy(&event);
        if (!ok) {
@ -388,8 +377,6 @@ sc_aoa_stop(struct sc_aoa *aoa) {
    aoa->stopped = true;
    sc_cond_signal(&aoa->event_cond);
    sc_mutex_unlock(&aoa->mutex);
-
-    sc_acksync_interrupt(aoa->acksync);
 }

 void
--- a/app/src/aoa_hid.h
+++ b/app/src/aoa_hid.h
@ -6,7 +6,7 @@

 #include <libusb-1.0/libusb.h>

-#include "util/acksync.h"
+#include "scrcpy.h"
 #include "util/cbuf.h"
 #include "util/thread.h"
 #include "util/tick.h"
@ -15,7 +15,7 @@ struct sc_hid_event {
    uint16_t accessory_id;
    unsigned char *buffer;
    uint16_t size;
-    uint64_t ack_to_wait;
+    sc_tick delay;
 };

 // Takes ownership of buffer
@ -37,12 +37,10 @@ struct sc_aoa {
    sc_cond event_cond;
    bool stopped;
    struct sc_hid_event_queue queue;
-
-    struct sc_acksync *acksync;
 };

 bool
-sc_aoa_init(struct sc_aoa *aoa, const char *serial, struct sc_acksync *acksync);
+sc_aoa_init(struct sc_aoa *aoa, const char *serial);

 void
 sc_aoa_destroy(struct sc_aoa *aoa);
--- a/app/src/cli.c
+++ b/app/src/cli.c
--- a/app/src/cli.h
+++ b/app/src/cli.h
@ -5,7 +5,7 @@

 #include <stdbool.h>

-#include "options.h"
+#include "scrcpy.h"

 struct scrcpy_cli_args {
    struct scrcpy_options opts;
--- a/app/src/clock.h
+++ b/app/src/clock.h
@ -26,7 +26,7 @@ struct sc_clock_point {
 * array.
 *
 * To estimate the slope, it splits the last SC_CLOCK_RANGE points into two
- * sets of SC_CLOCK_RANGE/2 points, and computes their centroid ("average
+ * sets of SC_CLOCK_RANGE/2 points, and compute their centroid ("average
 * point"). The slope of the estimated affine function is that of the line
 * passing through these two points.
 *
--- a/app/src/compat.c
+++ b/app/src/compat.c
@ -2,12 +2,6 @@

 #include "config.h"

-#include <assert.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <string.h>
-
 #ifndef HAVE_STRDUP
 char *strdup(const char *s) {
    size_t size = strlen(s) + 1;
@ -18,36 +12,3 @@ char *strdup(const char *s) {
    return dup;
 }
 #endif
-
-#ifndef HAVE_ASPRINTF
-int asprintf(char **strp, const char *fmt, ...) {
-    va_list va;
-    va_start(va, fmt);
-    int ret = vasprintf(strp, fmt, va);
-    va_end(va);
-    return ret;
-}
-#endif
-
-#ifndef HAVE_VASPRINTF
-int vasprintf(char **strp, const char *fmt, va_list ap) {
-    va_list va;
-    va_copy(va, ap);
-    int len = vsnprintf(NULL, 0, fmt, va);
-    va_end(va);
-
-    char *str = malloc(len + 1);
-    if (!str) {
-        return -1;
-    }
-
-    va_copy(va, ap);
-    int len2 = vsnprintf(str, len + 1, fmt, va);
-    (void) len2;
-    assert(len == len2);
-    va_end(va);
-
-    *strp = str;
-    return len;
-}
-#endif
--- a/app/src/compat.h
+++ b/app/src/compat.h
@ -1,17 +1,16 @@
 #ifndef COMPAT_H
 #define COMPAT_H

-#include "config.h"
+#define _POSIX_C_SOURCE 200809L
+#define _XOPEN_SOURCE 700
+#define _GNU_SOURCE
+#ifdef __APPLE__
+# define _DARWIN_C_SOURCE
+#endif

 #include <libavformat/version.h>
 #include <SDL2/SDL_version.h>

-#ifndef __WIN32
-# define PRIu64_ PRIu64
-#else
-# define PRIu64_ "I64u"  // Windows...
-#endif
-
 // In ffmpeg/doc/APIchanges:
 // 2018-02-06 - 0694d87024 - lavf 58.9.100 - avformat.h
 //   Deprecate use of av_register_input_format(), av_register_output_format(),
@ -44,11 +43,6 @@
 # define SCRCPY_SDL_HAS_WINDOW_ALWAYS_ON_TOP
 #endif

-#if SDL_VERSION_ATLEAST(2, 0, 6)
-// <https://github.com/libsdl-org/SDL/commit/d7a318de563125e5bb465b1000d6bc9576fbc6fc>
-# define SCRCPY_SDL_HAS_HINT_TOUCH_MOUSE_EVENTS
-#endif
-
 #if SDL_VERSION_ATLEAST(2, 0, 8)
 // <https://hg.libsdl.org/SDL/rev/dfde5d3f9781>
 # define SCRCPY_SDL_HAS_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
@ -58,12 +52,4 @@
 char *strdup(const char *s);
 #endif

-#ifndef HAVE_ASPRINTF
-int asprintf(char **strp, const char *fmt, ...);
-#endif
-
-#ifndef HAVE_VASPRINTF
-int vasprintf(char **strp, const char *fmt, va_list ap);
-#endif
-
 #endif
--- a/app/src/control_msg.c
+++ b/app/src/control_msg.c
@ -7,7 +7,7 @@

 #include "util/buffer_util.h"
 #include "util/log.h"
-#include "util/str.h"
+#include "util/str_util.h"

 /**
 * Map an enum value to a string based on an array, without crashing on an
@ -56,7 +56,7 @@ static const char *const screen_power_mode_labels[] = {
 };

 static void
-write_position(uint8_t *buf, const struct sc_position *position) {
+write_position(uint8_t *buf, const struct position *position) {
    buffer_write32be(&buf[0], position->point.x);
    buffer_write32be(&buf[4], position->point.y);
    buffer_write16be(&buf[8], position->screen_size.width);
@ -66,7 +66,7 @@ write_position(uint8_t *buf, const struct sc_position *position) {
 // write length (2 bytes) + string (non nul-terminated)
 static size_t
 write_string(const char *utf8, size_t max_len, unsigned char *buf) {
-    size_t len = sc_str_utf8_truncation_index(utf8, max_len);
+    size_t len = utf8_truncation_index(utf8, max_len);
    buffer_write32be(buf, len);
    memcpy(&buf[4], utf8, len);
    return 4 + len;
@ -118,12 +118,11 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
            buf[1] = msg->inject_keycode.action;
            return 2;
        case CONTROL_MSG_TYPE_SET_CLIPBOARD: {
-            buffer_write64be(&buf[1], msg->set_clipboard.sequence);
-            buf[9] = !!msg->set_clipboard.paste;
+            buf[1] = !!msg->set_clipboard.paste;
            size_t len = write_string(msg->set_clipboard.text,
                                      CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH,
-                                      &buf[10]);
-            return 10 + len;
+                                      &buf[2]);
+            return 2 + len;
        }
        case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
            buf[1] = msg->set_screen_power_mode.mode;
@ -171,6 +170,11 @@ control_msg_log(const struct control_msg *msg) {
                         (long) msg->inject_touch_event.buttons);
            } else {
                // numeric pointer id
+#ifndef __WIN32
+# define PRIu64_ PRIu64
+#else
+# define PRIu64_ "I64u"  // Windows...
+#endif
                LOG_CMSG("touch [id=%" PRIu64_ "] %-4s position=%" PRIi32 ",%"
                             PRIi32 " pressure=%g buttons=%06lx",
                         id,
@ -195,8 +199,7 @@ control_msg_log(const struct control_msg *msg) {
                     KEYEVENT_ACTION_LABEL(msg->inject_keycode.action));
            break;
        case CONTROL_MSG_TYPE_SET_CLIPBOARD:
-            LOG_CMSG("clipboard %" PRIu64_ " %s \"%s\"",
-                     msg->set_clipboard.sequence,
+            LOG_CMSG("clipboard %s \"%s\"",
                     msg->set_clipboard.paste ? "paste" : "copy",
                     msg->set_clipboard.text);
            break;
--- a/app/src/control_msg.h
+++ b/app/src/control_msg.h
@ -57,11 +57,11 @@ struct control_msg {
            enum android_motionevent_action action;
            enum android_motionevent_buttons buttons;
            uint64_t pointer_id;
-            struct sc_position position;
+            struct position position;
            float pressure;
        } inject_touch_event;
        struct {
-            struct sc_position position;
+            struct position position;
            int32_t hscroll;
            int32_t vscroll;
        } inject_scroll_event;
@ -70,7 +70,6 @@ struct control_msg {
            // screen may only be turned on on ACTION_DOWN
        } back_or_screen_on;
        struct {
-            uint64_t sequence;
            char *text; // owned, to be freed by free()
            bool paste;
        } set_clipboard;
--- a/app/src/controller.c
+++ b/app/src/controller.c
@ -5,11 +5,10 @@
 #include "util/log.h"

 bool
-controller_init(struct controller *controller, sc_socket control_socket,
-                struct sc_acksync *acksync) {
+controller_init(struct controller *controller, sc_socket control_socket) {
    cbuf_init(&controller->queue);

-    bool ok = receiver_init(&controller->receiver, control_socket, acksync);
+    bool ok = receiver_init(&controller->receiver, control_socket);
    if (!ok) {
        return false;
    }
--- a/app/src/controller.h
+++ b/app/src/controller.h
@ -7,7 +7,6 @@

 #include "control_msg.h"
 #include "receiver.h"
-#include "util/acksync.h"
 #include "util/cbuf.h"
 #include "util/net.h"
 #include "util/thread.h"
@ -25,8 +24,7 @@ struct controller {
 };

 bool
-controller_init(struct controller *controller, sc_socket control_socket,
-                struct sc_acksync *acksync);
+controller_init(struct controller *controller, sc_socket control_socket);

 void
 controller_destroy(struct controller *controller);
--- a/app/src/coords.h
+++ b/app/src/coords.h
@ -3,22 +3,22 @@

 #include <stdint.h>

-struct sc_size {
+struct size {
    uint16_t width;
    uint16_t height;
 };

-struct sc_point {
+struct point {
    int32_t x;
    int32_t y;
 };

-struct sc_position {
+struct position {
    // The video screen size may be different from the real device screen size,
    // so store to which size the absolute position apply, to scale it
    // accordingly.
-    struct sc_size screen_size;
-    struct sc_point point;
+    struct size screen_size;
+    struct point point;
 };

 #endif
--- a/app/src/decoder.c
+++ b/app/src/decoder.c
@ -42,7 +42,7 @@ static bool
 decoder_open(struct decoder *decoder, const AVCodec *codec) {
    decoder->codec_ctx = avcodec_alloc_context3(codec);
    if (!decoder->codec_ctx) {
-        LOG_OOM();
+        LOGC("Could not allocate decoder context");
        return false;
    }

@ -54,7 +54,7 @@ decoder_open(struct decoder *decoder, const AVCodec *codec) {

    decoder->frame = av_frame_alloc();
    if (!decoder->frame) {
-        LOG_OOM();
+        LOGE("Could not create decoder frame");
        avcodec_close(decoder->codec_ctx);
        avcodec_free_context(&decoder->codec_ctx);
        return false;
--- a/app/src/device_msg.c
+++ b/app/src/device_msg.c
@ -1,6 +1,5 @@
 #include "device_msg.h"

-#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>

@ -24,7 +23,7 @@ device_msg_deserialize(const unsigned char *buf, size_t len,
            }
            char *text = malloc(clipboard_len + 1);
            if (!text) {
-                LOG_OOM();
+                LOGW("Could not allocate text for clipboard");
                return -1;
            }
            if (clipboard_len) {
@ -35,11 +34,6 @@ device_msg_deserialize(const unsigned char *buf, size_t len,
            msg->clipboard.text = text;
            return 5 + clipboard_len;
        }
-        case DEVICE_MSG_TYPE_ACK_CLIPBOARD: {
-            uint64_t sequence = buffer_read64be(&buf[1]);
-            msg->ack_clipboard.sequence = sequence;
-            return 9;
-        }
        default:
            LOGW("Unknown device message type: %d", (int) msg->type);
            return -1; // error, we cannot recover
--- a/app/src/device_msg.h
+++ b/app/src/device_msg.h
@ -13,7 +13,6 @@

 enum device_msg_type {
    DEVICE_MSG_TYPE_CLIPBOARD,
-    DEVICE_MSG_TYPE_ACK_CLIPBOARD,
 };

 struct device_msg {
@ -22,9 +21,6 @@ struct device_msg {
        struct {
            char *text; // owned, to be freed by free()
        } clipboard;
-        struct {
-            uint64_t sequence;
-        } ack_clipboard;
    };
 };

--- a/app/src/events.h
+++ b/app/src/events.h
@ -1,4 +1,2 @@
-#define EVENT_NEW_FRAME                 SDL_USEREVENT
-#define EVENT_STREAM_STOPPED           (SDL_USEREVENT + 1)
-#define EVENT_SERVER_CONNECTION_FAILED (SDL_USEREVENT + 2)
-#define EVENT_SERVER_CONNECTED         (SDL_USEREVENT + 3)
+#define EVENT_NEW_FRAME       SDL_USEREVENT
+#define EVENT_STREAM_STOPPED (SDL_USEREVENT + 1)
--- a/app/src/file_handler.c
+++ b/app/src/file_handler.c
@ -5,7 +5,6 @@

 #include "adb.h"
 #include "util/log.h"
-#include "util/process_intr.h"

 #define DEFAULT_PUSH_TARGET "/sdcard/Download/"

@ -17,7 +16,6 @@ file_handler_request_destroy(struct file_handler_request *req) {
 bool
 file_handler_init(struct file_handler *file_handler, const char *serial,
                  const char *push_target) {
-    assert(serial);

    cbuf_init(&file_handler->queue);

@ -32,26 +30,23 @@ file_handler_init(struct file_handler *file_handler, const char *serial,
        return false;
    }

-    ok = sc_intr_init(&file_handler->intr);
-    if (!ok) {
-        sc_cond_destroy(&file_handler->event_cond);
-        sc_mutex_destroy(&file_handler->mutex);
-        return false;
-    }
-
-    file_handler->serial = strdup(serial);
-    if (!file_handler->serial) {
-        LOG_OOM();
-        sc_intr_destroy(&file_handler->intr);
-        sc_cond_destroy(&file_handler->event_cond);
-        sc_mutex_destroy(&file_handler->mutex);
-        return false;
+    if (serial) {
+        file_handler->serial = strdup(serial);
+        if (!file_handler->serial) {
+            LOGW("Could not strdup serial");
+            sc_cond_destroy(&file_handler->event_cond);
+            sc_mutex_destroy(&file_handler->mutex);
+            return false;
+        }
+    } else {
+        file_handler->serial = NULL;
    }

    // lazy initialization
    file_handler->initialized = false;

    file_handler->stopped = false;
+    file_handler->current_process = PROCESS_NONE;

    file_handler->push_target = push_target ? push_target : DEFAULT_PUSH_TARGET;

@ -62,7 +57,6 @@ void
 file_handler_destroy(struct file_handler *file_handler) {
    sc_cond_destroy(&file_handler->event_cond);
    sc_mutex_destroy(&file_handler->mutex);
-    sc_intr_destroy(&file_handler->intr);
    free(file_handler->serial);

    struct file_handler_request req;
@ -71,6 +65,16 @@ file_handler_destroy(struct file_handler *file_handler) {
    }
 }

+static process_t
+install_apk(const char *serial, const char *file) {
+    return adb_install(serial, file);
+}
+
+static process_t
+push_file(const char *serial, const char *file, const char *push_target) {
+    return adb_push(serial, file, push_target);
+}
+
 bool
 file_handler_request(struct file_handler *file_handler,
                     file_handler_action_t action, char *file) {
@ -102,16 +106,10 @@ file_handler_request(struct file_handler *file_handler,
 static int
 run_file_handler(void *data) {
    struct file_handler *file_handler = data;
-    struct sc_intr *intr = &file_handler->intr;
-
-    const char *serial = file_handler->serial;
-    assert(serial);
-
-    const char *push_target = file_handler->push_target;
-    assert(push_target);

    for (;;) {
        sc_mutex_lock(&file_handler->mutex);
+        file_handler->current_process = PROCESS_NONE;
        while (!file_handler->stopped && cbuf_is_empty(&file_handler->queue)) {
            sc_cond_wait(&file_handler->event_cond, &file_handler->mutex);
        }
@ -124,26 +122,43 @@ run_file_handler(void *data) {
        bool non_empty = cbuf_take(&file_handler->queue, &req);
        assert(non_empty);
        (void) non_empty;
+
+        process_t process;
+        if (req.action == ACTION_INSTALL_APK) {
+            LOGI("Installing %s...", req.file);
+            process = install_apk(file_handler->serial, req.file);
+        } else {
+            LOGI("Pushing %s...", req.file);
+            process = push_file(file_handler->serial, req.file,
+                                file_handler->push_target);
+        }
+        file_handler->current_process = process;
        sc_mutex_unlock(&file_handler->mutex);

        if (req.action == ACTION_INSTALL_APK) {
-            LOGI("Installing %s...", req.file);
-            bool ok = adb_install(intr, serial, req.file, 0);
-            if (ok) {
+            if (process_check_success(process, "adb install", false)) {
                LOGI("%s successfully installed", req.file);
            } else {
                LOGE("Failed to install %s", req.file);
            }
        } else {
-            LOGI("Pushing %s...", req.file);
-            bool ok = adb_push(intr, serial, req.file, push_target, 0);
-            if (ok) {
-                LOGI("%s successfully pushed to %s", req.file, push_target);
+            if (process_check_success(process, "adb push", false)) {
+                LOGI("%s successfully pushed to %s", req.file,
+                                                     file_handler->push_target);
            } else {
-                LOGE("Failed to push %s to %s", req.file, push_target);
+                LOGE("Failed to push %s to %s", req.file,
+                                                file_handler->push_target);
            }
        }

+        sc_mutex_lock(&file_handler->mutex);
+        // Close the process (it is necessary already terminated)
+        // Execute this call with mutex locked to avoid race conditions with
+        // file_handler_stop()
+        process_close(file_handler->current_process);
+        file_handler->current_process = PROCESS_NONE;
+        sc_mutex_unlock(&file_handler->mutex);
+
        file_handler_request_destroy(&req);
    }
    return 0;
@ -168,7 +183,11 @@ file_handler_stop(struct file_handler *file_handler) {
    sc_mutex_lock(&file_handler->mutex);
    file_handler->stopped = true;
    sc_cond_signal(&file_handler->event_cond);
-    sc_intr_interrupt(&file_handler->intr);
+    if (file_handler->current_process != PROCESS_NONE) {
+        if (!process_terminate(file_handler->current_process)) {
+            LOGW("Could not terminate push/install process");
+        }
+    }
    sc_mutex_unlock(&file_handler->mutex);
 }

--- a/app/src/file_handler.h
+++ b/app/src/file_handler.h
@ -8,7 +8,6 @@
 #include "adb.h"
 #include "util/cbuf.h"
 #include "util/thread.h"
-#include "util/intr.h"

 typedef enum {
    ACTION_INSTALL_APK,
@ -30,9 +29,8 @@ struct file_handler {
    sc_cond event_cond;
    bool stopped;
    bool initialized;
+    process_t current_process;
    struct file_handler_request_queue queue;
-
-    struct sc_intr intr;
 };

 bool
--- a/app/src/frame_buffer.c
+++ b/app/src/frame_buffer.c
@ -10,13 +10,11 @@ bool
 sc_frame_buffer_init(struct sc_frame_buffer *fb) {
    fb->pending_frame = av_frame_alloc();
    if (!fb->pending_frame) {
-        LOG_OOM();
        return false;
    }

    fb->tmp_frame = av_frame_alloc();
    if (!fb->tmp_frame) {
-        LOG_OOM();
        av_frame_free(&fb->pending_frame);
        return false;
    }
--- a/app/src/hid_keyboard.c
+++ b/app/src/hid_keyboard.c
@ -160,7 +160,6 @@ static bool
 sc_hid_keyboard_event_init(struct sc_hid_event *hid_event) {
    unsigned char *buffer = malloc(HID_KEYBOARD_EVENT_SIZE);
    if (!buffer) {
-        LOG_OOM();
        return false;
    }

@ -279,8 +278,7 @@ push_mod_lock_state(struct sc_hid_keyboard *kb, uint16_t sdl_mod) {

 static void
 sc_key_processor_process_key(struct sc_key_processor *kp,
-                             const SDL_KeyboardEvent *event,
-                             uint64_t ack_to_wait) {
+                             const SDL_KeyboardEvent *event) {
    if (event->repeat) {
        // In USB HID protocol, key repeat is handled by the host (Android), so
        // just ignore key repeat here.
@ -300,12 +298,16 @@ sc_key_processor_process_key(struct sc_key_processor *kp,
            }
        }

-        if (ack_to_wait) {
+        SDL_Keycode keycode = event->keysym.sym;
+        bool down = event->type == SDL_KEYDOWN;
+        bool ctrl = event->keysym.mod & KMOD_CTRL;
+        bool shift = event->keysym.mod & KMOD_SHIFT;
+        if (ctrl && !shift && keycode == SDLK_v && down) {
            // Ctrl+v is pressed, so clipboard synchronization has been
-            // requested. Wait until clipboard synchronization is acknowledged
-            // by the server, otherwise it could paste the old clipboard
-            // content.
-            hid_event.ack_to_wait = ack_to_wait;
+            // requested. Wait a bit so that the clipboard is set before
+            // injecting Ctrl+v via HID, otherwise it would paste the old
+            // clipboard content.
+            hid_event.delay = SC_TICK_FROM_MS(2);
        }

        if (!sc_aoa_push_hid_event(kb->aoa, &hid_event)) {
@ -346,10 +348,6 @@ sc_hid_keyboard_init(struct sc_hid_keyboard *kb, struct sc_aoa *aoa) {
        .process_text = sc_key_processor_process_text,
    };

-    // Clipboard synchronization is requested over the control socket, while HID
-    // events are sent over AOA, so it must wait for clipboard synchronization
-    // to be acknowledged by the device before injecting Ctrl+v.
-    kb->key_processor.async_paste = true;
    kb->key_processor.ops = &ops;

    return true;
--- a/app/src/icon.c
+++ b/app/src/icon.c
@ -8,9 +8,9 @@

 #include "config.h"
 #include "compat.h"
-#include "util/file.h"
 #include "util/log.h"
-#include "util/str.h"
+#include "util/process.h"
+#include "util/str_util.h"

 #define SCRCPY_PORTABLE_ICON_FILENAME "icon.png"
 #define SCRCPY_DEFAULT_ICON_PATH \
@ -26,12 +26,12 @@ get_icon_path(void) {
    if (icon_path_env) {
        // if the envvar is set, use it
 #ifdef __WINDOWS__
-        char *icon_path = sc_str_from_wchars(icon_path_env);
+        char *icon_path = utf8_from_wide_char(icon_path_env);
 #else
        char *icon_path = strdup(icon_path_env);
 #endif
        if (!icon_path) {
-            LOG_OOM();
+            LOGE("Could not allocate memory");
            return NULL;
        }
        LOGD("Using SCRCPY_ICON_PATH: %s", icon_path);
@ -42,11 +42,11 @@ get_icon_path(void) {
    LOGD("Using icon: " SCRCPY_DEFAULT_ICON_PATH);
    char *icon_path = strdup(SCRCPY_DEFAULT_ICON_PATH);
    if (!icon_path) {
-        LOG_OOM();
+        LOGE("Could not allocate memory");
        return NULL;
    }
 #else
-    char *icon_path = sc_file_get_local_path(SCRCPY_PORTABLE_ICON_FILENAME);
+    char *icon_path = get_local_file_path(SCRCPY_PORTABLE_ICON_FILENAME);
    if (!icon_path) {
        LOGE("Could not get icon path");
        return NULL;
@ -63,7 +63,7 @@ decode_image(const char *path) {

    AVFormatContext *ctx = avformat_alloc_context();
    if (!ctx) {
-        LOG_OOM();
+        LOGE("Could not allocate image decoder context");
        return NULL;
    }

@ -93,7 +93,7 @@ decode_image(const char *path) {

    AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
    if (!codec_ctx) {
-        LOG_OOM();
+        LOGE("Could not allocate codec context");
        goto close_input;
    }

@ -109,13 +109,13 @@ decode_image(const char *path) {

    AVFrame *frame = av_frame_alloc();
    if (!frame) {
-        LOG_OOM();
+        LOGE("Could not allocate frame");
        goto close_codec;
    }

    AVPacket *packet = av_packet_alloc();
    if (!packet) {
-        LOG_OOM();
+        LOGE("Could not allocate packet");
        av_frame_free(&frame);
        goto close_codec;
    }
@ -158,12 +158,6 @@ free_ctx:
    return result;
 }

-#if !SDL_VERSION_ATLEAST(2, 0, 10)
-// SDL_PixelFormatEnum has been introduced in SDL 2.0.10. Use int for older SDL
-// versions.
-typedef int SDL_PixelFormatEnum;
-#endif
-
 static SDL_PixelFormatEnum
 to_sdl_pixel_format(enum AVPixelFormat fmt) {
    switch (fmt) {
@ -178,9 +172,7 @@ to_sdl_pixel_format(enum AVPixelFormat fmt) {
        case AV_PIX_FMT_BGR565BE: return SDL_PIXELFORMAT_BGR565;
        case AV_PIX_FMT_BGR555BE: return SDL_PIXELFORMAT_BGR555;
        case AV_PIX_FMT_RGB444BE: return SDL_PIXELFORMAT_RGB444;
-#if SDL_VERSION_ATLEAST(2, 0, 12)
        case AV_PIX_FMT_BGR444BE: return SDL_PIXELFORMAT_BGR444;
-#endif
        case AV_PIX_FMT_PAL8: return SDL_PIXELFORMAT_INDEX8;
        default: return SDL_PIXELFORMAT_UNKNOWN;
    }
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
@ -66,7 +66,6 @@ input_manager_init(struct input_manager *im, struct controller *controller,
    im->control = options->control;
    im->forward_all_clicks = options->forward_all_clicks;
    im->legacy_paste = options->legacy_paste;
-    im->clipboard_autosync = options->clipboard_autosync;

    const struct sc_shortcut_mods *shortcut_mods = &options->shortcut_mods;
    assert(shortcut_mods->count);
@ -83,8 +82,6 @@ input_manager_init(struct input_manager *im, struct controller *controller,
    im->last_keycode = SDLK_UNKNOWN;
    im->last_mod = 0;
    im->key_repeat = 0;
-
-    im->next_sequence = 1; // 0 is reserved for SC_SEQUENCE_INVALID
 }

 static void
@ -211,35 +208,35 @@ collapse_panels(struct controller *controller) {
    }
 }

-static bool
-set_device_clipboard(struct controller *controller, bool paste,
-                     uint64_t sequence) {
+static void
+set_device_clipboard(struct controller *controller, bool paste) {
    char *text = SDL_GetClipboardText();
    if (!text) {
        LOGW("Could not get clipboard text: %s", SDL_GetError());
-        return false;
+        return;
+    }
+    if (!*text) {
+        // empty text
+        SDL_free(text);
+        return;
    }

    char *text_dup = strdup(text);
    SDL_free(text);
    if (!text_dup) {
        LOGW("Could not strdup input text");
-        return false;
+        return;
    }

    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_SET_CLIPBOARD;
-    msg.set_clipboard.sequence = sequence;
    msg.set_clipboard.text = text_dup;
    msg.set_clipboard.paste = paste;

    if (!controller_push_msg(controller, &msg)) {
        free(text_dup);
        LOGW("Could not request 'set device clipboard'");
-        return false;
    }
-
-    return true;
 }

 static void
@ -335,7 +332,7 @@ input_manager_process_text_input(struct input_manager *im,
 static bool
 simulate_virtual_finger(struct input_manager *im,
                        enum android_motionevent_action action,
-                        struct sc_point point) {
+                        struct point point) {
    bool up = action == AMOTION_EVENT_ACTION_UP;

    struct control_msg msg;
@ -355,8 +352,8 @@ simulate_virtual_finger(struct input_manager *im,
    return true;
 }

-static struct sc_point
-inverse_point(struct sc_point point, struct sc_size size) {
+static struct point
+inverse_point(struct point point, struct size size) {
    point.x = size.width - point.x;
    point.y = size.height - point.y;
    return point;
@ -465,10 +462,8 @@ input_manager_process_key(struct input_manager *im,
                        // inject the text as input events
                        clipboard_paste(controller);
                    } else {
-                        // store the text in the device clipboard and paste,
-                        // without requesting an acknowledgment
-                        set_device_clipboard(controller, true,
-                                             SC_SEQUENCE_INVALID);
+                        // store the text in the device clipboard and paste
+                        set_device_clipboard(controller, true);
                    }
                }
                return;
@ -517,36 +512,18 @@ input_manager_process_key(struct input_manager *im,
        return;
    }

-    uint64_t ack_to_wait = SC_SEQUENCE_INVALID;
-    bool is_ctrl_v = ctrl && !shift && keycode == SDLK_v && down && !repeat;
-    if (im->clipboard_autosync && is_ctrl_v) {
+    if (ctrl && !shift && keycode == SDLK_v && down && !repeat) {
        if (im->legacy_paste) {
            // inject the text as input events
            clipboard_paste(controller);
            return;
        }
-
-        // Request an acknowledgement only if necessary
-        uint64_t sequence = im->kp->async_paste ? im->next_sequence
-                                                : SC_SEQUENCE_INVALID;
-
        // Synchronize the computer clipboard to the device clipboard before
        // sending Ctrl+v, to allow seamless copy-paste.
-        bool ok = set_device_clipboard(controller, false, sequence);
-        if (!ok) {
-            LOGW("Clipboard could not be synchronized, Ctrl+v not injected");
-            return;
-        }
-
-        if (im->kp->async_paste) {
-            // The key processor must wait for this ack before injecting Ctrl+v
-            ack_to_wait = sequence;
-            // Increment only when the request succeeded
-            ++im->next_sequence;
-        }
+        set_device_clipboard(controller, false);
    }

-    im->kp->ops->process_key(im->kp, event, ack_to_wait);
+    im->kp->ops->process_key(im->kp, event);
 }

 static void
@ -568,10 +545,10 @@ input_manager_process_mouse_motion(struct input_manager *im,
    im->mp->ops->process_mouse_motion(im->mp, event);

    if (im->vfinger_down) {
-        struct sc_point mouse =
+        struct point mouse =
            screen_convert_window_to_frame_coords(im->screen, event->x,
                                                  event->y);
-        struct sc_point vfinger = inverse_point(mouse, im->screen->frame_size);
+        struct point vfinger = inverse_point(mouse, im->screen->frame_size);
        simulate_virtual_finger(im, AMOTION_EVENT_ACTION_MOVE, vfinger);
    }
 }
@ -653,10 +630,10 @@ input_manager_process_mouse_button(struct input_manager *im,
 #define CTRL_PRESSED (SDL_GetModState() & (KMOD_LCTRL | KMOD_RCTRL))
    if ((down && !im->vfinger_down && CTRL_PRESSED)
            || (!down && im->vfinger_down)) {
-        struct sc_point mouse =
+        struct point mouse =
            screen_convert_window_to_frame_coords(im->screen, event->x,
                                                              event->y);
-        struct sc_point vfinger = inverse_point(mouse, im->screen->frame_size);
+        struct point vfinger = inverse_point(mouse, im->screen->frame_size);
        enum android_motionevent_action action = down
                                               ? AMOTION_EVENT_ACTION_DOWN
                                               : AMOTION_EVENT_ACTION_UP;
--- a/app/src/input_manager.h
+++ b/app/src/input_manager.h
@ -9,7 +9,7 @@

 #include "controller.h"
 #include "fps_counter.h"
-#include "options.h"
+#include "scrcpy.h"
 #include "screen.h"
 #include "trait/key_processor.h"
 #include "trait/mouse_processor.h"
@ -24,7 +24,6 @@ struct input_manager {
    bool control;
    bool forward_all_clicks;
    bool legacy_paste;
-    bool clipboard_autosync;

    struct {
        unsigned data[SC_MAX_SHORTCUT_MODS];
@ -39,8 +38,6 @@ struct input_manager {
    unsigned key_repeat;
    SDL_Keycode last_keycode;
    uint16_t last_mod;
-
-    uint64_t next_sequence; // used for request acknowledgements
 };

 void
--- a/app/src/keyboard_inject.c
+++ b/app/src/keyboard_inject.c
@ -188,13 +188,7 @@ convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to,

 static void
 sc_key_processor_process_key(struct sc_key_processor *kp,
-                             const SDL_KeyboardEvent *event,
-                             uint64_t ack_to_wait) {
-    // The device clipboard synchronization and the key event messages are
-    // serialized, there is nothing special to do to ensure that the clipboard
-    // is set before injecting Ctrl+v.
-    (void) ack_to_wait;
-
+                             const SDL_KeyboardEvent *event) {
    struct sc_keyboard_inject *ki = DOWNCAST(kp);

    if (event->repeat) {
@ -256,7 +250,5 @@ sc_keyboard_inject_init(struct sc_keyboard_inject *ki,
        .process_text = sc_key_processor_process_text,
    };

-    // Key injection and clipboard synchronization are serialized
-    ki->key_processor.async_paste = false;
    ki->key_processor.ops = &ops;
 }
--- a/app/src/keyboard_inject.h
+++ b/app/src/keyboard_inject.h
@ -6,7 +6,7 @@
 #include <stdbool.h>

 #include "controller.h"
-#include "options.h"
+#include "scrcpy.h"
 #include "trait/key_processor.h"

 struct sc_keyboard_inject {
--- a/app/src/main.c
+++ b/app/src/main.c
@ -1,3 +1,5 @@
+#include "scrcpy.h"
+
 #include "common.h"

 #include <assert.h>
@ -11,8 +13,6 @@
 #include <SDL2/SDL.h>

 #include "cli.h"
-#include "options.h"
-#include "scrcpy.h"
 #include "util/log.h"

 static void
@ -47,11 +47,8 @@ main(int argc, char *argv[]) {
    setbuf(stderr, NULL);
 #endif

-    printf("scrcpy " SCRCPY_VERSION
-           " <https://github.com/Genymobile/scrcpy>\n");
-
    struct scrcpy_cli_args args = {
-        .opts = scrcpy_options_default,
+        .opts = SCRCPY_OPTIONS_DEFAULT,
        .help = false,
        .version = false,
    };
@ -76,6 +73,8 @@ main(int argc, char *argv[]) {
        return 0;
    }

+    LOGI("scrcpy " SCRCPY_VERSION " <https://github.com/Genymobile/scrcpy>");
+
 #ifdef SCRCPY_LAVF_REQUIRES_REGISTER_ALL
    av_register_all();
 #endif
--- a/app/src/mouse_inject.c
+++ b/app/src/mouse_inject.c
@ -125,7 +125,7 @@ convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct screen *screen,
    int mouse_y;
    SDL_GetMouseState(&mouse_x, &mouse_y);

-    struct sc_position position = {
+    struct position position = {
        .screen_size = screen->frame_size,
        .point = screen_convert_window_to_frame_coords(screen,
                                                       mouse_x, mouse_y),
--- a/app/src/mouse_inject.h
+++ b/app/src/mouse_inject.h
@ -6,6 +6,7 @@
 #include <stdbool.h>

 #include "controller.h"
+#include "scrcpy.h"
 #include "screen.h"
 #include "trait/mouse_processor.h"

--- a/app/src/options.c
+++ b/app/src/options.c
@ -1,59 +0,0 @@
-#include "options.h"
-
-const struct scrcpy_options scrcpy_options_default = {
-    .serial = NULL,
-    .crop = NULL,
-    .record_filename = NULL,
-    .window_title = NULL,
-    .push_target = NULL,
-    .render_driver = NULL,
-    .codec_options = NULL,
-    .encoder_name = NULL,
-#ifdef HAVE_V4L2
-    .v4l2_device = NULL,
-#endif
-    .log_level = SC_LOG_LEVEL_INFO,
-    .record_format = SC_RECORD_FORMAT_AUTO,
-    .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT,
-    .port_range = {
-        .first = DEFAULT_LOCAL_PORT_RANGE_FIRST,
-        .last = DEFAULT_LOCAL_PORT_RANGE_LAST,
-    },
-    .tunnel_host = 0,
-    .tunnel_port = 0,
-    .shortcut_mods = {
-        .data = {SC_MOD_LALT, SC_MOD_LSUPER},
-        .count = 2,
-    },
-    .max_size = 0,
-    .bit_rate = DEFAULT_BIT_RATE,
-    .max_fps = 0,
-    .lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_UNLOCKED,
-    .rotation = 0,
-    .window_x = SC_WINDOW_POSITION_UNDEFINED,
-    .window_y = SC_WINDOW_POSITION_UNDEFINED,
-    .window_width = 0,
-    .window_height = 0,
-    .display_id = 0,
-    .display_buffer = 0,
-    .v4l2_buffer = 0,
-    .show_touches = false,
-    .fullscreen = false,
-    .always_on_top = false,
-    .control = true,
-    .display = true,
-    .turn_screen_off = false,
-    .prefer_text = false,
-    .window_borderless = false,
-    .mipmaps = true,
-    .stay_awake = false,
-    .force_adb_forward = false,
-    .disable_screensaver = false,
-    .forward_key_repeat = true,
-    .forward_all_clicks = false,
-    .legacy_paste = false,
-    .power_off_on_close = false,
-    .clipboard_autosync = true,
-    .tcpip = false,
-    .tcpip_dst = NULL,
-};
--- a/app/src/options.h
+++ b/app/src/options.h
@ -1,118 +0,0 @@
-#ifndef SCRCPY_OPTIONS_H
-#define SCRCPY_OPTIONS_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "util/tick.h"
-
-enum sc_log_level {
-    SC_LOG_LEVEL_VERBOSE,
-    SC_LOG_LEVEL_DEBUG,
-    SC_LOG_LEVEL_INFO,
-    SC_LOG_LEVEL_WARN,
-    SC_LOG_LEVEL_ERROR,
-};
-
-enum sc_record_format {
-    SC_RECORD_FORMAT_AUTO,
-    SC_RECORD_FORMAT_MP4,
-    SC_RECORD_FORMAT_MKV,
-};
-
-enum sc_lock_video_orientation {
-    SC_LOCK_VIDEO_ORIENTATION_UNLOCKED = -1,
-    // lock the current orientation when scrcpy starts
-    SC_LOCK_VIDEO_ORIENTATION_INITIAL = -2,
-    SC_LOCK_VIDEO_ORIENTATION_0 = 0,
-    SC_LOCK_VIDEO_ORIENTATION_1,
-    SC_LOCK_VIDEO_ORIENTATION_2,
-    SC_LOCK_VIDEO_ORIENTATION_3,
-};
-
-enum sc_keyboard_input_mode {
-    SC_KEYBOARD_INPUT_MODE_INJECT,
-    SC_KEYBOARD_INPUT_MODE_HID,
-};
-
-#define SC_MAX_SHORTCUT_MODS 8
-
-enum sc_shortcut_mod {
-    SC_MOD_LCTRL = 1 << 0,
-    SC_MOD_RCTRL = 1 << 1,
-    SC_MOD_LALT = 1 << 2,
-    SC_MOD_RALT = 1 << 3,
-    SC_MOD_LSUPER = 1 << 4,
-    SC_MOD_RSUPER = 1 << 5,
-};
-
-struct sc_shortcut_mods {
-    unsigned data[SC_MAX_SHORTCUT_MODS];
-    unsigned count;
-};
-
-struct sc_port_range {
-    uint16_t first;
-    uint16_t last;
-};
-
-#define SC_WINDOW_POSITION_UNDEFINED (-0x8000)
-
-struct scrcpy_options {
-    const char *serial;
-    const char *crop;
-    const char *record_filename;
-    const char *window_title;
-    const char *push_target;
-    const char *render_driver;
-    const char *codec_options;
-    const char *encoder_name;
-#ifdef HAVE_V4L2
-    const char *v4l2_device;
-#endif
-    enum sc_log_level log_level;
-    enum sc_record_format record_format;
-    enum sc_keyboard_input_mode keyboard_input_mode;
-    struct sc_port_range port_range;
-    uint32_t tunnel_host;
-    uint16_t tunnel_port;
-    struct sc_shortcut_mods shortcut_mods;
-    uint16_t max_size;
-    uint32_t bit_rate;
-    uint16_t max_fps;
-    enum sc_lock_video_orientation lock_video_orientation;
-    uint8_t rotation;
-    int16_t window_x; // SC_WINDOW_POSITION_UNDEFINED for "auto"
-    int16_t window_y; // SC_WINDOW_POSITION_UNDEFINED for "auto"
-    uint16_t window_width;
-    uint16_t window_height;
-    uint32_t display_id;
-    sc_tick display_buffer;
-    sc_tick v4l2_buffer;
-    bool show_touches;
-    bool fullscreen;
-    bool always_on_top;
-    bool control;
-    bool display;
-    bool turn_screen_off;
-    bool prefer_text;
-    bool window_borderless;
-    bool mipmaps;
-    bool stay_awake;
-    bool force_adb_forward;
-    bool disable_screensaver;
-    bool forward_key_repeat;
-    bool forward_all_clicks;
-    bool legacy_paste;
-    bool power_off_on_close;
-    bool clipboard_autosync;
-    bool tcpip;
-    const char *tcpip_dst;
-};
-
-extern const struct scrcpy_options scrcpy_options_default;
-
-#endif
--- a/app/src/receiver.c
+++ b/app/src/receiver.c
@ -7,16 +7,12 @@
 #include "util/log.h"

 bool
-receiver_init(struct receiver *receiver, sc_socket control_socket,
-              struct sc_acksync *acksync) {
+receiver_init(struct receiver *receiver, sc_socket control_socket) {
    bool ok = sc_mutex_init(&receiver->mutex);
    if (!ok) {
        return false;
    }
-
    receiver->control_socket = control_socket;
-    receiver->acksync = acksync;
-
    return true;
 }

@ -26,7 +22,7 @@ receiver_destroy(struct receiver *receiver) {
 }

 static void
-process_msg(struct receiver *receiver, struct device_msg *msg) {
+process_msg(struct device_msg *msg) {
    switch (msg->type) {
        case DEVICE_MSG_TYPE_CLIPBOARD: {
            char *current = SDL_GetClipboardText();
@ -41,17 +37,11 @@ process_msg(struct receiver *receiver, struct device_msg *msg) {
            SDL_SetClipboardText(msg->clipboard.text);
            break;
        }
-        case DEVICE_MSG_TYPE_ACK_CLIPBOARD:
-            assert(receiver->acksync);
-            LOGD("Ack device clipboard sequence=%" PRIu64_,
-                 msg->ack_clipboard.sequence);
-            sc_acksync_ack(receiver->acksync, msg->ack_clipboard.sequence);
-            break;
    }
 }

 static ssize_t
-process_msgs(struct receiver *receiver, const unsigned char *buf, size_t len) {
+process_msgs(const unsigned char *buf, size_t len) {
    size_t head = 0;
    for (;;) {
        struct device_msg msg;
@ -63,7 +53,7 @@ process_msgs(struct receiver *receiver, const unsigned char *buf, size_t len) {
            return head;
        }

-        process_msg(receiver, &msg);
+        process_msg(&msg);
        device_msg_destroy(&msg);

        head += r;
@ -91,7 +81,7 @@ run_receiver(void *data) {
        }

        head += r;
-        ssize_t consumed = process_msgs(receiver, buf, head);
+        ssize_t consumed = process_msgs(buf, head);
        if (consumed == -1) {
            // an error occurred
            break;
--- a/app/src/receiver.h
+++ b/app/src/receiver.h
@ -5,7 +5,6 @@

 #include <stdbool.h>

-#include "util/acksync.h"
 #include "util/net.h"
 #include "util/thread.h"

@ -15,13 +14,10 @@ struct receiver {
    sc_socket control_socket;
    sc_thread thread;
    sc_mutex mutex;
-
-    struct sc_acksync *acksync;
 };

 bool
-receiver_init(struct receiver *receiver, sc_socket control_socket,
-              struct sc_acksync *acksync);
+receiver_init(struct receiver *receiver, sc_socket control_socket);

 void
 receiver_destroy(struct receiver *receiver);
--- a/app/src/recorder.c
+++ b/app/src/recorder.c
@ -6,7 +6,7 @@
 #include <libavutil/time.h>

 #include "util/log.h"
-#include "util/str.h"
+#include "util/str_util.h"

 /** Downcast packet_sink to recorder */
 #define DOWNCAST(SINK) container_of(SINK, struct recorder, packet_sink)
@ -26,7 +26,7 @@ find_muxer(const char *name) {
        oformat = av_oformat_next(oformat);
 #endif
        // until null or containing the requested name
-    } while (oformat && !sc_str_list_contains(oformat->name, ',', name));
+    } while (oformat && !strlist_contains(oformat->name, ',', name));
    return oformat;
 }

@ -34,13 +34,11 @@ static struct record_packet *
 record_packet_new(const AVPacket *packet) {
    struct record_packet *rec = malloc(sizeof(*rec));
    if (!rec) {
-        LOG_OOM();
        return NULL;
    }

    rec->packet = av_packet_alloc();
    if (!rec->packet) {
-        LOG_OOM();
        free(rec);
        return NULL;
    }
@ -83,7 +81,7 @@ recorder_write_header(struct recorder *recorder, const AVPacket *packet) {

    uint8_t *extradata = av_malloc(packet->size * sizeof(uint8_t));
    if (!extradata) {
-        LOG_OOM();
+        LOGC("Could not allocate extradata");
        return false;
    }

@ -230,11 +228,13 @@ static bool
 recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
    bool ok = sc_mutex_init(&recorder->mutex);
    if (!ok) {
+        LOGC("Could not create mutex");
        return false;
    }

    ok = sc_cond_init(&recorder->queue_cond);
    if (!ok) {
+        LOGC("Could not create cond");
        goto error_mutex_destroy;
    }

@ -254,7 +254,7 @@ recorder_open(struct recorder *recorder, const AVCodec *input_codec) {

    recorder->ctx = avformat_alloc_context();
    if (!recorder->ctx) {
-        LOG_OOM();
+        LOGE("Could not allocate output context");
        goto error_cond_destroy;
    }

@ -338,7 +338,7 @@ recorder_push(struct recorder *recorder, const AVPacket *packet) {

    struct record_packet *rec = record_packet_new(packet);
    if (!rec) {
-        LOG_OOM();
+        LOGC("Could not allocate record packet");
        sc_mutex_unlock(&recorder->mutex);
        return false;
    }
@ -372,10 +372,10 @@ bool
 recorder_init(struct recorder *recorder,
              const char *filename,
              enum sc_record_format format,
-              struct sc_size declared_frame_size) {
+              struct size declared_frame_size) {
    recorder->filename = strdup(filename);
    if (!recorder->filename) {
-        LOG_OOM();
+        LOGE("Could not strdup filename");
        return false;
    }

--- a/app/src/recorder.h
+++ b/app/src/recorder.h
@ -7,7 +7,7 @@
 #include <libavformat/avformat.h>

 #include "coords.h"
-#include "options.h"
+#include "scrcpy.h"
 #include "trait/packet_sink.h"
 #include "util/queue.h"
 #include "util/thread.h"
@ -25,7 +25,7 @@ struct recorder {
    char *filename;
    enum sc_record_format format;
    AVFormatContext *ctx;
-    struct sc_size declared_frame_size;
+    struct size declared_frame_size;
    bool header_written;

    sc_thread thread;
@ -44,7 +44,7 @@ struct recorder {

 bool
 recorder_init(struct recorder *recorder, const char *filename,
-              enum sc_record_format format, struct sc_size declared_frame_size);
+              enum sc_record_format format, struct size declared_frame_size);

 void
 recorder_destroy(struct recorder *recorder);
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@ -27,7 +27,6 @@
 #include "screen.h"
 #include "server.h"
 #include "stream.h"
-#include "util/acksync.h"
 #include "util/log.h"
 #include "util/net.h"
 #ifdef HAVE_V4L2
@ -35,7 +34,7 @@
 #endif

 struct scrcpy {
-    struct sc_server server;
+    struct server server;
    struct screen screen;
    struct stream stream;
    struct decoder decoder;
@ -47,8 +46,6 @@ struct scrcpy {
    struct file_handler file_handler;
 #ifdef HAVE_AOA_HID
    struct sc_aoa aoa;
-    // sequence/ack helper to synchronize clipboard and Ctrl+v via HID
-    struct sc_acksync acksync;
 #endif
    union {
        struct sc_keyboard_inject keyboard_inject;
@ -60,30 +57,41 @@ struct scrcpy {
    struct input_manager input_manager;
 };

-static inline void
-push_event(uint32_t type, const char *name) {
-    SDL_Event event;
-    event.type = type;
-    int ret = SDL_PushEvent(&event);
-    if (ret < 0) {
-        LOGE("Could not post %s event: %s", name, SDL_GetError());
-        // What could we do?
-    }
-}
-#define PUSH_EVENT(TYPE) push_event(TYPE, # TYPE)
-
 #ifdef _WIN32
 BOOL WINAPI windows_ctrl_handler(DWORD ctrl_type) {
    if (ctrl_type == CTRL_C_EVENT) {
-        PUSH_EVENT(SDL_QUIT);
+        SDL_Event event;
+        event.type = SDL_QUIT;
+        SDL_PushEvent(&event);
        return TRUE;
    }
    return FALSE;
 }
 #endif // _WIN32

-static void
-sdl_set_hints(const char *render_driver) {
+// init SDL and set appropriate hints
+static bool
+sdl_init_and_configure(bool display, const char *render_driver,
+                       bool disable_screensaver) {
+    uint32_t flags = display ? SDL_INIT_VIDEO : SDL_INIT_EVENTS;
+    if (SDL_Init(flags)) {
+        LOGC("Could not initialize SDL: %s", SDL_GetError());
+        return false;
+    }
+
+    atexit(SDL_Quit);
+
+#ifdef _WIN32
+    // Clean up properly on Ctrl+C on Windows
+    bool ok = SetConsoleCtrlHandler(windows_ctrl_handler, TRUE);
+    if (!ok) {
+        LOGW("Could not set Ctrl+C handler");
+    }
+#endif // _WIN32
+
+    if (!display) {
+        return true;
+    }

    if (render_driver && !SDL_SetHint(SDL_HINT_RENDER_DRIVER, render_driver)) {
        LOGW("Could not set render driver");
@ -101,15 +109,6 @@ sdl_set_hints(const char *render_driver) {
    }
 #endif

-#ifdef SCRCPY_SDL_HAS_HINT_TOUCH_MOUSE_EVENTS
-    // Disable synthetic mouse events from touch events
-    // Touch events with id SDL_TOUCH_MOUSEID are ignored anyway, but it is
-    // better not to generate them in the first place.
-    if (!SDL_SetHint(SDL_HINT_TOUCH_MOUSE_EVENTS, "0")) {
-        LOGW("Could not disable synthetic mouse events");
-    }
-#endif
-
 #ifdef SCRCPY_SDL_HAS_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
    // Disable compositor bypassing on X11
    if (!SDL_SetHint(SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR, "0")) {
@ -121,21 +120,6 @@ sdl_set_hints(const char *render_driver) {
    if (!SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "0")) {
        LOGW("Could not disable minimize on focus loss");
    }
-}
-
-static void
-sdl_configure(bool display, bool disable_screensaver) {
-#ifdef _WIN32
-    // Clean up properly on Ctrl+C on Windows
-    bool ok = SetConsoleCtrlHandler(windows_ctrl_handler, TRUE);
-    if (!ok) {
-        LOGW("Could not set Ctrl+C handler");
-    }
-#endif // _WIN32
-
-    if (!display) {
-        return;
-    }

    if (disable_screensaver) {
        LOGD("Screensaver disabled");
@ -144,6 +128,8 @@ sdl_configure(bool display, bool disable_screensaver) {
        LOGD("Screensaver enabled");
        SDL_EnableScreenSaver();
    }
+
+    return true;
 }

 static bool
@ -220,29 +206,6 @@ event_loop(struct scrcpy *s, const struct scrcpy_options *options) {
    return false;
 }

-static bool
-await_for_server(void) {
-    SDL_Event event;
-    while (SDL_WaitEvent(&event)) {
-        switch (event.type) {
-            case SDL_QUIT:
-                LOGD("User requested to quit");
-                return false;
-            case EVENT_SERVER_CONNECTION_FAILED:
-                LOGE("Server connection failed");
-                return false;
-            case EVENT_SERVER_CONNECTED:
-                LOGD("Server connected");
-                return true;
-            default:
-                break;
-        }
-    }
-
-    LOGE("SDL_WaitEvent() error: %s", SDL_GetError());
-    return false;
-}
-
 static SDL_LogPriority
 sdl_priority_from_av_level(int level) {
    switch (level) {
@ -271,7 +234,7 @@ av_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
    size_t fmt_len = strlen(fmt);
    char *local_fmt = malloc(fmt_len + 10);
    if (!local_fmt) {
-        LOG_OOM();
+        LOGC("Could not allocate string");
        return;
    }
    memcpy(local_fmt, "[FFmpeg] ", 9); // do not write the final '\0'
@ -285,33 +248,9 @@ stream_on_eos(struct stream *stream, void *userdata) {
    (void) stream;
    (void) userdata;

-    PUSH_EVENT(EVENT_STREAM_STOPPED);
-}
-
-static void
-sc_server_on_connection_failed(struct sc_server *server, void *userdata) {
-    (void) server;
-    (void) userdata;
-
-    PUSH_EVENT(EVENT_SERVER_CONNECTION_FAILED);
-}
-
-static void
-sc_server_on_connected(struct sc_server *server, void *userdata) {
-    (void) server;
-    (void) userdata;
-
-    PUSH_EVENT(EVENT_SERVER_CONNECTED);
-}
-
-static void
-sc_server_on_disconnected(struct sc_server *server, void *userdata) {
-    (void) server;
-    (void) userdata;
-
-    LOGD("Server disconnected");
-    // Do nothing, the disconnection will be handled by the "stream stopped"
-    // event
+    SDL_Event stop_event;
+    stop_event.type = EVENT_STREAM_STOPPED;
+    SDL_PushEvent(&stop_event);
 }

 bool
@ -319,14 +258,10 @@ scrcpy(struct scrcpy_options *options) {
    static struct scrcpy scrcpy;
    struct scrcpy *s = &scrcpy;

-    // Minimal SDL initialization
-    if (SDL_Init(SDL_INIT_EVENTS)) {
-        LOGC("Could not initialize SDL: %s", SDL_GetError());
+    if (!server_init(&s->server)) {
        return false;
    }

-    atexit(SDL_Quit);
-
    bool ret = false;

    bool server_started = false;
@ -343,15 +278,12 @@ scrcpy(struct scrcpy_options *options) {
    bool controller_started = false;
    bool screen_initialized = false;

-    struct sc_acksync *acksync = NULL;
-
-    struct sc_server_params params = {
+    bool record = !!options->record_filename;
+    struct server_params params = {
        .serial = options->serial,
        .log_level = options->log_level,
        .crop = options->crop,
        .port_range = options->port_range,
-        .tunnel_host = options->tunnel_host,
-        .tunnel_port = options->tunnel_port,
        .max_size = options->max_size,
        .bit_rate = options->bit_rate,
        .max_fps = options->max_fps,
@ -364,51 +296,27 @@ scrcpy(struct scrcpy_options *options) {
        .encoder_name = options->encoder_name,
        .force_adb_forward = options->force_adb_forward,
        .power_off_on_close = options->power_off_on_close,
-        .clipboard_autosync = options->clipboard_autosync,
-        .tcpip = options->tcpip,
-        .tcpip_dst = options->tcpip_dst,
    };
-
-    static const struct sc_server_callbacks cbs = {
-        .on_connection_failed = sc_server_on_connection_failed,
-        .on_connected = sc_server_on_connected,
-        .on_disconnected = sc_server_on_disconnected,
-    };
-    if (!sc_server_init(&s->server, &params, &cbs, NULL)) {
-        return false;
-    }
-
-    if (!sc_server_start(&s->server)) {
+    if (!server_start(&s->server, &params)) {
        goto end;
    }

    server_started = true;

-    if (options->display) {
-        sdl_set_hints(options->render_driver);
-    }
-
-    // Initialize SDL video in addition if display is enabled
-    if (options->display && SDL_Init(SDL_INIT_VIDEO)) {
-        LOGC("Could not initialize SDL: %s", SDL_GetError());
+    if (!sdl_init_and_configure(options->display, options->render_driver,
+                                options->disable_screensaver)) {
        goto end;
    }

-    sdl_configure(options->display, options->disable_screensaver);
+    char device_name[DEVICE_NAME_FIELD_LENGTH];
+    struct size frame_size;

-    // Await for server without blocking Ctrl+C handling
-    if (!await_for_server()) {
+    if (!server_connect_to(&s->server, device_name, &frame_size)) {
        goto end;
    }

-    // It is necessarily initialized here, since the device is connected
-    struct sc_server_info *info = &s->server.info;
-
-    const char *serial = s->server.params.serial;
-    assert(serial);
-
    if (options->display && options->control) {
-        if (!file_handler_init(&s->file_handler, serial,
+        if (!file_handler_init(&s->file_handler, s->server.serial,
                               options->push_target)) {
            goto end;
        }
@ -426,11 +334,11 @@ scrcpy(struct scrcpy_options *options) {
    }

    struct recorder *rec = NULL;
-    if (options->record_filename) {
+    if (record) {
        if (!recorder_init(&s->recorder,
                           options->record_filename,
                           options->record_format,
-                           info->frame_size)) {
+                           frame_size)) {
            goto end;
        }
        rec = &s->recorder;
@ -453,18 +361,7 @@ scrcpy(struct scrcpy_options *options) {
    }

    if (options->control) {
-#ifdef HAVE_AOA_HID
-        if (options->keyboard_input_mode == SC_KEYBOARD_INPUT_MODE_HID) {
-            bool ok = sc_acksync_init(&s->acksync);
-            if (!ok) {
-                goto end;
-            }
-
-            acksync = &s->acksync;
-        }
-#endif
-        if (!controller_init(&s->controller, s->server.control_socket,
-                             acksync)) {
+        if (!controller_init(&s->controller, s->server.control_socket)) {
            goto end;
        }
        controller_initialized = true;
@ -487,11 +384,11 @@ scrcpy(struct scrcpy_options *options) {

    if (options->display) {
        const char *window_title =
-            options->window_title ? options->window_title : info->device_name;
+            options->window_title ? options->window_title : device_name;

        struct screen_params screen_params = {
            .window_title = window_title,
-            .frame_size = info->frame_size,
+            .frame_size = frame_size,
            .always_on_top = options->always_on_top,
            .window_x = options->window_x,
            .window_y = options->window_y,
@ -514,8 +411,8 @@ scrcpy(struct scrcpy_options *options) {

 #ifdef HAVE_V4L2
    if (options->v4l2_device) {
-        if (!sc_v4l2_sink_init(&s->v4l2_sink, options->v4l2_device,
-                               info->frame_size, options->v4l2_buffer)) {
+        if (!sc_v4l2_sink_init(&s->v4l2_sink, options->v4l2_device, frame_size,
+                               options->v4l2_buffer)) {
            goto end;
        }

@ -540,7 +437,21 @@ scrcpy(struct scrcpy_options *options) {
 #ifdef HAVE_AOA_HID
            bool aoa_hid_ok = false;

-            bool ok = sc_aoa_init(&s->aoa, serial, acksync);
+            char *serialno = NULL;
+
+            const char *serial = options->serial;
+            if (!serial) {
+                serialno = adb_get_serialno();
+                if (!serialno) {
+                    LOGE("Could not get device serial");
+                    goto aoa_hid_end;
+                }
+                serial = serialno;
+                LOGI("Device serial: %s", serial);
+            }
+
+            bool ok = sc_aoa_init(&s->aoa, serial);
+            free(serialno);
            if (!ok) {
                goto aoa_hid_end;
            }
@ -605,9 +516,6 @@ end:
        sc_hid_keyboard_destroy(&s->keyboard_hid);
        sc_aoa_stop(&s->aoa);
    }
-    if (acksync) {
-        sc_acksync_destroy(acksync);
-    }
 #endif
    if (controller_started) {
        controller_stop(&s->controller);
@ -621,7 +529,7 @@ end:

    if (server_started) {
        // shutdown the sockets and kill the server
-        sc_server_stop(&s->server);
+        server_stop(&s->server);
    }

    // now that the sockets are shutdown, the stream and controller are
@ -666,7 +574,7 @@ end:
        file_handler_destroy(&s->file_handler);
    }

-    sc_server_destroy(&s->server);
+    server_destroy(&s->server);

    return ret;
 }
--- a/app/src/scrcpy.h
+++ b/app/src/scrcpy.h
@ -4,7 +4,158 @@
 #include "common.h"

 #include <stdbool.h>
-#include "options.h"
+#include <stddef.h>
+#include <stdint.h>
+
+#include "util/tick.h"
+
+enum sc_log_level {
+    SC_LOG_LEVEL_VERBOSE,
+    SC_LOG_LEVEL_DEBUG,
+    SC_LOG_LEVEL_INFO,
+    SC_LOG_LEVEL_WARN,
+    SC_LOG_LEVEL_ERROR,
+};
+
+enum sc_record_format {
+    SC_RECORD_FORMAT_AUTO,
+    SC_RECORD_FORMAT_MP4,
+    SC_RECORD_FORMAT_MKV,
+};
+
+enum sc_lock_video_orientation {
+    SC_LOCK_VIDEO_ORIENTATION_UNLOCKED = -1,
+    // lock the current orientation when scrcpy starts
+    SC_LOCK_VIDEO_ORIENTATION_INITIAL = -2,
+    SC_LOCK_VIDEO_ORIENTATION_0 = 0,
+    SC_LOCK_VIDEO_ORIENTATION_1,
+    SC_LOCK_VIDEO_ORIENTATION_2,
+    SC_LOCK_VIDEO_ORIENTATION_3,
+};
+
+enum sc_keyboard_input_mode {
+    SC_KEYBOARD_INPUT_MODE_INJECT,
+    SC_KEYBOARD_INPUT_MODE_HID,
+};
+
+#define SC_MAX_SHORTCUT_MODS 8
+
+enum sc_shortcut_mod {
+    SC_MOD_LCTRL = 1 << 0,
+    SC_MOD_RCTRL = 1 << 1,
+    SC_MOD_LALT = 1 << 2,
+    SC_MOD_RALT = 1 << 3,
+    SC_MOD_LSUPER = 1 << 4,
+    SC_MOD_RSUPER = 1 << 5,
+};
+
+struct sc_shortcut_mods {
+    unsigned data[SC_MAX_SHORTCUT_MODS];
+    unsigned count;
+};
+
+struct sc_port_range {
+    uint16_t first;
+    uint16_t last;
+};
+
+#define SC_WINDOW_POSITION_UNDEFINED (-0x8000)
+
+struct scrcpy_options {
+    const char *serial;
+    const char *crop;
+    const char *record_filename;
+    const char *window_title;
+    const char *push_target;
+    const char *render_driver;
+    const char *codec_options;
+    const char *encoder_name;
+    const char *v4l2_device;
+    enum sc_log_level log_level;
+    enum sc_record_format record_format;
+    enum sc_keyboard_input_mode keyboard_input_mode;
+    struct sc_port_range port_range;
+    struct sc_shortcut_mods shortcut_mods;
+    uint16_t max_size;
+    uint32_t bit_rate;
+    uint16_t max_fps;
+    enum sc_lock_video_orientation lock_video_orientation;
+    uint8_t rotation;
+    int16_t window_x; // SC_WINDOW_POSITION_UNDEFINED for "auto"
+    int16_t window_y; // SC_WINDOW_POSITION_UNDEFINED for "auto"
+    uint16_t window_width;
+    uint16_t window_height;
+    uint32_t display_id;
+    sc_tick display_buffer;
+    sc_tick v4l2_buffer;
+    bool show_touches;
+    bool fullscreen;
+    bool always_on_top;
+    bool control;
+    bool display;
+    bool turn_screen_off;
+    bool prefer_text;
+    bool window_borderless;
+    bool mipmaps;
+    bool stay_awake;
+    bool force_adb_forward;
+    bool disable_screensaver;
+    bool forward_key_repeat;
+    bool forward_all_clicks;
+    bool legacy_paste;
+    bool power_off_on_close;
+};
+
+#define SCRCPY_OPTIONS_DEFAULT { \
+    .serial = NULL, \
+    .crop = NULL, \
+    .record_filename = NULL, \
+    .window_title = NULL, \
+    .push_target = NULL, \
+    .render_driver = NULL, \
+    .codec_options = NULL, \
+    .encoder_name = NULL, \
+    .v4l2_device = NULL, \
+    .log_level = SC_LOG_LEVEL_INFO, \
+    .record_format = SC_RECORD_FORMAT_AUTO, \
+    .keyboard_input_mode = SC_KEYBOARD_INPUT_MODE_INJECT, \
+    .port_range = { \
+        .first = DEFAULT_LOCAL_PORT_RANGE_FIRST, \
+        .last = DEFAULT_LOCAL_PORT_RANGE_LAST, \
+    }, \
+    .shortcut_mods = { \
+        .data = {SC_MOD_LALT, SC_MOD_LSUPER}, \
+        .count = 2, \
+    }, \
+    .max_size = 0, \
+    .bit_rate = DEFAULT_BIT_RATE, \
+    .max_fps = 0, \
+    .lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_UNLOCKED, \
+    .rotation = 0, \
+    .window_x = SC_WINDOW_POSITION_UNDEFINED, \
+    .window_y = SC_WINDOW_POSITION_UNDEFINED, \
+    .window_width = 0, \
+    .window_height = 0, \
+    .display_id = 0, \
+    .display_buffer = 0, \
+    .v4l2_buffer = 0, \
+    .show_touches = false, \
+    .fullscreen = false, \
+    .always_on_top = false, \
+    .control = true, \
+    .display = true, \
+    .turn_screen_off = false, \
+    .prefer_text = false, \
+    .window_borderless = false, \
+    .mipmaps = true, \
+    .stay_awake = false, \
+    .force_adb_forward = false, \
+    .disable_screensaver = false, \
+    .forward_key_repeat = true, \
+    .forward_all_clicks = false, \
+    .legacy_paste = false, \
+    .power_off_on_close = false, \
+}

 bool
 scrcpy(struct scrcpy_options *options);
--- a/app/src/screen.c
+++ b/app/src/screen.c
@ -6,7 +6,7 @@

 #include "events.h"
 #include "icon.h"
-#include "options.h"
+#include "scrcpy.h"
 #include "video_buffer.h"
 #include "util/log.h"

@ -14,9 +14,9 @@

 #define DOWNCAST(SINK) container_of(SINK, struct screen, frame_sink)

-static inline struct sc_size
-get_rotated_size(struct sc_size size, int rotation) {
-    struct sc_size rotated_size;
+static inline struct size
+get_rotated_size(struct size size, int rotation) {
+    struct size rotated_size;
    if (rotation & 1) {
        rotated_size.width = size.height;
        rotated_size.height = size.width;
@ -27,26 +27,26 @@ get_rotated_size(struct sc_size size, int rotation) {
    return rotated_size;
 }

-// get the window size in a struct sc_size
-static struct sc_size
+// get the window size in a struct size
+static struct size
 get_window_size(const struct screen *screen) {
    int width;
    int height;
    SDL_GetWindowSize(screen->window, &width, &height);

-    struct sc_size size;
+    struct size size;
    size.width = width;
    size.height = height;
    return size;
 }

-static struct sc_point
+static struct point
 get_window_position(const struct screen *screen) {
    int x;
    int y;
    SDL_GetWindowPosition(screen->window, &x, &y);

-    struct sc_point point;
+    struct point point;
    point.x = x;
    point.y = y;
    return point;
@ -54,7 +54,7 @@ get_window_position(const struct screen *screen) {

 // set the window size to be applied when fullscreen is disabled
 static void
-set_window_size(struct screen *screen, struct sc_size new_size) {
+set_window_size(struct screen *screen, struct size new_size) {
    assert(!screen->fullscreen);
    assert(!screen->maximized);
    SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
@ -62,7 +62,7 @@ set_window_size(struct screen *screen, struct sc_size new_size) {

 // get the preferred display bounds (i.e. the screen bounds with some margins)
 static bool
-get_preferred_display_bounds(struct sc_size *bounds) {
+get_preferred_display_bounds(struct size *bounds) {
    SDL_Rect rect;
 #ifdef SCRCPY_SDL_HAS_GET_DISPLAY_USABLE_BOUNDS
 # define GET_DISPLAY_BOUNDS(i, r) SDL_GetDisplayUsableBounds((i), (r))
@ -80,7 +80,7 @@ get_preferred_display_bounds(struct sc_size *bounds) {
 }

 static bool
-is_optimal_size(struct sc_size current_size, struct sc_size content_size) {
+is_optimal_size(struct size current_size, struct size content_size) {
    // The size is optimal if we can recompute one dimension of the current
    // size from the other
    return current_size.height == current_size.width * content_size.height
@ -94,16 +94,16 @@ is_optimal_size(struct sc_size current_size, struct sc_size content_size) {
 //    crops the black borders)
 //  - it keeps the aspect ratio
 //  - it scales down to make it fit in the display_size
-static struct sc_size
-get_optimal_size(struct sc_size current_size, struct sc_size content_size) {
+static struct size
+get_optimal_size(struct size current_size, struct size content_size) {
    if (content_size.width == 0 || content_size.height == 0) {
        // avoid division by 0
        return current_size;
    }

-    struct sc_size window_size;
+    struct size window_size;

-    struct sc_size display_size;
+    struct size display_size;
    if (!get_preferred_display_bounds(&display_size)) {
        // could not get display bounds, do not constraint the size
        window_size.width = current_size.width;
@ -135,10 +135,10 @@ get_optimal_size(struct sc_size current_size, struct sc_size content_size) {

 // initially, there is no current size, so use the frame size as current size
 // req_width and req_height, if not 0, are the sizes requested by the user
-static inline struct sc_size
-get_initial_optimal_size(struct sc_size content_size, uint16_t req_width,
+static inline struct size
+get_initial_optimal_size(struct size content_size, uint16_t req_width,
                         uint16_t req_height) {
-    struct sc_size window_size;
+    struct size window_size;
    if (!req_width && !req_height) {
        window_size = get_optimal_size(content_size, content_size);
    } else {
@ -166,9 +166,9 @@ screen_update_content_rect(struct screen *screen) {
    int dh;
    SDL_GL_GetDrawableSize(screen->window, &dw, &dh);

-    struct sc_size content_size = screen->content_size;
+    struct size content_size = screen->content_size;
    // The drawable size is the window size * the HiDPI scale
-    struct sc_size drawable_size = {dw, dh};
+    struct size drawable_size = {dw, dh};

    SDL_Rect *rect = &screen->rect;

@ -200,7 +200,7 @@ screen_update_content_rect(struct screen *screen) {
 static inline SDL_Texture *
 create_texture(struct screen *screen) {
    SDL_Renderer *renderer = screen->renderer;
-    struct sc_size size = screen->frame_size;
+    struct size size = screen->frame_size;
    SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
                                             SDL_TEXTUREACCESS_STREAMING,
                                             size.width, size.height);
@ -224,45 +224,6 @@ create_texture(struct screen *screen) {
    return texture;
 }

-// render the texture to the renderer
-//
-// Set the update_content_rect flag if the window or content size may have
-// changed, so that the content rectangle is recomputed
-static void
-screen_render(struct screen *screen, bool update_content_rect) {
-    if (update_content_rect) {
-        screen_update_content_rect(screen);
-    }
-
-    SDL_RenderClear(screen->renderer);
-    if (screen->rotation == 0) {
-        SDL_RenderCopy(screen->renderer, screen->texture, NULL, &screen->rect);
-    } else {
-        // rotation in RenderCopyEx() is clockwise, while screen->rotation is
-        // counterclockwise (to be consistent with --lock-video-orientation)
-        int cw_rotation = (4 - screen->rotation) % 4;
-        double angle = 90 * cw_rotation;
-
-        SDL_Rect *dstrect = NULL;
-        SDL_Rect rect;
-        if (screen->rotation & 1) {
-            rect.x = screen->rect.x + (screen->rect.w - screen->rect.h) / 2;
-            rect.y = screen->rect.y + (screen->rect.h - screen->rect.w) / 2;
-            rect.w = screen->rect.h;
-            rect.h = screen->rect.w;
-            dstrect = &rect;
-        } else {
-            assert(screen->rotation == 2);
-            dstrect = &screen->rect;
-        }
-
-        SDL_RenderCopyEx(screen->renderer, screen->texture, NULL, dstrect,
-                         angle, NULL, 0);
-    }
-    SDL_RenderPresent(screen->renderer);
-}
-
-
 #if defined(__APPLE__) || defined(__WINDOWS__)
 # define CONTINUOUS_RESIZING_WORKAROUND
 #endif
@ -321,33 +282,17 @@ sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
    (void) vb;
    struct screen *screen = userdata;

-    // event_failed implies previous_skipped (the previous frame may not have
-    // been consumed if the event was not sent)
-    assert(!screen->event_failed || previous_skipped);
-
-    bool need_new_event;
    if (previous_skipped) {
        fps_counter_add_skipped_frame(&screen->fps_counter);
        // The EVENT_NEW_FRAME triggered for the previous frame will consume
-        // this new frame instead, unless the previous event failed
-        need_new_event = screen->event_failed;
+        // this new frame instead
    } else {
-        need_new_event = true;
-    }
-
-    if (need_new_event) {
        static SDL_Event new_frame_event = {
            .type = EVENT_NEW_FRAME,
        };

        // Post the event on the UI thread
-        int ret = SDL_PushEvent(&new_frame_event);
-        if (ret < 0) {
-            LOGW("Could not post new frame event: %s", SDL_GetError());
-            screen->event_failed = true;
-        } else {
-            screen->event_failed = false;
-        }
+        SDL_PushEvent(&new_frame_event);
    }
 }

@ -357,7 +302,6 @@ screen_init(struct screen *screen, const struct screen_params *params) {
    screen->has_frame = false;
    screen->fullscreen = false;
    screen->maximized = false;
-    screen->event_failed = false;

    static const struct sc_video_buffer_callbacks cbs = {
        .on_new_frame = sc_video_buffer_on_new_frame,
@ -366,15 +310,18 @@ screen_init(struct screen *screen, const struct screen_params *params) {
    bool ok = sc_video_buffer_init(&screen->vb, params->buffering_time, &cbs,
                                   screen);
    if (!ok) {
+        LOGE("Could not initialize video buffer");
        return false;
    }

    ok = sc_video_buffer_start(&screen->vb);
    if (!ok) {
+        LOGE("Could not start video_buffer");
        goto error_destroy_video_buffer;
    }

    if (!fps_counter_init(&screen->fps_counter)) {
+        LOGE("Could not initialize FPS counter");
        goto error_stop_and_join_video_buffer;
    }

@ -383,13 +330,13 @@ screen_init(struct screen *screen, const struct screen_params *params) {
    if (screen->rotation) {
        LOGI("Initial display rotation set to %u", screen->rotation);
    }
-    struct sc_size content_size =
+    struct size content_size =
        get_rotated_size(screen->frame_size, screen->rotation);
    screen->content_size = content_size;

-    struct sc_size window_size =
-        get_initial_optimal_size(content_size,params->window_width,
-                                 params->window_height);
+    struct size window_size = get_initial_optimal_size(content_size,
+                                                       params->window_width,
+                                                       params->window_height);
    uint32_t window_flags = SDL_WINDOW_HIDDEN
                          | SDL_WINDOW_RESIZABLE
                          | SDL_WINDOW_ALLOW_HIGHDPI;
@ -475,7 +422,7 @@ screen_init(struct screen *screen, const struct screen_params *params) {

    screen->frame = av_frame_alloc();
    if (!screen->frame) {
-        LOG_OOM();
+        LOGC("Could not create screen frame");
        goto error_destroy_texture;
    }

@ -561,10 +508,10 @@ screen_destroy(struct screen *screen) {
 }

 static void
-resize_for_content(struct screen *screen, struct sc_size old_content_size,
-                   struct sc_size new_content_size) {
-    struct sc_size window_size = get_window_size(screen);
-    struct sc_size target_size = {
+resize_for_content(struct screen *screen, struct size old_content_size,
+                                                 struct size new_content_size) {
+    struct size window_size = get_window_size(screen);
+    struct size target_size = {
        .width = (uint32_t) window_size.width * new_content_size.width
                / old_content_size.width,
        .height = (uint32_t) window_size.height * new_content_size.height
@ -575,7 +522,7 @@ resize_for_content(struct screen *screen, struct sc_size old_content_size,
 }

 static void
-set_content_size(struct screen *screen, struct sc_size new_content_size) {
+set_content_size(struct screen *screen, struct size new_content_size) {
    if (!screen->fullscreen && !screen->maximized) {
        resize_for_content(screen, screen->content_size, new_content_size);
    } else if (!screen->resize_pending) {
@ -606,7 +553,7 @@ screen_set_rotation(struct screen *screen, unsigned rotation) {
        return;
    }

-    struct sc_size new_content_size =
+    struct size new_content_size =
        get_rotated_size(screen->frame_size, rotation);

    set_content_size(screen, new_content_size);
@ -619,7 +566,7 @@ screen_set_rotation(struct screen *screen, unsigned rotation) {

 // recreate the texture and resize the window if the frame size has changed
 static bool
-prepare_for_frame(struct screen *screen, struct sc_size new_frame_size) {
+prepare_for_frame(struct screen *screen, struct size new_frame_size) {
    if (screen->frame_size.width != new_frame_size.width
            || screen->frame_size.height != new_frame_size.height) {
        // frame dimension changed, destroy texture
@ -627,7 +574,7 @@ prepare_for_frame(struct screen *screen, struct sc_size new_frame_size) {

        screen->frame_size = new_frame_size;

-        struct sc_size new_content_size =
+        struct size new_content_size =
            get_rotated_size(new_frame_size, screen->rotation);
        set_content_size(screen, new_content_size);

@ -668,7 +615,7 @@ screen_update_frame(struct screen *screen) {

    fps_counter_add_rendered_frame(&screen->fps_counter);

-    struct sc_size new_frame_size = {frame->width, frame->height};
+    struct size new_frame_size = {frame->width, frame->height};
    if (!prepare_for_frame(screen, new_frame_size)) {
        return false;
    }
@ -678,6 +625,40 @@ screen_update_frame(struct screen *screen) {
    return true;
 }

+void
+screen_render(struct screen *screen, bool update_content_rect) {
+    if (update_content_rect) {
+        screen_update_content_rect(screen);
+    }
+
+    SDL_RenderClear(screen->renderer);
+    if (screen->rotation == 0) {
+        SDL_RenderCopy(screen->renderer, screen->texture, NULL, &screen->rect);
+    } else {
+        // rotation in RenderCopyEx() is clockwise, while screen->rotation is
+        // counterclockwise (to be consistent with --lock-video-orientation)
+        int cw_rotation = (4 - screen->rotation) % 4;
+        double angle = 90 * cw_rotation;
+
+        SDL_Rect *dstrect = NULL;
+        SDL_Rect rect;
+        if (screen->rotation & 1) {
+            rect.x = screen->rect.x + (screen->rect.w - screen->rect.h) / 2;
+            rect.y = screen->rect.y + (screen->rect.h - screen->rect.w) / 2;
+            rect.w = screen->rect.h;
+            rect.h = screen->rect.w;
+            dstrect = &rect;
+        } else {
+            assert(screen->rotation == 2);
+            dstrect = &screen->rect;
+        }
+
+        SDL_RenderCopyEx(screen->renderer, screen->texture, NULL, dstrect,
+                         angle, NULL, 0);
+    }
+    SDL_RenderPresent(screen->renderer);
+}
+
 void
 screen_switch_fullscreen(struct screen *screen) {
    uint32_t new_mode = screen->fullscreen ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP;
@ -701,10 +682,10 @@ screen_resize_to_fit(struct screen *screen) {
        return;
    }

-    struct sc_point point = get_window_position(screen);
-    struct sc_size window_size = get_window_size(screen);
+    struct point point = get_window_position(screen);
+    struct size window_size = get_window_size(screen);

-    struct sc_size optimal_size =
+    struct size optimal_size =
        get_optimal_size(window_size, screen->content_size);

    // Center the window related to the device screen
@ -730,7 +711,7 @@ screen_resize_to_pixel_perfect(struct screen *screen) {
        screen->maximized = false;
    }

-    struct sc_size content_size = screen->content_size;
+    struct size content_size = screen->content_size;
    SDL_SetWindowSize(screen->window, content_size.width, content_size.height);
    LOGD("Resized to pixel-perfect: %ux%u", content_size.width,
                                            content_size.height);
@ -785,7 +766,7 @@ screen_handle_event(struct screen *screen, SDL_Event *event) {
    return false;
 }

-struct sc_point
+struct point
 screen_convert_drawable_to_frame_coords(struct screen *screen,
                                        int32_t x, int32_t y) {
    unsigned rotation = screen->rotation;
@ -799,7 +780,7 @@ screen_convert_drawable_to_frame_coords(struct screen *screen,
    y = (int64_t) (y - screen->rect.y) * h / screen->rect.h;

    // rotate
-    struct sc_point result;
+    struct point result;
    switch (rotation) {
        case 0:
            result.x = x;
@ -822,7 +803,7 @@ screen_convert_drawable_to_frame_coords(struct screen *screen,
    return result;
 }

-struct sc_point
+struct point
 screen_convert_window_to_frame_coords(struct screen *screen,
                                      int32_t x, int32_t y) {
    screen_hidpi_scale_coords(screen, &x, &y);
--- a/app/src/screen.h
+++ b/app/src/screen.h
@ -27,13 +27,13 @@ struct screen {
    SDL_Renderer *renderer;
    SDL_Texture *texture;
    struct sc_opengl gl;
-    struct sc_size frame_size;
-    struct sc_size content_size; // rotated frame_size
+    struct size frame_size;
+    struct size content_size; // rotated frame_size

    bool resize_pending; // resize requested while fullscreen or maximized
    // The content size the last time the window was not maximized or
    // fullscreen (meaningful only when resize_pending is true)
-    struct sc_size windowed_content_size;
+    struct size windowed_content_size;

    // client rotation: 0, 1, 2 or 3 (x90 degrees counterclockwise)
    unsigned rotation;
@ -44,14 +44,12 @@ struct screen {
    bool maximized;
    bool mipmaps;

-    bool event_failed; // in case SDL_PushEvent() returned an error
-
    AVFrame *frame;
 };

 struct screen_params {
    const char *window_title;
-    struct sc_size frame_size;
+    struct size frame_size;
    bool always_on_top;

    int16_t window_x;
@ -93,6 +91,13 @@ screen_destroy(struct screen *screen);
 void
 screen_hide_window(struct screen *screen);

+// render the texture to the renderer
+//
+// Set the update_content_rect flag if the window or content size may have
+// changed, so that the content rectangle is recomputed
+void
+screen_render(struct screen *screen, bool update_content_rect);
+
 // switch the fullscreen mode
 void
 screen_switch_fullscreen(struct screen *screen);
@ -115,13 +120,13 @@ screen_handle_event(struct screen *screen, SDL_Event *event);

 // convert point from window coordinates to frame coordinates
 // x and y are expressed in pixels
-struct sc_point
+struct point
 screen_convert_window_to_frame_coords(struct screen *screen,
                                      int32_t x, int32_t y);

 // convert point from drawable coordinates to frame coordinates
 // x and y are expressed in pixels
-struct sc_point
+struct point
 screen_convert_drawable_to_frame_coords(struct screen *screen,
                                        int32_t x, int32_t y);

--- a/app/src/server.c
+++ b/app/src/server.c
--- a/app/src/server.h
+++ b/app/src/server.h
@ -8,29 +8,36 @@
 #include <stdint.h>

 #include "adb.h"
-#include "adb_tunnel.h"
 #include "coords.h"
-#include "options.h"
-#include "util/intr.h"
+#include "scrcpy.h"
 #include "util/log.h"
 #include "util/net.h"
 #include "util/thread.h"

-#define SC_DEVICE_NAME_FIELD_LENGTH 64
-struct sc_server_info {
-    char device_name[SC_DEVICE_NAME_FIELD_LENGTH];
-    struct sc_size frame_size;
+struct server {
+    char *serial;
+    process_t process;
+    sc_thread wait_server_thread;
+
+    sc_mutex mutex;
+    sc_cond process_terminated_cond;
+    bool process_terminated;
+
+    sc_socket server_socket; // only used if !tunnel_forward
+    sc_socket video_socket;
+    sc_socket control_socket;
+    uint16_t local_port; // selected from port_range
+    bool tunnel_enabled;
+    bool tunnel_forward; // use "adb forward" instead of "adb reverse"
 };

-struct sc_server_params {
+struct server_params {
    const char *serial;
    enum sc_log_level log_level;
    const char *crop;
    const char *codec_options;
    const char *encoder_name;
    struct sc_port_range port_range;
-    uint32_t tunnel_host;
-    uint16_t tunnel_port;
    uint16_t max_size;
    uint32_t bit_rate;
    uint16_t max_fps;
@ -41,67 +48,28 @@ struct sc_server_params {
    bool stay_awake;
    bool force_adb_forward;
    bool power_off_on_close;
-    bool clipboard_autosync;
-    bool tcpip;
-    const char *tcpip_dst;
 };

-struct sc_server {
-    // The internal allocated strings are copies owned by the server
-    struct sc_server_params params;
-
-    sc_thread thread;
-    struct sc_server_info info; // initialized once connected
-
-    sc_mutex mutex;
-    sc_cond cond_stopped;
-    bool stopped;
-
-    struct sc_intr intr;
-    struct sc_adb_tunnel tunnel;
-
-    sc_socket video_socket;
-    sc_socket control_socket;
-
-    const struct sc_server_callbacks *cbs;
-    void *cbs_userdata;
-};
-
-struct sc_server_callbacks {
-    /**
-     * Called when the server failed to connect
-     *
-     * If it is called, then on_connected() and on_disconnected() will never be
-     * called.
-     */
-    void (*on_connection_failed)(struct sc_server *server, void *userdata);
-
-    /**
-     * Called on server connection
-     */
-    void (*on_connected)(struct sc_server *server, void *userdata);
-
-    /**
-     * Called on server disconnection (after it has been connected)
-     */
-    void (*on_disconnected)(struct sc_server *server, void *userdata);
-};
-
-// init the server with the given params
+// init default values
 bool
-sc_server_init(struct sc_server *server, const struct sc_server_params *params,
-               const struct sc_server_callbacks *cbs, void *cbs_userdata);
+server_init(struct server *server);

-// start the server asynchronously
+// push, enable tunnel et start the server
 bool
-sc_server_start(struct sc_server *server);
+server_start(struct server *server, const struct server_params *params);
+
+#define DEVICE_NAME_FIELD_LENGTH 64
+// block until the communication with the server is established
+// device_name must point to a buffer of at least DEVICE_NAME_FIELD_LENGTH bytes
+bool
+server_connect_to(struct server *server, char *device_name, struct size *size);

 // disconnect and kill the server process
 void
-sc_server_stop(struct sc_server *server);
+server_stop(struct server *server);

 // close and release sockets
 void
-sc_server_destroy(struct sc_server *server);
+server_destroy(struct server *server);

 #endif
--- a/app/src/stream.c
+++ b/app/src/stream.c
@ -42,7 +42,7 @@ stream_recv_packet(struct stream *stream, AVPacket *packet) {
    assert(len);

    if (av_new_packet(packet, len)) {
-        LOG_OOM();
+        LOGE("Could not allocate packet");
        return false;
    }

@ -111,18 +111,18 @@ stream_push_packet(struct stream *stream, AVPacket *packet) {
        if (stream->pending) {
            offset = stream->pending->size;
            if (av_grow_packet(stream->pending, packet->size)) {
-                LOG_OOM();
+                LOGE("Could not grow packet");
                return false;
            }
        } else {
            offset = 0;
            stream->pending = av_packet_alloc();
            if (!stream->pending) {
-                LOG_OOM();
+                LOGE("Could not allocate packet");
                return false;
            }
            if (av_new_packet(stream->pending, packet->size)) {
-                LOG_OOM();
+                LOGE("Could not create packet");
                av_packet_free(&stream->pending);
                return false;
            }
@ -200,7 +200,7 @@ run_stream(void *data) {

    stream->codec_ctx = avcodec_alloc_context3(codec);
    if (!stream->codec_ctx) {
-        LOG_OOM();
+        LOGC("Could not allocate codec context");
        goto end;
    }

@ -221,7 +221,7 @@ run_stream(void *data) {

    AVPacket *packet = av_packet_alloc();
    if (!packet) {
-        LOG_OOM();
+        LOGE("Could not allocate packet");
        goto finally_close_parser;
    }

--- a/app/src/sys/unix/file.c
+++ b/app/src/sys/unix/file.c
@ -1,81 +0,0 @@
-#include "util/file.h"
-
-#include <limits.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <unistd.h>
-
-#include "util/log.h"
-
-bool
-sc_file_executable_exists(const char *file) {
-    char *path = getenv("PATH");
-    if (!path)
-        return false;
-    path = strdup(path);
-    if (!path)
-        return false;
-
-    bool ret = false;
-    size_t file_len = strlen(file);
-    char *saveptr;
-    for (char *dir = strtok_r(path, ":", &saveptr); dir;
-            dir = strtok_r(NULL, ":", &saveptr)) {
-        size_t dir_len = strlen(dir);
-        char *fullpath = malloc(dir_len + file_len + 2);
-        if (!fullpath)
-        {
-            LOG_OOM();
-            continue;
-        }
-        memcpy(fullpath, dir, dir_len);
-        fullpath[dir_len] = '/';
-        memcpy(fullpath + dir_len + 1, file, file_len + 1);
-
-        struct stat sb;
-        bool fullpath_executable = stat(fullpath, &sb) == 0 &&
-            sb.st_mode & S_IXUSR;
-        free(fullpath);
-        if (fullpath_executable) {
-            ret = true;
-            break;
-        }
-    }
-
-    free(path);
-    return ret;
-}
-
-char *
-sc_file_get_executable_path(void) {
-// <https://stackoverflow.com/a/1024937/1987178>
-#ifdef __linux__
-    char buf[PATH_MAX + 1]; // +1 for the null byte
-    ssize_t len = readlink("/proc/self/exe", buf, PATH_MAX);
-    if (len == -1) {
-        perror("readlink");
-        return NULL;
-    }
-    buf[len] = '\0';
-    return strdup(buf);
-#else
-    // in practice, we only need this feature for portable builds, only used on
-    // Windows, so we don't care implementing it for every platform
-    // (it's useful to have a working version on Linux for debugging though)
-    return NULL;
-#endif
-}
-
-bool
-sc_file_is_regular(const char *path) {
-    struct stat path_stat;
-
-    if (stat(path, &path_stat)) {
-        perror("stat");
-        return false;
-    }
-    return S_ISREG(path_stat.st_mode);
-}
-
--- a/app/src/sys/unix/process.c
+++ b/app/src/sys/unix/process.c
@ -3,19 +3,56 @@
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <limits.h>
 #include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>

 #include "util/log.h"

-enum sc_process_result
-sc_process_execute_p(const char *const argv[], sc_pid *pid, unsigned flags,
-                     int *pin, int *pout, int *perr) {
-    bool inherit_stdout = !pout && !(flags & SC_PROCESS_NO_STDOUT);
-    bool inherit_stderr = !perr && !(flags & SC_PROCESS_NO_STDERR);
+bool
+search_executable(const char *file) {
+    char *path = getenv("PATH");
+    if (!path)
+        return false;
+    path = strdup(path);
+    if (!path)
+        return false;

+    bool ret = false;
+    size_t file_len = strlen(file);
+    char *saveptr;
+    for (char *dir = strtok_r(path, ":", &saveptr); dir;
+            dir = strtok_r(NULL, ":", &saveptr)) {
+        size_t dir_len = strlen(dir);
+        char *fullpath = malloc(dir_len + file_len + 2);
+        if (!fullpath)
+            continue;
+        memcpy(fullpath, dir, dir_len);
+        fullpath[dir_len] = '/';
+        memcpy(fullpath + dir_len + 1, file, file_len + 1);
+
+        struct stat sb;
+        bool fullpath_executable = stat(fullpath, &sb) == 0 &&
+            sb.st_mode & S_IXUSR;
+        free(fullpath);
+        if (fullpath_executable) {
+            ret = true;
+            break;
+        }
+    }
+
+    free(path);
+    return ret;
+}
+
+enum process_result
+process_execute_redirect(const char *const argv[], pid_t *pid, int *pipe_stdin,
+                     int *pipe_stdout, int *pipe_stderr) {
    int in[2];
    int out[2];
    int err[2];
@ -23,44 +60,44 @@ sc_process_execute_p(const char *const argv[], sc_pid *pid, unsigned flags,

    if (pipe(internal) == -1) {
        perror("pipe");
-        return SC_PROCESS_ERROR_GENERIC;
+        return PROCESS_ERROR_GENERIC;
    }
-    if (pin) {
+    if (pipe_stdin) {
        if (pipe(in) == -1) {
            perror("pipe");
            close(internal[0]);
            close(internal[1]);
-            return SC_PROCESS_ERROR_GENERIC;
+            return PROCESS_ERROR_GENERIC;
        }
    }
-    if (pout) {
+    if (pipe_stdout) {
        if (pipe(out) == -1) {
            perror("pipe");
            // clean up
-            if (pin) {
+            if (pipe_stdin) {
                close(in[0]);
                close(in[1]);
            }
            close(internal[0]);
            close(internal[1]);
-            return SC_PROCESS_ERROR_GENERIC;
+            return PROCESS_ERROR_GENERIC;
        }
    }
-    if (perr) {
+    if (pipe_stderr) {
        if (pipe(err) == -1) {
            perror("pipe");
            // clean up
-            if (pout) {
+            if (pipe_stdout) {
                close(out[0]);
                close(out[1]);
            }
-            if (pin) {
+            if (pipe_stdin) {
                close(in[0]);
                close(in[1]);
            }
            close(internal[0]);
            close(internal[1]);
-            return SC_PROCESS_ERROR_GENERIC;
+            return PROCESS_ERROR_GENERIC;
        }
    }

@ -68,65 +105,55 @@ sc_process_execute_p(const char *const argv[], sc_pid *pid, unsigned flags,
    if (*pid == -1) {
        perror("fork");
        // clean up
-        if (perr) {
+        if (pipe_stderr) {
            close(err[0]);
            close(err[1]);
        }
-        if (pout) {
+        if (pipe_stdout) {
            close(out[0]);
            close(out[1]);
        }
-        if (pin) {
+        if (pipe_stdin) {
            close(in[0]);
            close(in[1]);
        }
        close(internal[0]);
        close(internal[1]);
-        return SC_PROCESS_ERROR_GENERIC;
+        return PROCESS_ERROR_GENERIC;
    }

    if (*pid == 0) {
-        if (pin) {
+        if (pipe_stdin) {
            if (in[0] != STDIN_FILENO) {
                dup2(in[0], STDIN_FILENO);
                close(in[0]);
            }
            close(in[1]);
        }
-        // Do not close stdin in the child process, this makes adb fail on Linux
-
-        if (pout) {
+        if (pipe_stdout) {
            if (out[1] != STDOUT_FILENO) {
                dup2(out[1], STDOUT_FILENO);
                close(out[1]);
            }
            close(out[0]);
-        } else if (!inherit_stdout) {
-            // Close stdout in the child process
-            close(STDOUT_FILENO);
        }
-
-        if (perr) {
+        if (pipe_stderr) {
            if (err[1] != STDERR_FILENO) {
                dup2(err[1], STDERR_FILENO);
                close(err[1]);
            }
            close(err[0]);
-        } else if (!inherit_stderr) {
-            // Close stderr in the child process
-            close(STDERR_FILENO);
        }
-
        close(internal[0]);
-        enum sc_process_result err;
+        enum process_result err;
        if (fcntl(internal[1], F_SETFD, FD_CLOEXEC) == 0) {
            execvp(argv[0], (char *const *) argv);
            perror("exec");
-            err = errno == ENOENT ? SC_PROCESS_ERROR_MISSING_BINARY
-                                  : SC_PROCESS_ERROR_GENERIC;
+            err = errno == ENOENT ? PROCESS_ERROR_MISSING_BINARY
+                                  : PROCESS_ERROR_GENERIC;
        } else {
            perror("fcntl");
-            err = SC_PROCESS_ERROR_GENERIC;
+            err = PROCESS_ERROR_GENERIC;
        }
        // send err to the parent
        if (write(internal[1], &err, sizeof(err)) == -1) {
@ -141,33 +168,38 @@ sc_process_execute_p(const char *const argv[], sc_pid *pid, unsigned flags,

    close(internal[1]);

-    enum sc_process_result res = SC_PROCESS_SUCCESS;
+    enum process_result res = PROCESS_SUCCESS;
    // wait for EOF or receive err from child
    if (read(internal[0], &res, sizeof(res)) == -1) {
        perror("read");
-        res = SC_PROCESS_ERROR_GENERIC;
+        res = PROCESS_ERROR_GENERIC;
    }

    close(internal[0]);

-    if (pin) {
+    if (pipe_stdin) {
        close(in[0]);
-        *pin = in[1];
+        *pipe_stdin = in[1];
    }
-    if (pout) {
-        *pout = out[0];
+    if (pipe_stdout) {
+        *pipe_stdout = out[0];
        close(out[1]);
    }
-    if (perr) {
-        *perr = err[0];
+    if (pipe_stderr) {
+        *pipe_stderr = err[0];
        close(err[1]);
    }

    return res;
 }

+enum process_result
+process_execute(const char *const argv[], pid_t *pid) {
+    return process_execute_redirect(argv, pid, NULL, NULL, NULL);
+}
+
 bool
-sc_process_terminate(pid_t pid) {
+process_terminate(pid_t pid) {
    if (pid <= 0) {
        LOGC("Requested to kill %d, this is an error. Please report the bug.\n",
             (int) pid);
@ -176,8 +208,8 @@ sc_process_terminate(pid_t pid) {
    return kill(pid, SIGKILL) != -1;
 }

-sc_exit_code
-sc_process_wait(pid_t pid, bool close) {
+exit_code_t
+process_wait(pid_t pid, bool close) {
    int code;
    int options = WEXITED;
    if (!close) {
@ -188,7 +220,7 @@ sc_process_wait(pid_t pid, bool close) {
    int r = waitid(P_PID, pid, &info, options);
    if (r == -1 || info.si_code != CLD_EXITED) {
        // could not wait, or exited unexpectedly, probably by a signal
-        code = SC_EXIT_CODE_NONE;
+        code = NO_EXIT_CODE;
    } else {
        code = info.si_status;
    }
@ -196,17 +228,48 @@ sc_process_wait(pid_t pid, bool close) {
 }

 void
-sc_process_close(pid_t pid) {
-    sc_process_wait(pid, true); // ignore exit code
+process_close(pid_t pid) {
+    process_wait(pid, true); // ignore exit code
+}
+
+char *
+get_executable_path(void) {
+// <https://stackoverflow.com/a/1024937/1987178>
+#ifdef __linux__
+    char buf[PATH_MAX + 1]; // +1 for the null byte
+    ssize_t len = readlink("/proc/self/exe", buf, PATH_MAX);
+    if (len == -1) {
+        perror("readlink");
+        return NULL;
+    }
+    buf[len] = '\0';
+    return strdup(buf);
+#else
+    // in practice, we only need this feature for portable builds, only used on
+    // Windows, so we don't care implementing it for every platform
+    // (it's useful to have a working version on Linux for debugging though)
+    return NULL;
+#endif
+}
+
+bool
+is_regular_file(const char *path) {
+    struct stat path_stat;
+
+    if (stat(path, &path_stat)) {
+        perror("stat");
+        return false;
+    }
+    return S_ISREG(path_stat.st_mode);
 }

 ssize_t
-sc_pipe_read(int pipe, char *data, size_t len) {
+read_pipe(int pipe, char *data, size_t len) {
    return read(pipe, data, len);
 }

 void
-sc_pipe_close(int pipe) {
+close_pipe(int pipe) {
    if (close(pipe)) {
        perror("close pipe");
    }
--- a/app/src/sys/win/file.c
+++ b/app/src/sys/win/file.c
@ -1,43 +0,0 @@
-#include "util/file.h"
-
-#include <windows.h>
-
-#include <sys/stat.h>
-
-#include "util/log.h"
-#include "util/str.h"
-
-char *
-sc_file_get_executable_path(void) {
-    HMODULE hModule = GetModuleHandleW(NULL);
-    if (!hModule) {
-        return NULL;
-    }
-    WCHAR buf[MAX_PATH + 1]; // +1 for the null byte
-    int len = GetModuleFileNameW(hModule, buf, MAX_PATH);
-    if (!len) {
-        return NULL;
-    }
-    buf[len] = '\0';
-    return sc_str_from_wchars(buf);
-}
-
-bool
-sc_file_is_regular(const char *path) {
-    wchar_t *wide_path = sc_str_to_wchars(path);
-    if (!wide_path) {
-        LOG_OOM();
-        return false;
-    }
-
-    struct _stat path_stat;
-    int r = _wstat(wide_path, &path_stat);
-    free(wide_path);
-
-    if (r) {
-        perror("stat");
-        return false;
-    }
-    return S_ISREG(path_stat.st_mode);
-}
-
--- a/app/src/sys/win/process.c
+++ b/app/src/sys/win/process.c
@ -1,11 +1,10 @@
 #include "util/process.h"

-#include <processthreadsapi.h>
-
 #include <assert.h>
+#include <sys/stat.h>

 #include "util/log.h"
-#include "util/str.h"
+#include "util/str_util.h"

 #define CMD_MAX_LEN 8192

@ -15,26 +14,19 @@ build_cmd(char *cmd, size_t len, const char *const argv[]) {
    // <http://daviddeley.com/autohotkey/parameters/parameters.htm#WINPASS>
    // only make it work for this very specific program
    // (don't handle escaping nor quotes)
-    size_t ret = sc_str_join(cmd, argv, ' ', len);
+    size_t ret = xstrjoin(cmd, argv, ' ', len);
    if (ret >= len) {
-        LOGE("Command too long (%" SC_PRIsizet " chars)", len - 1);
+        LOGE("Command too long (%" PRIsizet " chars)", len - 1);
        return false;
    }
    return true;
 }

-enum sc_process_result
-sc_process_execute_p(const char *const argv[], HANDLE *handle, unsigned flags,
-                     HANDLE *pin, HANDLE *pout, HANDLE *perr) {
-    bool inherit_stdout = !pout && !(flags & SC_PROCESS_NO_STDOUT);
-    bool inherit_stderr = !perr && !(flags & SC_PROCESS_NO_STDERR);
-
-    // Add 1 per non-NULL pointer
-    unsigned handle_count = !!pin
-                          + (pout || inherit_stdout)
-                          + (perr || inherit_stderr);
-
-    enum sc_process_result ret = SC_PROCESS_ERROR_GENERIC;
+enum process_result
+process_execute_redirect(const char *const argv[], HANDLE *handle,
+                         HANDLE *pipe_stdin, HANDLE *pipe_stdout,
+                         HANDLE *pipe_stderr) {
+    enum process_result ret = PROCESS_ERROR_GENERIC;

    SECURITY_ATTRIBUTES sa;
    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
@ -44,178 +36,130 @@ sc_process_execute_p(const char *const argv[], HANDLE *handle, unsigned flags,
    HANDLE stdin_read_handle;
    HANDLE stdout_write_handle;
    HANDLE stderr_write_handle;
-    if (pin) {
-        if (!CreatePipe(&stdin_read_handle, pin, &sa, 0)) {
+    if (pipe_stdin) {
+        if (!CreatePipe(&stdin_read_handle, pipe_stdin, &sa, 0)) {
            perror("pipe");
-            return SC_PROCESS_ERROR_GENERIC;
+            return PROCESS_ERROR_GENERIC;
        }
-        if (!SetHandleInformation(*pin, HANDLE_FLAG_INHERIT, 0)) {
+        if (!SetHandleInformation(*pipe_stdin, HANDLE_FLAG_INHERIT, 0)) {
            LOGE("SetHandleInformation stdin failed");
            goto error_close_stdin;
        }
    }
-    if (pout) {
-        if (!CreatePipe(pout, &stdout_write_handle, &sa, 0)) {
+    if (pipe_stdout) {
+        if (!CreatePipe(pipe_stdout, &stdout_write_handle, &sa, 0)) {
            perror("pipe");
            goto error_close_stdin;
        }
-        if (!SetHandleInformation(*pout, HANDLE_FLAG_INHERIT, 0)) {
+        if (!SetHandleInformation(*pipe_stdout, HANDLE_FLAG_INHERIT, 0)) {
            LOGE("SetHandleInformation stdout failed");
            goto error_close_stdout;
        }
    }
-    if (perr) {
-        if (!CreatePipe(perr, &stderr_write_handle, &sa, 0)) {
+    if (pipe_stderr) {
+        if (!CreatePipe(pipe_stderr, &stderr_write_handle, &sa, 0)) {
            perror("pipe");
            goto error_close_stdout;
        }
-        if (!SetHandleInformation(*perr, HANDLE_FLAG_INHERIT, 0)) {
+        if (!SetHandleInformation(*pipe_stderr, HANDLE_FLAG_INHERIT, 0)) {
            LOGE("SetHandleInformation stderr failed");
            goto error_close_stderr;
        }
    }

-    STARTUPINFOEXW si;
+    STARTUPINFOW si;
    PROCESS_INFORMATION pi;
    memset(&si, 0, sizeof(si));
-    si.StartupInfo.cb = sizeof(si);
-    HANDLE handles[3];
-
-    LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList = NULL;
-    if (handle_count) {
-        si.StartupInfo.dwFlags = STARTF_USESTDHANDLES;
-
-        unsigned i = 0;
-        if (pin) {
-            si.StartupInfo.hStdInput = stdin_read_handle;
-            handles[i++] = si.StartupInfo.hStdInput;
+    si.cb = sizeof(si);
+    if (pipe_stdin || pipe_stdout || pipe_stderr) {
+        si.dwFlags = STARTF_USESTDHANDLES;
+        if (pipe_stdin) {
+            si.hStdInput = stdin_read_handle;
        }
-        if (pout || inherit_stdout) {
-            si.StartupInfo.hStdOutput = pout ? stdout_write_handle
-                                             : GetStdHandle(STD_OUTPUT_HANDLE);
-            handles[i++] = si.StartupInfo.hStdOutput;
+        if (pipe_stdout) {
+            si.hStdOutput = stdout_write_handle;
        }
-        if (perr || inherit_stderr) {
-            si.StartupInfo.hStdError = perr ? stderr_write_handle
-                                            : GetStdHandle(STD_ERROR_HANDLE);
-            handles[i++] = si.StartupInfo.hStdError;
+        if (pipe_stderr) {
+            si.hStdError = stderr_write_handle;
        }
-
-        SIZE_T size;
-        // Call it once to know the required buffer size
-        BOOL ok =
-            InitializeProcThreadAttributeList(NULL, 1, 0, &size)
-                || GetLastError() == ERROR_INSUFFICIENT_BUFFER;
-        if (!ok) {
-            goto error_close_stderr;
-        }
-
-        lpAttributeList = malloc(size);
-        if (!lpAttributeList) {
-            LOG_OOM();
-            goto error_close_stderr;
-        }
-
-        ok = InitializeProcThreadAttributeList(lpAttributeList, 1, 0, &size);
-        if (!ok) {
-            free(lpAttributeList);
-            goto error_close_stderr;
-        }
-
-        ok = UpdateProcThreadAttribute(lpAttributeList, 0,
-                                       PROC_THREAD_ATTRIBUTE_HANDLE_LIST,
-                                       handles, handle_count * sizeof(HANDLE),
-                                       NULL, NULL);
-        if (!ok) {
-            goto error_free_attribute_list;
-        }
-
-        si.lpAttributeList = lpAttributeList;
    }

    char *cmd = malloc(CMD_MAX_LEN);
    if (!cmd || !build_cmd(cmd, CMD_MAX_LEN, argv)) {
-        LOG_OOM();
-        goto error_free_attribute_list;
+        *handle = NULL;
+        goto error_close_stderr;
    }

-    wchar_t *wide = sc_str_to_wchars(cmd);
+    wchar_t *wide = utf8_to_wide_char(cmd);
    free(cmd);
    if (!wide) {
-        LOG_OOM();
-        goto error_free_attribute_list;
+        LOGC("Could not allocate wide char string");
+        goto error_close_stderr;
    }

-    BOOL bInheritHandles = handle_count > 0;
-    // DETACHED_PROCESS to disable stdin, stdout and stderr
-    DWORD dwCreationFlags = handle_count > 0 ? EXTENDED_STARTUPINFO_PRESENT
-                                             : DETACHED_PROCESS;
-    BOOL ok = CreateProcessW(NULL, wide, NULL, NULL, bInheritHandles,
-                             dwCreationFlags, NULL, NULL, &si.StartupInfo, &pi);
-    free(wide);
-    if (!ok) {
+    if (!CreateProcessW(NULL, wide, NULL, NULL, TRUE, 0, NULL, NULL, &si,
+                        &pi)) {
+        free(wide);
+        *handle = NULL;
+
        if (GetLastError() == ERROR_FILE_NOT_FOUND) {
-            ret = SC_PROCESS_ERROR_MISSING_BINARY;
+            ret = PROCESS_ERROR_MISSING_BINARY;
        }
-        goto error_free_attribute_list;
-    }
-
-    if (lpAttributeList) {
-        DeleteProcThreadAttributeList(lpAttributeList);
-        free(lpAttributeList);
+        goto error_close_stderr;
    }

    // These handles are used by the child process, close them for this process
-    if (pin) {
+    if (pipe_stdin) {
        CloseHandle(stdin_read_handle);
    }
-    if (pout) {
+    if (pipe_stdout) {
        CloseHandle(stdout_write_handle);
    }
-    if (perr) {
+    if (pipe_stderr) {
        CloseHandle(stderr_write_handle);
    }

+    free(wide);
    *handle = pi.hProcess;

-    return SC_PROCESS_SUCCESS;
+    return PROCESS_SUCCESS;

-error_free_attribute_list:
-    if (lpAttributeList) {
-        DeleteProcThreadAttributeList(lpAttributeList);
-        free(lpAttributeList);
-    }
 error_close_stderr:
-    if (perr) {
-        CloseHandle(*perr);
+    if (pipe_stderr) {
+        CloseHandle(*pipe_stderr);
        CloseHandle(stderr_write_handle);
    }
 error_close_stdout:
-    if (pout) {
-        CloseHandle(*pout);
+    if (pipe_stdout) {
+        CloseHandle(*pipe_stdout);
        CloseHandle(stdout_write_handle);
    }
 error_close_stdin:
-    if (pin) {
-        CloseHandle(*pin);
+    if (pipe_stdin) {
+        CloseHandle(*pipe_stdin);
        CloseHandle(stdin_read_handle);
    }

    return ret;
 }

+enum process_result
+process_execute(const char *const argv[], HANDLE *handle) {
+    return process_execute_redirect(argv, handle, NULL, NULL, NULL);
+}
+
 bool
-sc_process_terminate(HANDLE handle) {
+process_terminate(HANDLE handle) {
    return TerminateProcess(handle, 1);
 }

-sc_exit_code
-sc_process_wait(HANDLE handle, bool close) {
+exit_code_t
+process_wait(HANDLE handle, bool close) {
    DWORD code;
    if (WaitForSingleObject(handle, INFINITE) != WAIT_OBJECT_0
            || !GetExitCodeProcess(handle, &code)) {
        // could not wait or retrieve the exit code
-        code = SC_EXIT_CODE_NONE;
+        code = NO_EXIT_CODE; // max value, it's unsigned
    }
    if (close) {
        CloseHandle(handle);
@ -224,14 +168,48 @@ sc_process_wait(HANDLE handle, bool close) {
 }

 void
-sc_process_close(HANDLE handle) {
+process_close(HANDLE handle) {
    bool closed = CloseHandle(handle);
    assert(closed);
    (void) closed;
 }

+char *
+get_executable_path(void) {
+    HMODULE hModule = GetModuleHandleW(NULL);
+    if (!hModule) {
+        return NULL;
+    }
+    WCHAR buf[MAX_PATH + 1]; // +1 for the null byte
+    int len = GetModuleFileNameW(hModule, buf, MAX_PATH);
+    if (!len) {
+        return NULL;
+    }
+    buf[len] = '\0';
+    return utf8_from_wide_char(buf);
+}
+
+bool
+is_regular_file(const char *path) {
+    wchar_t *wide_path = utf8_to_wide_char(path);
+    if (!wide_path) {
+        LOGC("Could not allocate wide char string");
+        return false;
+    }
+
+    struct _stat path_stat;
+    int r = _wstat(wide_path, &path_stat);
+    free(wide_path);
+
+    if (r) {
+        perror("stat");
+        return false;
+    }
+    return S_ISREG(path_stat.st_mode);
+}
+
 ssize_t
-sc_pipe_read(HANDLE pipe, char *data, size_t len) {
+read_pipe(HANDLE pipe, char *data, size_t len) {
    DWORD r;
    if (!ReadFile(pipe, data, len, &r, NULL)) {
        return -1;
@ -240,7 +218,7 @@ sc_pipe_read(HANDLE pipe, char *data, size_t len) {
 }

 void
-sc_pipe_close(HANDLE pipe) {
+close_pipe(HANDLE pipe) {
    if (!CloseHandle(pipe)) {
        LOGW("Cannot close pipe");
    }
--- a/app/src/trait/key_processor.h
+++ b/app/src/trait/key_processor.h
@ -14,31 +14,12 @@
 * Component able to process and inject keys should implement this trait.
 */
 struct sc_key_processor {
-    /**
-     * Set by the implementation to indicate that it must explicitly wait for
-     * the clipboard to be set on the device before injecting Ctrl+v to avoid
-     * race conditions. If it is set, the input_manager will pass a valid
-     * ack_to_wait to process_key() in case of clipboard synchronization
-     * resulting of the key event.
-     */
-    bool async_paste;
-
    const struct sc_key_processor_ops *ops;
 };

 struct sc_key_processor_ops {
-
-    /**
-     * Process the keyboard event
-     *
-     * The `sequence` number (if different from `SC_SEQUENCE_INVALID`) indicates
-     * the acknowledgement number to wait for before injecting this event.
-     * This allows to ensure that the device clipboard is set before injecting
-     * Ctrl+v on the device.
-     */
    void
-    (*process_key)(struct sc_key_processor *kp, const SDL_KeyboardEvent *event,
-                   uint64_t ack_to_wait);
+    (*process_key)(struct sc_key_processor *kp, const SDL_KeyboardEvent *event);

    void
    (*process_text)(struct sc_key_processor *kp,
--- a/app/src/util/acksync.c
+++ b/app/src/util/acksync.c
@ -1,76 +0,0 @@
-#include "acksync.h"
-
-#include <assert.h>
-#include "util/log.h"
-
-bool
-sc_acksync_init(struct sc_acksync *as) {
-    bool ok = sc_mutex_init(&as->mutex);
-    if (!ok) {
-        return false;
-    }
-
-    ok = sc_cond_init(&as->cond);
-    if (!ok) {
-        sc_mutex_destroy(&as->mutex);
-        return false;
-    }
-
-    as->stopped = false;
-    as->ack = SC_SEQUENCE_INVALID;
-
-    return true;
-}
-
-void
-sc_acksync_destroy(struct sc_acksync *as) {
-    sc_cond_destroy(&as->cond);
-    sc_mutex_destroy(&as->mutex);
-}
-
-void
-sc_acksync_ack(struct sc_acksync *as, uint64_t sequence) {
-    sc_mutex_lock(&as->mutex);
-
-    // Acknowledgements must be monotonic
-    assert(sequence >= as->ack);
-
-    as->ack = sequence;
-    sc_cond_signal(&as->cond);
-
-    sc_mutex_unlock(&as->mutex);
-}
-
-enum sc_acksync_wait_result
-sc_acksync_wait(struct sc_acksync *as, uint64_t ack, sc_tick deadline) {
-    sc_mutex_lock(&as->mutex);
-
-    bool timed_out = false;
-    while (!as->stopped && as->ack < ack && !timed_out) {
-        timed_out = !sc_cond_timedwait(&as->cond, &as->mutex, deadline);
-    }
-
-    enum sc_acksync_wait_result ret;
-    if (as->stopped) {
-        ret = SC_ACKSYNC_WAIT_INTR;
-    } else if (as->ack >= ack) {
-        ret = SC_ACKSYNC_WAIT_OK;
-    } else {
-        assert(timed_out);
-        ret = SC_ACKSYNC_WAIT_TIMEOUT;
-    }
-    sc_mutex_unlock(&as->mutex);
-
-    return ret;
-}
-
-/**
- * Interrupt any `sc_acksync_wait()`
- */
-void
-sc_acksync_interrupt(struct sc_acksync *as) {
-    sc_mutex_lock(&as->mutex);
-    as->stopped = true;
-    sc_cond_signal(&as->cond);
-    sc_mutex_unlock(&as->mutex);
-}
--- a/app/src/util/acksync.h
+++ b/app/src/util/acksync.h
@ -1,66 +0,0 @@
-#ifndef SC_ACK_SYNC_H
-#define SC_ACK_SYNC_H
-
-#include "common.h"
-
-#include "thread.h"
-
-#define SC_SEQUENCE_INVALID 0
-
-/**
- * Helper to wait for acknowledgments
- *
- * In practice, it is used to wait for device clipboard acknowledgement from the
- * server before injecting Ctrl+v via AOA HID, in order to avoid pasting the
- * content of the old device clipboard (if Ctrl+v was injected before the
- * clipboard content was actually set).
- */
-struct sc_acksync {
-    sc_mutex mutex;
-    sc_cond cond;
-
-    bool stopped;
-
-    // Last acked value, initially SC_SEQUENCE_INVALID
-    uint64_t ack;
-};
-
-enum sc_acksync_wait_result {
-    // Acknowledgment received
-    SC_ACKSYNC_WAIT_OK,
-
-    // Timeout expired
-    SC_ACKSYNC_WAIT_TIMEOUT,
-
-    // Interrupted from another thread by sc_acksync_interrupt()
-    SC_ACKSYNC_WAIT_INTR,
-};
-
-bool
-sc_acksync_init(struct sc_acksync *as);
-
-void
-sc_acksync_destroy(struct sc_acksync *as);
-
-/**
- * Acknowledge `sequence`
- *
- * The `sequence` must be greater than (or equal to) any previous acknowledged
- * sequence.
- */
-void
-sc_acksync_ack(struct sc_acksync *as, uint64_t sequence);
-
-/**
- * Wait for acknowledgment of sequence `ack` (or higher)
- */
-enum sc_acksync_wait_result
-sc_acksync_wait(struct sc_acksync *as, uint64_t ack, sc_tick deadline);
-
-/**
- * Interrupt any `sc_acksync_wait()`
- */
-void
-sc_acksync_interrupt(struct sc_acksync *as);
-
-#endif
--- a/app/src/util/file.c
+++ b/app/src/util/file.c
@ -1,48 +0,0 @@
-#include "file.h"
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "util/log.h"
-
-char *
-sc_file_get_local_path(const char *name) {
-    char *executable_path = sc_file_get_executable_path();
-    if (!executable_path) {
-        return NULL;
-    }
-
-    // dirname() does not work correctly everywhere, so get the parent
-    // directory manually.
-    // See <https://github.com/Genymobile/scrcpy/issues/2619>
-    char *p = strrchr(executable_path, SC_PATH_SEPARATOR);
-    if (!p) {
-        LOGE("Unexpected executable path: \"%s\" (it should contain a '%c')",
-             executable_path, SC_PATH_SEPARATOR);
-        free(executable_path);
-        return NULL;
-    }
-
-    *p = '\0'; // modify executable_path in place
-    char *dir = executable_path;
-    size_t dirlen = strlen(dir);
-    size_t namelen = strlen(name);
-
-    size_t len = dirlen + namelen + 2; // +2: '/' and '\0'
-    char *file_path = malloc(len);
-    if (!file_path) {
-        LOG_OOM();
-        free(executable_path);
-        return NULL;
-    }
-
-    memcpy(file_path, dir, dirlen);
-    file_path[dirlen] = SC_PATH_SEPARATOR;
-    // namelen + 1 to copy the final '\0'
-    memcpy(&file_path[dirlen + 1], name, namelen + 1);
-
-    free(executable_path);
-
-    return file_path;
-}
-
--- a/app/src/util/file.h
+++ b/app/src/util/file.h
@ -1,49 +0,0 @@
-#ifndef SC_FILE_H
-#define SC_FILE_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#ifdef _WIN32
-# define SC_PATH_SEPARATOR '\\'
-#else
-# define SC_PATH_SEPARATOR '/'
-#endif
-
-#ifndef _WIN32
-/**
- * Indicate if an executable exists using $PATH
- *
- * In practice, it is only used to know if a package manager is available on
- * the system. It is only implemented on Linux.
- */
-bool
-sc_file_executable_exists(const char *file);
-#endif
-
-/**
- * Return the absolute path of the executable (the scrcpy binary)
- *
- * The result must be freed by the caller using free(). It may return NULL on
- * error.
- */
-char *
-sc_file_get_executable_path(void);
-
-/**
- * Return the absolute path of a file in the same directory as the executable
- *
- * The result must be freed by the caller using free(). It may return NULL on
- * error.
- */
-char *
-sc_file_get_local_path(const char *name);
-
-/**
- * Indicate if the file exists and is not a directory
- */
-bool
-sc_file_is_regular(const char *path);
-
-#endif
--- a/app/src/util/intr.c
+++ b/app/src/util/intr.c
@ -1,83 +0,0 @@
-#include "intr.h"
-
-#include "util/log.h"
-
-#include <assert.h>
-
-bool
-sc_intr_init(struct sc_intr *intr) {
-    bool ok = sc_mutex_init(&intr->mutex);
-    if (!ok) {
-        LOG_OOM();
-        return false;
-    }
-
-    intr->socket = SC_SOCKET_NONE;
-    intr->process = SC_PROCESS_NONE;
-
-    atomic_store_explicit(&intr->interrupted, false, memory_order_relaxed);
-
-    return true;
-}
-
-bool
-sc_intr_set_socket(struct sc_intr *intr, sc_socket socket) {
-    assert(intr->process == SC_PROCESS_NONE);
-
-    sc_mutex_lock(&intr->mutex);
-    bool interrupted =
-        atomic_load_explicit(&intr->interrupted, memory_order_relaxed);
-    if (!interrupted) {
-        intr->socket = socket;
-    }
-    sc_mutex_unlock(&intr->mutex);
-
-    return !interrupted;
-}
-
-bool
-sc_intr_set_process(struct sc_intr *intr, sc_pid pid) {
-    assert(intr->socket == SC_SOCKET_NONE);
-
-    sc_mutex_lock(&intr->mutex);
-    bool interrupted =
-        atomic_load_explicit(&intr->interrupted, memory_order_relaxed);
-    if (!interrupted) {
-        intr->process = pid;
-    }
-    sc_mutex_unlock(&intr->mutex);
-
-    return !interrupted;
-}
-
-void
-sc_intr_interrupt(struct sc_intr *intr) {
-    sc_mutex_lock(&intr->mutex);
-
-    atomic_store_explicit(&intr->interrupted, true, memory_order_relaxed);
-
-    // No more than one component to interrupt
-    assert(intr->socket == SC_SOCKET_NONE ||
-           intr->process == SC_PROCESS_NONE);
-
-    if (intr->socket != SC_SOCKET_NONE) {
-        LOGD("Interrupting socket");
-        net_interrupt(intr->socket);
-        intr->socket = SC_SOCKET_NONE;
-    }
-    if (intr->process != SC_PROCESS_NONE) {
-        LOGD("Interrupting process");
-        sc_process_terminate(intr->process);
-        intr->process = SC_PROCESS_NONE;
-    }
-
-    sc_mutex_unlock(&intr->mutex);
-}
-
-void
-sc_intr_destroy(struct sc_intr *intr) {
-    assert(intr->socket == SC_SOCKET_NONE);
-    assert(intr->process == SC_PROCESS_NONE);
-
-    sc_mutex_destroy(&intr->mutex);
-}
--- a/app/src/util/intr.h
+++ b/app/src/util/intr.h
@ -1,78 +0,0 @@
-#ifndef SC_INTR_H
-#define SC_INTR_H
-
-#include "common.h"
-
-#include <stdatomic.h>
-#include <stdbool.h>
-
-#include "net.h"
-#include "process.h"
-#include "thread.h"
-
-/**
- * Interruptor to wake up a blocking call from another thread
- *
- * It allows to register a socket or a process before a blocking call, and
- * interrupt/close from another thread to wake up the blocking call.
- */
-struct sc_intr {
-    sc_mutex mutex;
-
-    sc_socket socket;
-    sc_pid process;
-
-    // Written protected by the mutex to avoid race conditions against
-    // sc_intr_set_socket() and sc_intr_set_process(), but can be read
-    // (atomically) without mutex
-    atomic_bool interrupted;
-};
-
-/**
- * Initialize an interruptor
- */
-bool
-sc_intr_init(struct sc_intr *intr);
-
-/**
- * Set a socket as the interruptible component
- *
- * Call with SC_SOCKET_NONE to unset.
- */
-bool
-sc_intr_set_socket(struct sc_intr *intr, sc_socket socket);
-
-/**
- * Set a process as the interruptible component
- *
- * Call with SC_PROCESS_NONE to unset.
- */
-bool
-sc_intr_set_process(struct sc_intr *intr, sc_pid socket);
-
-/**
- * Interrupt the current interruptible component
- *
- * Must be called from a different thread.
- */
-void
-sc_intr_interrupt(struct sc_intr *intr);
-
-/**
- * Read the interrupted state
- *
- * It is exposed as a static inline function because it just loads from an
- * atomic.
- */
-static inline bool
-sc_intr_is_interrupted(struct sc_intr *intr) {
-    return atomic_load_explicit(&intr->interrupted, memory_order_relaxed);
-}
-
-/**
- * Destroy the interruptor
- */
-void
-sc_intr_destroy(struct sc_intr *intr);
-
-#endif
--- a/app/src/util/log.h
+++ b/app/src/util/log.h
@ -5,10 +5,7 @@

 #include <SDL2/SDL_log.h>

-#include "options.h"
-
-#define LOG_STR_IMPL_(x) # x
-#define LOG_STR(x) LOG_STR_IMPL_(x)
+#include "scrcpy.h"

 #define LOGV(...) SDL_LogVerbose(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
 #define LOGD(...) SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
@ -17,9 +14,6 @@
 #define LOGE(...) SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
 #define LOGC(...) SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)

-#define LOG_OOM() \
-    LOGC("OOM: %s:%d %s()", __FILE__, __LINE__, __func__)
-
 void
 sc_set_log_level(enum sc_log_level level);

--- a/app/src/util/net.c
+++ b/app/src/util/net.c
@ -1,30 +1,25 @@
 #include "net.h"

 #include <assert.h>
-#include <errno.h>
 #include <stdio.h>
 #include <SDL2/SDL_platform.h>

 #include "log.h"

 #ifdef __WINDOWS__
-# include <ws2tcpip.h>
  typedef int socklen_t;
  typedef SOCKET sc_raw_socket;
-# define SC_RAW_SOCKET_NONE INVALID_SOCKET
 #else
 # include <sys/types.h>
 # include <sys/socket.h>
 # include <netinet/in.h>
 # include <arpa/inet.h>
 # include <unistd.h>
-# include <fcntl.h>
 # define SOCKET_ERROR -1
  typedef struct sockaddr_in SOCKADDR_IN;
  typedef struct sockaddr SOCKADDR;
  typedef struct in_addr IN_ADDR;
  typedef int sc_raw_socket;
-# define SC_RAW_SOCKET_NONE -1
 #endif

 bool
@ -51,14 +46,13 @@ static inline sc_socket
 wrap(sc_raw_socket sock) {
 #ifdef __WINDOWS__
    if (sock == INVALID_SOCKET) {
-        return SC_SOCKET_NONE;
+        return SC_INVALID_SOCKET;
    }

    struct sc_socket_windows *socket = malloc(sizeof(*socket));
    if (!socket) {
-        LOG_OOM();
        closesocket(sock);
-        return SC_SOCKET_NONE;
+        return SC_INVALID_SOCKET;
    }

    socket->socket = sock;
@ -73,7 +67,7 @@ wrap(sc_raw_socket sock) {
 static inline sc_raw_socket
 unwrap(sc_socket socket) {
 #ifdef __WINDOWS__
-    if (socket == SC_SOCKET_NONE) {
+    if (socket == SC_INVALID_SOCKET) {
        return INVALID_SOCKET;
    }

@ -83,35 +77,6 @@ unwrap(sc_socket socket) {
 #endif
 }

-static inline bool
-sc_raw_socket_close(sc_raw_socket raw_sock) {
-#ifndef _WIN32
-    return !close(raw_sock);
-#else
-    return !closesocket(raw_sock);
-#endif
-}
-
-#ifndef HAVE_SOCK_CLOEXEC
-// If SOCK_CLOEXEC does not exist, the flag must be set manually once the
-// socket is created
-static bool
-set_cloexec_flag(sc_raw_socket raw_sock) {
-#ifndef _WIN32
-    if (fcntl(raw_sock, F_SETFD, FD_CLOEXEC) == -1) {
-        perror("fcntl F_SETFD");
-        return false;
-    }
-#else
-    if (!SetHandleInformation((HANDLE) raw_sock, HANDLE_FLAG_INHERIT, 0)) {
-        LOGE("SetHandleInformation socket failed");
-        return false;
-    }
-#endif
-    return true;
-}
-#endif
-
 static void
 net_perror(const char *s) {
 #ifdef _WIN32
@ -129,27 +94,13 @@ net_perror(const char *s) {
 }

 sc_socket
-net_socket(void) {
-#ifdef HAVE_SOCK_CLOEXEC
-    sc_raw_socket raw_sock = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
-#else
+net_connect(uint32_t addr, uint16_t port) {
    sc_raw_socket raw_sock = socket(AF_INET, SOCK_STREAM, 0);
-    if (raw_sock != SC_RAW_SOCKET_NONE && !set_cloexec_flag(raw_sock)) {
-        sc_raw_socket_close(raw_sock);
-        return SC_SOCKET_NONE;
-    }
-#endif
-
    sc_socket sock = wrap(raw_sock);
-    if (sock == SC_SOCKET_NONE) {
+    if (sock == SC_INVALID_SOCKET) {
        net_perror("socket");
+        return SC_INVALID_SOCKET;
    }
-    return sock;
-}
-
-bool
-net_connect(sc_socket socket, uint32_t addr, uint16_t port) {
-    sc_raw_socket raw_sock = unwrap(socket);

    SOCKADDR_IN sin;
    sin.sin_family = AF_INET;
@ -158,15 +109,21 @@ net_connect(sc_socket socket, uint32_t addr, uint16_t port) {

    if (connect(raw_sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
        net_perror("connect");
-        return false;
+        net_close(sock);
+        return SC_INVALID_SOCKET;
    }

-    return true;
+    return sock;
 }

-bool
-net_listen(sc_socket socket, uint32_t addr, uint16_t port, int backlog) {
-    sc_raw_socket raw_sock = unwrap(socket);
+sc_socket
+net_listen(uint32_t addr, uint16_t port, int backlog) {
+    sc_raw_socket raw_sock = socket(AF_INET, SOCK_STREAM, 0);
+    sc_socket sock = wrap(raw_sock);
+    if (sock == SC_INVALID_SOCKET) {
+        net_perror("socket");
+        return SC_INVALID_SOCKET;
+    }

    int reuse = 1;
    if (setsockopt(raw_sock, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuse,
@ -181,15 +138,17 @@ net_listen(sc_socket socket, uint32_t addr, uint16_t port, int backlog) {

    if (bind(raw_sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
        net_perror("bind");
-        return false;
+        net_close(sock);
+        return SC_INVALID_SOCKET;
    }

    if (listen(raw_sock, backlog) == SOCKET_ERROR) {
        net_perror("listen");
-        return false;
+        net_close(sock);
+        return SC_INVALID_SOCKET;
    }

-    return true;
+    return sock;
 }

 sc_socket
@ -198,18 +157,8 @@ net_accept(sc_socket server_socket) {

    SOCKADDR_IN csin;
    socklen_t sinsize = sizeof(csin);
-
-#ifdef HAVE_SOCK_CLOEXEC
-    sc_raw_socket raw_sock =
-        accept4(raw_server_socket, (SOCKADDR *) &csin, &sinsize, SOCK_CLOEXEC);
-#else
    sc_raw_socket raw_sock =
        accept(raw_server_socket, (SOCKADDR *) &csin, &sinsize);
-    if (raw_sock != SC_RAW_SOCKET_NONE && !set_cloexec_flag(raw_sock)) {
-        sc_raw_socket_close(raw_sock);
-        return SC_SOCKET_NONE;
-    }
-#endif

    return wrap(raw_sock);
 }
@ -249,7 +198,7 @@ net_send_all(sc_socket socket, const void *buf, size_t len) {

 bool
 net_interrupt(sc_socket socket) {
-    assert(socket != SC_SOCKET_NONE);
+    assert(socket != SC_INVALID_SOCKET);

    sc_raw_socket raw_sock = unwrap(socket);

@ -263,6 +212,7 @@ net_interrupt(sc_socket socket) {
 #endif
 }

+#include <errno.h>
 bool
 net_close(sc_socket socket) {
    sc_raw_socket raw_sock = unwrap(socket);
@ -278,15 +228,3 @@ net_close(sc_socket socket) {
    return !close(raw_sock);
 #endif
 }
-
-bool
-net_parse_ipv4(const char *s, uint32_t *ipv4) {
-    struct in_addr addr;
-    if (!inet_pton(AF_INET, s, &addr)) {
-        LOGE("Invalid IPv4 address: %s", s);
-        return false;
-    }
-
-    *ipv4 = ntohl(addr.s_addr);
-    return true;
-}
--- a/app/src/util/net.h
+++ b/app/src/util/net.h
@ -11,7 +11,7 @@

 # include <winsock2.h>
 # include <stdatomic.h>
-# define SC_SOCKET_NONE NULL
+# define SC_INVALID_SOCKET NULL
  typedef struct sc_socket_windows {
      SOCKET socket;
      atomic_flag closed;
@ -20,13 +20,10 @@
 #else // not __WINDOWS__

 # include <sys/socket.h>
-# define SC_SOCKET_NONE -1
+# define SC_INVALID_SOCKET -1
  typedef int sc_socket;
-
 #endif

-#define IPV4_LOCALHOST 0x7F000001
-
 bool
 net_init(void);

@ -34,13 +31,10 @@ void
 net_cleanup(void);

 sc_socket
-net_socket(void);
+net_connect(uint32_t addr, uint16_t port);

-bool
-net_connect(sc_socket socket, uint32_t addr, uint16_t port);
-
-bool
-net_listen(sc_socket socket, uint32_t addr, uint16_t port, int backlog);
+sc_socket
+net_listen(uint32_t addr, uint16_t port, int backlog);

 sc_socket
 net_accept(sc_socket server_socket);
@ -59,7 +53,7 @@ ssize_t
 net_send_all(sc_socket socket, const void *buf, size_t len);

 // Shutdown the socket (or close on Windows) so that any blocking send() or
-// recv() are interrupted.
+// recv() are interrupted
 bool
 net_interrupt(sc_socket socket);

@ -68,10 +62,4 @@ net_interrupt(sc_socket socket);
 bool
 net_close(sc_socket socket);

-/**
- * Parse `ip` "xxx.xxx.xxx.xxx" to an IPv4 host representation
- */
-bool
-net_parse_ipv4(const char *ip, uint32_t *ipv4);
-
 #endif
--- a/app/src/util/net_intr.c
+++ b/app/src/util/net_intr.c
@ -1,97 +0,0 @@
-#include "net_intr.h"
-
-bool
-net_connect_intr(struct sc_intr *intr, sc_socket socket, uint32_t addr,
-                 uint16_t port) {
-    if (!sc_intr_set_socket(intr, socket)) {
-        // Already interrupted
-        return false;
-    }
-
-    bool ret = net_connect(socket, addr, port);
-
-    sc_intr_set_socket(intr, SC_SOCKET_NONE);
-    return ret;
-}
-
-bool
-net_listen_intr(struct sc_intr *intr, sc_socket socket, uint32_t addr,
-                uint16_t port, int backlog) {
-    if (!sc_intr_set_socket(intr, socket)) {
-        // Already interrupted
-        return false;
-    }
-
-    bool ret = net_listen(socket, addr, port, backlog);
-
-    sc_intr_set_socket(intr, SC_SOCKET_NONE);
-    return ret;
-}
-
-sc_socket
-net_accept_intr(struct sc_intr *intr, sc_socket server_socket) {
-    if (!sc_intr_set_socket(intr, server_socket)) {
-        // Already interrupted
-        return SC_SOCKET_NONE;
-    }
-
-    sc_socket socket = net_accept(server_socket);
-
-    sc_intr_set_socket(intr, SC_SOCKET_NONE);
-    return socket;
-}
-
-ssize_t
-net_recv_intr(struct sc_intr *intr, sc_socket socket, void *buf, size_t len) {
-    if (!sc_intr_set_socket(intr, socket)) {
-        // Already interrupted
-        return -1;
-    }
-
-    ssize_t r = net_recv(socket, buf, len);
-
-    sc_intr_set_socket(intr, SC_SOCKET_NONE);
-    return r;
-}
-
-ssize_t
-net_recv_all_intr(struct sc_intr *intr, sc_socket socket, void *buf,
-                  size_t len) {
-    if (!sc_intr_set_socket(intr, socket)) {
-        // Already interrupted
-        return -1;
-    }
-
-    ssize_t r = net_recv_all(socket, buf, len);
-
-    sc_intr_set_socket(intr, SC_SOCKET_NONE);
-    return r;
-}
-
-ssize_t
-net_send_intr(struct sc_intr *intr, sc_socket socket, const void *buf,
-              size_t len) {
-    if (!sc_intr_set_socket(intr, socket)) {
-        // Already interrupted
-        return -1;
-    }
-
-    ssize_t w = net_send(socket, buf, len);
-
-    sc_intr_set_socket(intr, SC_SOCKET_NONE);
-    return w;
-}
-
-ssize_t
-net_send_all_intr(struct sc_intr *intr, sc_socket socket, const void *buf,
-                  size_t len) {
-    if (!sc_intr_set_socket(intr, socket)) {
-        // Already interrupted
-        return -1;
-    }
-
-    ssize_t w = net_send_all(socket, buf, len);
-
-    sc_intr_set_socket(intr, SC_SOCKET_NONE);
-    return w;
-}
--- a/app/src/util/net_intr.h
+++ b/app/src/util/net_intr.h
@ -1,35 +0,0 @@
-#ifndef SC_NET_INTR_H
-#define SC_NET_INTR_H
-
-#include "common.h"
-
-#include "intr.h"
-#include "net.h"
-
-bool
-net_connect_intr(struct sc_intr *intr, sc_socket socket, uint32_t addr,
-                 uint16_t port);
-
-bool
-net_listen_intr(struct sc_intr *intr, sc_socket socket, uint32_t addr,
-                uint16_t port, int backlog);
-
-sc_socket
-net_accept_intr(struct sc_intr *intr, sc_socket server_socket);
-
-ssize_t
-net_recv_intr(struct sc_intr *intr, sc_socket socket, void *buf, size_t len);
-
-ssize_t
-net_recv_all_intr(struct sc_intr *intr, sc_socket socket, void *buf,
-                  size_t len);
-
-ssize_t
-net_send_intr(struct sc_intr *intr, sc_socket socket, const void *buf,
-              size_t len);
-
-ssize_t
-net_send_all_intr(struct sc_intr *intr, sc_socket socket, const void *buf,
-                  size_t len);
-
-#endif
--- a/app/src/util/process.c
+++ b/app/src/util/process.c
@ -1,19 +1,72 @@
 #include "process.h"

-#include <assert.h>
 #include <libgen.h>
 #include "log.h"

-enum sc_process_result
-sc_process_execute(const char *const argv[], sc_pid *pid, unsigned flags) {
-    return sc_process_execute_p(argv, pid, flags, NULL, NULL, NULL);
+bool
+process_check_success(process_t proc, const char *name, bool close) {
+    if (proc == PROCESS_NONE) {
+        LOGE("Could not execute \"%s\"", name);
+        return false;
+    }
+    exit_code_t exit_code = process_wait(proc, close);
+    if (exit_code) {
+        if (exit_code != NO_EXIT_CODE) {
+            LOGE("\"%s\" returned with value %" PRIexitcode, name, exit_code);
+        } else {
+            LOGE("\"%s\" exited unexpectedly", name);
+        }
+        return false;
+    }
+    return true;
+}
+
+char *
+get_local_file_path(const char *name) {
+    char *executable_path = get_executable_path();
+    if (!executable_path) {
+        return NULL;
+    }
+
+    // dirname() does not work correctly everywhere, so get the parent
+    // directory manually.
+    // See <https://github.com/Genymobile/scrcpy/issues/2619>
+    char *p = strrchr(executable_path, PATH_SEPARATOR);
+    if (!p) {
+        LOGE("Unexpected executable path: \"%s\" (it should contain a '%c')",
+             executable_path, PATH_SEPARATOR);
+        free(executable_path);
+        return NULL;
+    }
+
+    *p = '\0'; // modify executable_path in place
+    char *dir = executable_path;
+    size_t dirlen = strlen(dir);
+    size_t namelen = strlen(name);
+
+    size_t len = dirlen + namelen + 2; // +2: '/' and '\0'
+    char *file_path = malloc(len);
+    if (!file_path) {
+        LOGE("Could not alloc path");
+        free(executable_path);
+        return NULL;
+    }
+
+    memcpy(file_path, dir, dirlen);
+    file_path[dirlen] = PATH_SEPARATOR;
+    // namelen + 1 to copy the final '\0'
+    memcpy(&file_path[dirlen + 1], name, namelen + 1);
+
+    free(executable_path);
+
+    return file_path;
 }

 ssize_t
-sc_pipe_read_all(sc_pipe pipe, char *data, size_t len) {
+read_pipe_all(pipe_t pipe, char *data, size_t len) {
    size_t copied = 0;
    while (len > 0) {
-        ssize_t r = sc_pipe_read(pipe, data, len);
+        ssize_t r = read_pipe(pipe, data, len);
        if (r <= 0) {
            return copied ? (ssize_t) copied : r;
        }
@ -23,80 +76,3 @@ sc_pipe_read_all(sc_pipe pipe, char *data, size_t len) {
    }
    return copied;
 }
-
-static int
-run_observer(void *data) {
-    struct sc_process_observer *observer = data;
-    sc_process_wait(observer->pid, false); // ignore exit code
-
-    sc_mutex_lock(&observer->mutex);
-    observer->terminated = true;
-    sc_cond_signal(&observer->cond_terminated);
-    sc_mutex_unlock(&observer->mutex);
-
-    if (observer->listener) {
-        observer->listener->on_terminated(observer->listener_userdata);
-    }
-
-    return 0;
-}
-
-bool
-sc_process_observer_init(struct sc_process_observer *observer, sc_pid pid,
-                         const struct sc_process_listener *listener,
-                         void *listener_userdata) {
-    // Either no listener, or on_terminated() is defined
-    assert(!listener || listener->on_terminated);
-
-    bool ok = sc_mutex_init(&observer->mutex);
-    if (!ok) {
-        return false;
-    }
-
-    ok = sc_cond_init(&observer->cond_terminated);
-    if (!ok) {
-        sc_mutex_destroy(&observer->mutex);
-        return false;
-    }
-
-    observer->pid = pid;
-    observer->listener = listener;
-    observer->listener_userdata = listener_userdata;
-    observer->terminated = false;
-
-    ok = sc_thread_create(&observer->thread, run_observer, "process_observer",
-                          observer);
-    if (!ok) {
-        sc_cond_destroy(&observer->cond_terminated);
-        sc_mutex_destroy(&observer->mutex);
-        return false;
-    }
-
-    return true;
-}
-
-bool
-sc_process_observer_timedwait(struct sc_process_observer *observer,
-                              sc_tick deadline) {
-    sc_mutex_lock(&observer->mutex);
-    bool timed_out = false;
-    while (!observer->terminated && !timed_out) {
-        timed_out = !sc_cond_timedwait(&observer->cond_terminated,
-                                       &observer->mutex, deadline);
-    }
-    bool terminated = observer->terminated;
-    sc_mutex_unlock(&observer->mutex);
-
-    return terminated;
-}
-
-void
-sc_process_observer_join(struct sc_process_observer *observer) {
-    sc_thread_join(&observer->thread, NULL);
-}
-
-void
-sc_process_observer_destroy(struct sc_process_observer *observer) {
-    sc_cond_destroy(&observer->cond_terminated);
-    sc_mutex_destroy(&observer->mutex);
-}
--- a/app/src/util/process.h
+++ b/app/src/util/process.h
@ -4,177 +4,102 @@
 #include "common.h"

 #include <stdbool.h>
-#include "util/thread.h"

 #ifdef _WIN32

 // not needed here, but winsock2.h must never be included AFTER windows.h
 # include <winsock2.h>
 # include <windows.h>
-# define SC_PRIexitcode "lu"
+# define PATH_SEPARATOR '\\'
+# define PRIexitcode "lu"
 // <https://stackoverflow.com/a/44383330/1987178>
-# define SC_PRIsizet "Iu"
-# define SC_PROCESS_NONE NULL
-# define SC_EXIT_CODE_NONE -1u // max value as unsigned
-  typedef HANDLE sc_pid;
-  typedef DWORD sc_exit_code;
-  typedef HANDLE sc_pipe;
+# define PRIsizet "Iu"
+# define PROCESS_NONE NULL
+# define NO_EXIT_CODE -1u // max value as unsigned
+  typedef HANDLE process_t;
+  typedef DWORD exit_code_t;
+  typedef HANDLE pipe_t;

 #else

 # include <sys/types.h>
-# define SC_PRIsizet "zu"
-# define SC_PRIexitcode "d"
-# define SC_PROCESS_NONE -1
-# define SC_EXIT_CODE_NONE -1
-  typedef pid_t sc_pid;
-  typedef int sc_exit_code;
-  typedef int sc_pipe;
+# define PATH_SEPARATOR '/'
+# define PRIsizet "zu"
+# define PRIexitcode "d"
+# define PROCESS_NONE -1
+# define NO_EXIT_CODE -1
+  typedef pid_t process_t;
+  typedef int exit_code_t;
+  typedef int pipe_t;

 #endif

-struct sc_process_listener {
-    void (*on_terminated)(void *userdata);
+enum process_result {
+    PROCESS_SUCCESS,
+    PROCESS_ERROR_GENERIC,
+    PROCESS_ERROR_MISSING_BINARY,
 };

-/**
- * Tool to observe process termination
- *
- * To keep things simple and multiplatform, it runs a separate thread to wait
- * for process termination (without closing the process to avoid race
- * conditions).
- *
- * It allows a caller to block until the process is terminated (with a
- * timeout), and to be notified asynchronously from the observer thread.
- *
- * The process is not owned by the observer (the observer will never close it).
- */
-struct sc_process_observer {
-    sc_pid pid;
+// execute the command and write the result to the output parameter "process"
+enum process_result
+process_execute(const char *const argv[], process_t *process);

-    sc_mutex mutex;
-    sc_cond cond_terminated;
-    bool terminated;
+enum process_result
+process_execute_redirect(const char *const argv[], process_t *process,
+                         pipe_t *pipe_stdin, pipe_t *pipe_stdout,
+                         pipe_t *pipe_stderr);

-    sc_thread thread;
-    const struct sc_process_listener *listener;
-    void *listener_userdata;
-};
-
-enum sc_process_result {
-    SC_PROCESS_SUCCESS,
-    SC_PROCESS_ERROR_GENERIC,
-    SC_PROCESS_ERROR_MISSING_BINARY,
-};
-
-#define SC_PROCESS_NO_STDOUT (1 << 0)
-#define SC_PROCESS_NO_STDERR (1 << 1)
-
-/**
- * Execute the command and write the process id to `pid`
- *
- * The `flags` argument is a bitwise OR of the following values:
- *  - SC_PROCESS_NO_STDOUT
- *  - SC_PROCESS_NO_STDERR
- *
- * It indicates if stdout and stderr must be inherited from the scrcpy process
- * (i.e. if the process must output to the scrcpy console).
- */
-enum sc_process_result
-sc_process_execute(const char *const argv[], sc_pid *pid, unsigned flags);
-
-/**
- * Execute the command and write the process id to `pid`
- *
- * If not NULL, provide a pipe for stdin (`pin`), stdout (`pout`) and stderr
- * (`perr`).
- *
- * The `flags` argument has the same semantics as in `sc_process_execute()`.
- */
-enum sc_process_result
-sc_process_execute_p(const char *const argv[], sc_pid *pid, unsigned flags,
-                     sc_pipe *pin, sc_pipe *pout, sc_pipe *perr);
-
-/**
- * Kill the process
- */
 bool
-sc_process_terminate(sc_pid pid);
+process_terminate(process_t pid);

-/**
- * Wait and close the process (similar to waitpid())
- *
- * The `close` flag indicates if the process must be _closed_ (reaped) (passing
- * false is equivalent to enable WNOWAIT in waitid()).
- */
-sc_exit_code
-sc_process_wait(sc_pid pid, bool close);
+// kill the process
+bool
+process_terminate(process_t pid);

-/**
- * Close (reap) the process
- *
- * Semantically:
- *    sc_process_wait(close) = sc_process_wait(noclose) + sc_process_close()
- */
+// wait and close the process (like waitpid())
+// the "close" flag indicates if the process must be "closed" (reaped)
+// (passing false is equivalent to enable WNOWAIT in waitid())
+exit_code_t
+process_wait(process_t pid, bool close);
+
+// close the process
+//
+// Semantically, process_wait(close) = process_wait(noclose) + process_close
 void
-sc_process_close(sc_pid pid);
+process_close(process_t pid);
+
+// convenience function to wait for a successful process execution
+// automatically log process errors with the provided process name
+bool
+process_check_success(process_t proc, const char *name, bool close);
+
+#ifndef _WIN32
+// only used to find package manager, not implemented for Windows
+bool
+search_executable(const char *file);
+#endif
+
+// return the absolute path of the executable (the scrcpy binary)
+// may be NULL on error; to be freed by free()
+char *
+get_executable_path(void);
+
+// Return the absolute path of a file in the same directory as he executable.
+// May be NULL on error. To be freed by free().
+char *
+get_local_file_path(const char *name);
+
+// returns true if the file exists and is not a directory
+bool
+is_regular_file(const char *path);

-/**
- * Read from the pipe
- *
- * Same semantic as read().
- */
 ssize_t
-sc_pipe_read(sc_pipe pipe, char *data, size_t len);
+read_pipe(pipe_t pipe, char *data, size_t len);

-/**
- * Read exactly `len` chars from a pipe (unless EOF)
- */
 ssize_t
-sc_pipe_read_all(sc_pipe pipe, char *data, size_t len);
+read_pipe_all(pipe_t pipe, char *data, size_t len);

-/**
- * Close the pipe
- */
 void
-sc_pipe_close(sc_pipe pipe);
-
-/**
- * Start observing process
- *
- * The listener is optional. If set, its callback will be called from the
- * observer thread once the process is terminated.
- */
-bool
-sc_process_observer_init(struct sc_process_observer *observer, sc_pid pid,
-                         const struct sc_process_listener *listener,
-                         void *listener_userdata);
-
-/**
- * Wait for process termination until a deadline
- *
- * Return true if the process is already terminated. Return false if the
- * process terminatation has not been detected yet (however, it may have
- * terminated in the meantime).
- *
- * To wait without timeout/deadline, just use sc_process_wait() instead.
- */
-bool
-sc_process_observer_timedwait(struct sc_process_observer *observer,
-                              sc_tick deadline);
-
-/**
- * Join the observer thread
- */
-void
-sc_process_observer_join(struct sc_process_observer *observer);
-
-/**
- * Destroy the observer
- *
- * This does not close the associated process.
- */
-void
-sc_process_observer_destroy(struct sc_process_observer *observer);
+close_pipe(pipe_t pipe);

 #endif
--- a/app/src/util/process_intr.c
+++ b/app/src/util/process_intr.c
@ -1,29 +0,0 @@
-#include "process_intr.h"
-
-ssize_t
-sc_pipe_read_intr(struct sc_intr *intr, sc_pid pid, sc_pipe pipe, char *data,
-                  size_t len) {
-    if (!sc_intr_set_process(intr, pid)) {
-        // Already interrupted
-        return false;
-    }
-
-    ssize_t ret = sc_pipe_read(pipe, data, len);
-
-    sc_intr_set_process(intr, SC_PROCESS_NONE);
-    return ret;
-}
-
-ssize_t
-sc_pipe_read_all_intr(struct sc_intr *intr, sc_pid pid, sc_pipe pipe,
-                      char *data, size_t len) {
-    if (!sc_intr_set_process(intr, pid)) {
-        // Already interrupted
-        return false;
-    }
-
-    ssize_t ret = sc_pipe_read_all(pipe, data, len);
-
-    sc_intr_set_process(intr, SC_PROCESS_NONE);
-    return ret;
-}
--- a/app/src/util/process_intr.h
+++ b/app/src/util/process_intr.h
@ -1,17 +0,0 @@
-#ifndef SC_PROCESS_INTR_H
-#define SC_PROCESS_INTR_H
-
-#include "common.h"
-
-#include "intr.h"
-#include "process.h"
-
-ssize_t
-sc_pipe_read_intr(struct sc_intr *intr, sc_pid pid, sc_pipe pipe, char *data,
-                  size_t len);
-
-ssize_t
-sc_pipe_read_all_intr(struct sc_intr *intr, sc_pid pid, sc_pipe pipe,
-                      char *data, size_t len);
-
-#endif
--- a/app/src/util/str.h
+++ b/app/src/util/str.h
@ -1,148 +0,0 @@
-#ifndef SC_STR_H
-#define SC_STR_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stddef.h>
-
-/**
- * Like strncpy(), except:
- *  - it copies at most n-1 chars
- *  - the dest string is nul-terminated
- *  - it does not write useless bytes if strlen(src) < n
- *  - it returns the number of chars actually written (max n-1) if src has
- *    been copied completely, or n if src has been truncated
- */
-size_t
-sc_strncpy(char *dest, const char *src, size_t n);
-
-/**
- * Join tokens by separator `sep` into `dst`
- *
- * Return the number of chars actually written (max n-1) if no truncation
- * occurred, or n if truncated.
- */
-size_t
-sc_str_join(char *dst, const char *const tokens[], char sep, size_t n);
-
-/**
- * Quote a string
- *
- * Return a new allocated string, surrounded with quotes (`"`).
- */
-char *
-sc_str_quote(const char *src);
-
-/**
- * Parse `s` as an integer into `out`
- *
- * Return true if the conversion succeeded, false otherwise.
- */
-bool
-sc_str_parse_integer(const char *s, long *out);
-
-/**
- * Parse `s` as integers separated by `sep` (for example `1234:2000`) into `out`
- *
- * Returns the number of integers on success, 0 on failure.
- */
-size_t
-sc_str_parse_integers(const char *s, const char sep, size_t max_items,
-                      long *out);
-
-/**
- * Parse `s` as an integer into `out`
- *
- * Like `sc_str_parse_integer()`, but accept 'k'/'K' (x1000) and 'm'/'M'
- * (x1000000) as suffixes.
- *
- * Return true if the conversion succeeded, false otherwise.
- */
-bool
-sc_str_parse_integer_with_suffix(const char *s, long *out);
-
-/**
- * Search `s` in the list separated by `sep`
- *
- * For example, sc_str_list_contains("a,bc,def", ',', "bc") returns true.
- */
-bool
-sc_str_list_contains(const char *list, char sep, const char *s);
-
-/**
- * Return the index to truncate a UTF-8 string at a valid position
- */
-size_t
-sc_str_utf8_truncation_index(const char *utf8, size_t max_len);
-
-#ifdef _WIN32
-/**
- * Convert a UTF-8 string to a wchar_t string
- *
- * Return the new allocated string, to be freed by the caller.
- */
-wchar_t *
-sc_str_to_wchars(const char *utf8);
-
-/**
- * Convert a wchar_t string to a UTF-8 string
- *
- * Return the new allocated string, to be freed by the caller.
- */
-char *
-sc_str_from_wchars(const wchar_t *s);
-#endif
-
-/**
- * Wrap input lines to fit in `columns` columns
- *
- * Break input lines at word boundaries (spaces) so that they fit in `columns`
- * columns, left-indented by `indent` spaces.
- */
-char *
-sc_str_wrap_lines(const char *input, unsigned columns, unsigned indent);
-
-/**
- * Truncate the data after any of the characters from `endchars`
- *
- * An '\0' is always written at the end of the data, even if no newline
- * character is encountered.
- *
- * Return the size of the resulting line.
- */
-size_t
-sc_str_truncate(char *data, size_t len, const char *endchars);
-
-/**
- * Find the start of a column in a string
- *
- * A string may represent several columns, separated by some "spaces"
- * (separators). This function aims to find the start of the column number
- * `col`.
- *
- * For example, to find the 4th column (column number 3):
- *
- *     //                               here
- *     //                               v
- *     const char *s = "abc def    ghi  jk";
- *     ssize_t index = sc_str_index_of_column(s, 3, " ");
- *     assert(index == 16); // points to "jk"
- *
- * Return -1 if no such column exists.
- */
-ssize_t
-sc_str_index_of_column(const char *s, unsigned col, const char *seps);
-
-/**
- * Remove all `\r` at the end of the line
- *
- * The line length is provided by `len` (this avoids a call to `strlen()` when
- * the caller already knows the length).
- *
- * Return the new length.
- */
-size_t
-sc_str_remove_trailing_cr(char *s, size_t len);
-
-#endif
--- a/app/src/util/str_util.c
+++ b/app/src/util/str_util.c
@ -1,6 +1,5 @@
-#include "str.h"
+#include "str_util.h"

-#include <assert.h>
 #include <errno.h>
 #include <limits.h>
 #include <stdlib.h>
@ -11,11 +10,8 @@
 # include <tchar.h>
 #endif

-#include "log.h"
-#include "strbuf.h"
-
 size_t
-sc_strncpy(char *dest, const char *src, size_t n) {
+xstrncpy(char *dest, const char *src, size_t n) {
    size_t i;
    for (i = 0; i < n - 1 && src[i] != '\0'; ++i)
        dest[i] = src[i];
@ -25,7 +21,7 @@ sc_strncpy(char *dest, const char *src, size_t n) {
 }

 size_t
-sc_str_join(char *dst, const char *const tokens[], char sep, size_t n) {
+xstrjoin(char *dst, const char *const tokens[], char sep, size_t n) {
    const char *const *remaining = tokens;
    const char *token = *remaining++;
    size_t i = 0;
@ -35,7 +31,7 @@ sc_str_join(char *dst, const char *const tokens[], char sep, size_t n) {
            if (i == n)
                goto truncated;
        }
-        size_t w = sc_strncpy(dst + i, token, n - i);
+        size_t w = xstrncpy(dst + i, token, n - i);
        if (w >= n - i)
            goto truncated;
        i += w;
@ -49,11 +45,10 @@ truncated:
 }

 char *
-sc_str_quote(const char *src) {
+strquote(const char *src) {
    size_t len = strlen(src);
    char *quoted = malloc(len + 3);
    if (!quoted) {
-        LOG_OOM();
        return NULL;
    }
    memcpy(&quoted[1], src, len);
@ -64,7 +59,7 @@ sc_str_quote(const char *src) {
 }

 bool
-sc_str_parse_integer(const char *s, long *out) {
+parse_integer(const char *s, long *out) {
    char *endptr;
    if (*s == '\0') {
        return false;
@ -83,8 +78,7 @@ sc_str_parse_integer(const char *s, long *out) {
 }

 size_t
-sc_str_parse_integers(const char *s, const char sep, size_t max_items,
-                      long *out) {
+parse_integers(const char *s, const char sep, size_t max_items, long *out) {
    size_t count = 0;
    char *endptr;
    do {
@ -113,7 +107,7 @@ sc_str_parse_integers(const char *s, const char sep, size_t max_items,
 }

 bool
-sc_str_parse_integer_with_suffix(const char *s, long *out) {
+parse_integer_with_suffix(const char *s, long *out) {
    char *endptr;
    if (*s == '\0') {
        return false;
@ -147,7 +141,7 @@ sc_str_parse_integer_with_suffix(const char *s, long *out) {
 }

 bool
-sc_str_list_contains(const char *list, char sep, const char *s) {
+strlist_contains(const char *list, char sep, const char *s) {
    char *p;
    do {
        p = strchr(list, sep);
@ -165,7 +159,7 @@ sc_str_list_contains(const char *list, char sep, const char *s) {
 }

 size_t
-sc_str_utf8_truncation_index(const char *utf8, size_t max_len) {
+utf8_truncation_index(const char *utf8, size_t max_len) {
    size_t len = strlen(utf8);
    if (len <= max_len) {
        return len;
@ -183,7 +177,7 @@ sc_str_utf8_truncation_index(const char *utf8, size_t max_len) {
 #ifdef _WIN32

 wchar_t *
-sc_str_to_wchars(const char *utf8) {
+utf8_to_wide_char(const char *utf8) {
    int len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
    if (!len) {
        return NULL;
@ -191,7 +185,6 @@ sc_str_to_wchars(const char *utf8) {

    wchar_t *wide = malloc(len * sizeof(wchar_t));
    if (!wide) {
-        LOG_OOM();
        return NULL;
    }

@ -200,7 +193,7 @@ sc_str_to_wchars(const char *utf8) {
 }

 char *
-sc_str_from_wchars(const wchar_t *ws) {
+utf8_from_wide_char(const wchar_t *ws) {
    int len = WideCharToMultiByte(CP_UTF8, 0, ws, -1, NULL, 0, NULL, NULL);
    if (!len) {
        return NULL;
@ -208,7 +201,6 @@ sc_str_from_wchars(const wchar_t *ws) {

    char *utf8 = malloc(len);
    if (!utf8) {
-        LOG_OOM();
        return NULL;
    }

@ -217,127 +209,3 @@ sc_str_from_wchars(const wchar_t *ws) {
 }

 #endif
-
-char *
-sc_str_wrap_lines(const char *input, unsigned columns, unsigned indent) {
-    assert(indent < columns);
-
-    struct sc_strbuf buf;
-
-    // The output string should not be much longer than the input string (just
-    // a few '\n' added), so this initial capacity should hopefully almost
-    // always avoid internal realloc() in string buffer
-    size_t cap = strlen(input) * 3 / 2;
-
-    if (!sc_strbuf_init(&buf, cap)) {
-        return false;
-    }
-
-#define APPEND(S,N) if (!sc_strbuf_append(&buf, S, N)) goto error
-#define APPEND_CHAR(C) if (!sc_strbuf_append_char(&buf, C)) goto error
-#define APPEND_N(C,N) if (!sc_strbuf_append_n(&buf, C, N)) goto error
-#define APPEND_INDENT() if (indent) APPEND_N(' ', indent)
-
-    APPEND_INDENT();
-
-    // The last separator encountered, it must be inserted only conditionnaly,
-    // depending on the next token
-    char pending = 0;
-
-    // col tracks the current column in the current line
-    size_t col = indent;
-    while (*input) {
-        size_t sep_idx = strcspn(input, "\n ");
-        size_t new_col = col + sep_idx;
-        if (pending == ' ') {
-            // The pending space counts
-            ++new_col;
-        }
-        bool wrap = new_col > columns;
-
-        char sep = input[sep_idx];
-        if (sep == ' ')
-            sep = ' ';
-
-        if (wrap) {
-            APPEND_CHAR('\n');
-            APPEND_INDENT();
-            col = indent;
-        } else if (pending) {
-            APPEND_CHAR(pending);
-            ++col;
-            if (pending == '\n')
-            {
-                APPEND_INDENT();
-                col = indent;
-            }
-        }
-
-        if (sep_idx) {
-            APPEND(input, sep_idx);
-            col += sep_idx;
-        }
-
-        pending = sep;
-
-        input += sep_idx;
-        if (*input != '\0') {
-            // Skip the separator
-            ++input;
-        }
-    }
-
-    if (pending)
-        APPEND_CHAR(pending);
-
-    return buf.s;
-
-error:
-    free(buf.s);
-    return NULL;
-}
-
-size_t
-sc_str_truncate(char *data, size_t len, const char *endchars) {
-    data[len - 1] = '\0';
-    size_t idx = strcspn(data, endchars);
-    data[idx] = '\0';
-    return idx;
-}
-
-ssize_t
-sc_str_index_of_column(const char *s, unsigned col, const char *seps) {
-    size_t colidx = 0;
-
-    size_t idx = 0;
-    while (s[idx] != '\0' && colidx != col) {
-        size_t r = strcspn(&s[idx], seps);
-        idx += r;
-
-        if (s[idx] == '\0') {
-            // Not found
-            return -1;
-        }
-
-        size_t consecutive_seps = strspn(&s[idx], seps);
-        assert(consecutive_seps); // At least one
-        idx += consecutive_seps;
-
-        if (s[idx] != '\0') {
-            ++colidx;
-        }
-    }
-
-    return col == colidx ? (ssize_t) idx : -1;
-}
-
-size_t
-sc_str_remove_trailing_cr(char *s, size_t len) {
-    while (len) {
-        if (s[len - 1] != '\r') {
-            break;
-        }
-        s[--len] = '\0';
-    }
-    return len;
-}
--- a/app/src/util/str_util.h
+++ b/app/src/util/str_util.h
@ -0,0 +1,65 @@
+#ifndef STRUTIL_H
+#define STRUTIL_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <stddef.h>
+
+// like strncpy, except:
+//  - it copies at most n-1 chars
+//  - the dest string is nul-terminated
+//  - it does not write useless bytes if strlen(src) < n
+//  - it returns the number of chars actually written (max n-1) if src has
+//    been copied completely, or n if src has been truncated
+size_t
+xstrncpy(char *dest, const char *src, size_t n);
+
+// join tokens by sep into dst
+// returns the number of chars actually written (max n-1) if no truncation
+// occurred, or n if truncated
+size_t
+xstrjoin(char *dst, const char *const tokens[], char sep, size_t n);
+
+// quote a string
+// returns the new allocated string, to be freed by the caller
+char *
+strquote(const char *src);
+
+// parse s as an integer into value
+// returns true if the conversion succeeded, false otherwise
+bool
+parse_integer(const char *s, long *out);
+
+// parse s as integers separated by sep (for example '1234:2000')
+// returns the number of integers on success, 0 on failure
+size_t
+parse_integers(const char *s, const char sep, size_t max_items, long *out);
+
+// parse s as an integer into value
+// like parse_integer(), but accept 'k'/'K' (x1000) and 'm'/'M' (x1000000) as
+// suffix
+// returns true if the conversion succeeded, false otherwise
+bool
+parse_integer_with_suffix(const char *s, long *out);
+
+// search s in the list separated by sep
+// for example, strlist_contains("a,bc,def", ',', "bc") returns true
+bool
+strlist_contains(const char *list, char sep, const char *s);
+
+// return the index to truncate a UTF-8 string at a valid position
+size_t
+utf8_truncation_index(const char *utf8, size_t max_len);
+
+#ifdef _WIN32
+// convert a UTF-8 string to a wchar_t string
+// returns the new allocated string, to be freed by the caller
+wchar_t *
+utf8_to_wide_char(const char *utf8);
+
+char *
+utf8_from_wide_char(const wchar_t *s);
+#endif
+
+#endif
--- a/app/src/util/strbuf.c
+++ b/app/src/util/strbuf.c
@ -1,90 +0,0 @@
-#include "strbuf.h"
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "log.h"
-
-bool
-sc_strbuf_init(struct sc_strbuf *buf, size_t init_cap) {
-    buf->s = malloc(init_cap + 1); // +1 for '\0'
-    if (!buf->s) {
-        LOG_OOM();
-        return false;
-    }
-
-    buf->len = 0;
-    buf->cap = init_cap;
-    return true;
-}
-
-static bool
-sc_strbuf_reserve(struct sc_strbuf *buf, size_t len) {
-    if (buf->len + len > buf->cap) {
-        size_t new_cap = buf->cap * 3 / 2 + len;
-        char *s = realloc(buf->s, new_cap + 1); // +1 for '\0'
-        if (!s) {
-            // Leave the old buf->s
-            LOG_OOM();
-            return false;
-        }
-        buf->s = s;
-        buf->cap = new_cap;
-    }
-    return true;
-}
-
-bool
-sc_strbuf_append(struct sc_strbuf *buf, const char *s, size_t len) {
-    assert(s);
-    assert(*s);
-    assert(strlen(s) >= len);
-    if (!sc_strbuf_reserve(buf, len)) {
-        return false;
-    }
-
-    memcpy(&buf->s[buf->len], s, len);
-    buf->len += len;
-    buf->s[buf->len] = '\0';
-
-    return true;
-}
-
-bool
-sc_strbuf_append_char(struct sc_strbuf *buf, const char c) {
-    if (!sc_strbuf_reserve(buf, 1)) {
-        return false;
-    }
-
-    buf->s[buf->len] = c;
-    buf->len ++;
-    buf->s[buf->len] = '\0';
-
-    return true;
-}
-
-bool
-sc_strbuf_append_n(struct sc_strbuf *buf, const char c, size_t n) {
-    if (!sc_strbuf_reserve(buf, n)) {
-        return false;
-    }
-
-    memset(&buf->s[buf->len], c, n);
-    buf->len += n;
-    buf->s[buf->len] = '\0';
-
-    return true;
-}
-
-void
-sc_strbuf_shrink(struct sc_strbuf *buf) {
-    assert(buf->len <= buf->cap);
-    if (buf->len != buf->cap) {
-        char *s = realloc(buf->s, buf->len + 1); // +1 for '\0'
-        assert(s); // decreasing the size may not fail
-        buf->s = s;
-        buf->cap = buf->len;
-    }
-}
--- a/app/src/util/strbuf.h
+++ b/app/src/util/strbuf.h
@ -1,73 +0,0 @@
-#ifndef SC_STRBUF_H
-#define SC_STRBUF_H
-
-#include "common.h"
-
-#include <stdbool.h>
-#include <stddef.h>
-#include <string.h>
-
-struct sc_strbuf {
-    char *s;
-    size_t len;
-    size_t cap;
-};
-
-/**
- * Initialize the string buffer
- *
- * `buf->s` must be manually freed by the caller.
- */
-bool
-sc_strbuf_init(struct sc_strbuf *buf, size_t init_cap);
-
-/**
- * Append a string
- *
- * Append `len` characters from `s` to the buffer.
- */
-bool
-sc_strbuf_append(struct sc_strbuf *buf, const char *s, size_t len);
-
-/**
- * Append a char
- *
- * Append a single character to the buffer.
- */
-bool
-sc_strbuf_append_char(struct sc_strbuf *buf, const char c);
-
-/**
- * Append a char `n` times
- *
- * Append the same characters `n` times to the buffer.
- */
-bool
-sc_strbuf_append_n(struct sc_strbuf *buf, const char c, size_t n);
-
-/**
- * Append a NUL-terminated string
- */
-static inline bool
-sc_strbuf_append_str(struct sc_strbuf *buf, const char *s) {
-    return sc_strbuf_append(buf, s, strlen(s));
-}
-
-/**
- * Append a static string
- *
- * Append a string whose size is known at compile time (for
- * example a string literal).
- */
-#define sc_strbuf_append_staticstr(BUF, S) \
-    sc_strbuf_append(BUF, S, sizeof(S) - 1)
-
-/**
- * Shrink the buffer capacity to its current length
- *
- * This resizes `buf->s` to fit the content.
- */
-void
-sc_strbuf_shrink(struct sc_strbuf *buf);
-
-#endif
--- a/app/src/util/term.c
+++ b/app/src/util/term.c
@ -1,51 +0,0 @@
-#include "term.h"
-
-#include <assert.h>
-
-#ifdef _WIN32
-# include <windows.h>
-#else
-# include <unistd.h>
-# include <sys/ioctl.h>
-#endif
-
-bool
-sc_term_get_size(unsigned *rows, unsigned *cols) {
-#ifdef _WIN32
-    CONSOLE_SCREEN_BUFFER_INFO csbi;
-
-    bool ok =
-        GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
-    if (!ok) {
-        return false;
-    }
-
-    if (rows) {
-        assert(csbi.srWindow.Bottom >= csbi.srWindow.Top);
-        *rows = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
-    }
-
-    if (cols) {
-        assert(csbi.srWindow.Right >= csbi.srWindow.Left);
-        *cols = csbi.srWindow.Right - csbi.srWindow.Left + 1;
-    }
-
-    return true;
-#else
-    struct winsize ws;
-    int r = ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws);
-    if (r == -1) {
-        return false;
-    }
-
-    if (rows) {
-        *rows = ws.ws_row;
-    }
-
-    if (cols) {
-        *cols = ws.ws_col;
-    }
-
-    return true;
-#endif
-}
--- a/app/src/util/term.h
+++ b/app/src/util/term.h
@ -1,21 +0,0 @@
-#ifndef SC_TERM_H
-#define SC_TERM_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-/**
- * Return the terminal dimensions
- *
- * Return false if the dimensions could not be retrieved.
- *
- * Otherwise, return true, and:
- *  - if `rows` is not NULL, then the number of rows is written to `*rows`.
- *  - if `columns` is not NULL, then the number of columns is written to
- *    `*columns`.
- */
-bool
-sc_term_get_size(unsigned *rows, unsigned *cols);
-
-#endif
--- a/app/src/util/thread.c
+++ b/app/src/util/thread.c
@ -10,7 +10,6 @@ sc_thread_create(sc_thread *thread, sc_thread_fn fn, const char *name,
                 void *userdata) {
    SDL_Thread *sdl_thread = SDL_CreateThread(fn, name, userdata);
    if (!sdl_thread) {
-        LOG_OOM();
        return false;
    }

@ -27,7 +26,6 @@ bool
 sc_mutex_init(sc_mutex *mutex) {
    SDL_mutex *sdl_mutex = SDL_CreateMutex();
    if (!sdl_mutex) {
-        LOG_OOM();
        return false;
    }

@ -96,7 +94,6 @@ bool
 sc_cond_init(sc_cond *cond) {
    SDL_cond *sdl_cond = SDL_CreateCond();
    if (!sdl_cond) {
-        LOG_OOM();
        return false;
    }

--- a/app/src/util/tick.h
+++ b/app/src/util/tick.h
@ -1,8 +1,6 @@
 #ifndef SC_TICK_H
 #define SC_TICK_H

-#include "common.h"
-
 #include <stdint.h>

 typedef int64_t sc_tick;
--- a/app/src/v4l2_sink.c
+++ b/app/src/v4l2_sink.c
@ -1,9 +1,7 @@
 #include "v4l2_sink.h"

-#include <string.h>
-
 #include "util/log.h"
-#include "util/str.h"
+#include "util/str_util.h"

 /** Downcast frame_sink to sc_v4l2_sink */
 #define DOWNCAST(SINK) container_of(SINK, struct sc_v4l2_sink, frame_sink)
@ -23,7 +21,7 @@ find_muxer(const char *name) {
        oformat = av_oformat_next(oformat);
 #endif
        // until null or containing the requested name
-    } while (oformat && !sc_str_list_contains(oformat->name, ',', name));
+    } while (oformat && !strlist_contains(oformat->name, ',', name));
    return oformat;
 }

@ -33,7 +31,7 @@ write_header(struct sc_v4l2_sink *vs, const AVPacket *packet) {

    uint8_t *extradata = av_malloc(packet->size * sizeof(uint8_t));
    if (!extradata) {
-        LOG_OOM();
+        LOGC("Could not allocate extradata");
        return false;
    }

@ -163,21 +161,25 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {

    bool ok = sc_video_buffer_init(&vs->vb, vs->buffering_time, &cbs, vs);
    if (!ok) {
+        LOGE("Could not initialize video buffer");
        return false;
    }

    ok = sc_video_buffer_start(&vs->vb);
    if (!ok) {
+        LOGE("Could not start video buffer");
        goto error_video_buffer_destroy;
    }

    ok = sc_mutex_init(&vs->mutex);
    if (!ok) {
+        LOGC("Could not create mutex");
        goto error_video_buffer_stop_and_join;
    }

    ok = sc_cond_init(&vs->cond);
    if (!ok) {
+        LOGC("Could not create cond");
        goto error_mutex_destroy;
    }

@ -199,7 +201,7 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {

    vs->format_ctx = avformat_alloc_context();
    if (!vs->format_ctx) {
-        LOG_OOM();
+        LOGE("Could not allocate v4l2 output context");
        return false;
    }

@ -211,8 +213,9 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
 #ifdef SCRCPY_LAVF_HAS_AVFORMATCONTEXT_URL
    vs->format_ctx->url = strdup(vs->device_name);
    if (!vs->format_ctx->url) {
-        LOG_OOM();
+        LOGE("Could not strdup v4l2 device name");
        goto error_avformat_free_context;
+        return false;
    }
 #else
    strncpy(vs->format_ctx->filename, vs->device_name,
@ -221,8 +224,9 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {

    AVStream *ostream = avformat_new_stream(vs->format_ctx, encoder);
    if (!ostream) {
-        LOG_OOM();
+        LOGE("Could not allocate new v4l2 stream");
        goto error_avformat_free_context;
+        return false;
    }

    ostream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
@ -240,7 +244,7 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {

    vs->encoder_ctx = avcodec_alloc_context3(encoder);
    if (!vs->encoder_ctx) {
-        LOG_OOM();
+        LOGC("Could not allocate codec context for v4l2");
        goto error_avio_close;
    }

@ -257,13 +261,13 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {

    vs->frame = av_frame_alloc();
    if (!vs->frame) {
-        LOG_OOM();
+        LOGE("Could not create v4l2 frame");
        goto error_avcodec_close;
    }

    vs->packet = av_packet_alloc();
    if (!vs->packet) {
-        LOG_OOM();
+        LOGE("Could not allocate packet");
        goto error_av_frame_free;
    }

@ -355,7 +359,7 @@ sc_v4l2_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {

 bool
 sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
-                  struct sc_size frame_size, sc_tick buffering_time) {
+                  struct size frame_size, sc_tick buffering_time) {
    vs->device_name = strdup(device_name);
    if (!vs->device_name) {
        LOGE("Could not strdup v4l2 device name");
--- a/app/src/v4l2_sink.h
+++ b/app/src/v4l2_sink.h
@ -18,7 +18,7 @@ struct sc_v4l2_sink {
    AVCodecContext *encoder_ctx;

    char *device_name;
-    struct sc_size frame_size;
+    struct size frame_size;
    sc_tick buffering_time;

    sc_thread thread;
@ -34,7 +34,7 @@ struct sc_v4l2_sink {

 bool
 sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
-                  struct sc_size frame_size, sc_tick buffering_time);
+                  struct size frame_size, sc_tick buffering_time);

 void
 sc_v4l2_sink_destroy(struct sc_v4l2_sink *vs);
--- a/app/src/video_buffer.c
+++ b/app/src/video_buffer.c
@ -14,13 +14,11 @@ static struct sc_video_buffer_frame *
 sc_video_buffer_frame_new(const AVFrame *frame) {
    struct sc_video_buffer_frame *vb_frame = malloc(sizeof(*vb_frame));
    if (!vb_frame) {
-        LOG_OOM();
        return NULL;
    }

    vb_frame->frame = av_frame_alloc();
    if (!vb_frame->frame) {
-        LOG_OOM();
        free(vb_frame);
        return NULL;
    }
@ -134,12 +132,14 @@ sc_video_buffer_init(struct sc_video_buffer *vb, sc_tick buffering_time,
    if (buffering_time) {
        ok = sc_mutex_init(&vb->b.mutex);
        if (!ok) {
+            LOGC("Could not create mutex");
            sc_frame_buffer_destroy(&vb->fb);
            return false;
        }

        ok = sc_cond_init(&vb->b.queue_cond);
        if (!ok) {
+            LOGC("Could not create cond");
            sc_mutex_destroy(&vb->b.mutex);
            sc_frame_buffer_destroy(&vb->fb);
            return false;
@ -147,6 +147,7 @@ sc_video_buffer_init(struct sc_video_buffer *vb, sc_tick buffering_time,

        ok = sc_cond_init(&vb->b.wait_cond);
        if (!ok) {
+            LOGC("Could not create wait cond");
            sc_cond_destroy(&vb->b.queue_cond);
            sc_mutex_destroy(&vb->b.mutex);
            sc_frame_buffer_destroy(&vb->fb);
@ -233,7 +234,7 @@ sc_video_buffer_push(struct sc_video_buffer *vb, const AVFrame *frame) {
    struct sc_video_buffer_frame *vb_frame = sc_video_buffer_frame_new(frame);
    if (!vb_frame) {
        sc_mutex_unlock(&vb->b.mutex);
-        LOG_OOM();
+        LOGE("Could not allocate frame");
        return false;
    }

--- a/app/tests/test_adb_parser.c
+++ b/app/tests/test_adb_parser.c
@ -1,83 +0,0 @@
-#include "common.h"
-
-#include <assert.h>
-
-#include "adb_parser.h"
-
-static void test_get_ip_single_line() {
-    char ip_route[] = "192.168.1.0/24 dev wlan0  proto kernel  scope link  src "
-                      "192.168.12.34\r\r\n";
-
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route, sizeof(ip_route));
-    assert(ip);
-    assert(!strcmp(ip, "192.168.12.34"));
-}
-
-static void test_get_ip_single_line_without_eol() {
-    char ip_route[] = "192.168.1.0/24 dev wlan0  proto kernel  scope link  src "
-                      "192.168.12.34";
-
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route, sizeof(ip_route));
-    assert(ip);
-    assert(!strcmp(ip, "192.168.12.34"));
-}
-
-static void test_get_ip_single_line_with_trailing_space() {
-    char ip_route[] = "192.168.1.0/24 dev wlan0  proto kernel  scope link  src "
-                      "192.168.12.34 \n";
-
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route, sizeof(ip_route));
-    assert(ip);
-    assert(!strcmp(ip, "192.168.12.34"));
-}
-
-static void test_get_ip_multiline_first_ok() {
-    char ip_route[] = "192.168.1.0/24 dev wlan0  proto kernel  scope link  src "
-                      "192.168.1.2\r\n"
-                      "10.0.0.0/24 dev rmnet  proto kernel  scope link  src "
-                      "10.0.0.2\r\n";
-
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route, sizeof(ip_route));
-    assert(ip);
-    assert(!strcmp(ip, "192.168.1.2"));
-}
-
-static void test_get_ip_multiline_second_ok() {
-    char ip_route[] = "10.0.0.0/24 dev rmnet  proto kernel  scope link  src "
-                      "10.0.0.3\r\n"
-                      "192.168.1.0/24 dev wlan0  proto kernel  scope link  src "
-                      "192.168.1.3\r\n";
-
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route, sizeof(ip_route));
-    assert(ip);
-    assert(!strcmp(ip, "192.168.1.3"));
-}
-
-static void test_get_ip_no_wlan() {
-    char ip_route[] = "192.168.1.0/24 dev rmnet  proto kernel  scope link  src "
-                      "192.168.12.34\r\r\n";
-
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route, sizeof(ip_route));
-    assert(!ip);
-}
-
-static void test_get_ip_truncated() {
-    char ip_route[] = "192.168.1.0/24 dev rmnet  proto kernel  scope link  src "
-                      "\n";
-
-    char *ip = sc_adb_parse_device_ip_from_output(ip_route, sizeof(ip_route));
-    assert(!ip);
-}
-
-int main(int argc, char *argv[]) {
-    (void) argc;
-    (void) argv;
-
-    test_get_ip_single_line();
-    test_get_ip_single_line_without_eol();
-    test_get_ip_single_line_with_trailing_space();
-    test_get_ip_multiline_first_ok();
-    test_get_ip_multiline_second_ok();
-    test_get_ip_no_wlan();
-    test_get_ip_truncated();
-}
--- a/app/tests/test_cli.c
+++ b/app/tests/test_cli.c
@ -4,11 +4,11 @@
 #include <string.h>

 #include "cli.h"
-#include "options.h"
+#include "scrcpy.h"

 static void test_flag_version(void) {
    struct scrcpy_cli_args args = {
-        .opts = scrcpy_options_default,
+        .opts = SCRCPY_OPTIONS_DEFAULT,
        .help = false,
        .version = false,
    };
@ -23,7 +23,7 @@ static void test_flag_version(void) {

 static void test_flag_help(void) {
    struct scrcpy_cli_args args = {
-        .opts = scrcpy_options_default,
+        .opts = SCRCPY_OPTIONS_DEFAULT,
        .help = false,
        .version = false,
    };
@ -38,7 +38,7 @@ static void test_flag_help(void) {

 static void test_options(void) {
    struct scrcpy_cli_args args = {
-        .opts = scrcpy_options_default,
+        .opts = SCRCPY_OPTIONS_DEFAULT,
        .help = false,
        .version = false,
    };
@ -100,7 +100,7 @@ static void test_options(void) {

 static void test_options2(void) {
    struct scrcpy_cli_args args = {
-        .opts = scrcpy_options_default,
+        .opts = SCRCPY_OPTIONS_DEFAULT,
        .help = false,
        .version = false,
    };
--- a/app/tests/test_control_msg_serialize.c
+++ b/app/tests/test_control_msg_serialize.c
@ -78,7 +78,7 @@ static void test_serialize_inject_touch_event(void) {
        .type = CONTROL_MSG_TYPE_INJECT_TOUCH_EVENT,
        .inject_touch_event = {
            .action = AMOTION_EVENT_ACTION_DOWN,
-            .pointer_id = UINT64_C(0x1234567887654321),
+            .pointer_id = 0x1234567887654321L,
            .position = {
                .point = {
                    .x = 100,
@ -226,7 +226,6 @@ static void test_serialize_set_clipboard(void) {
    struct control_msg msg = {
        .type = CONTROL_MSG_TYPE_SET_CLIPBOARD,
        .set_clipboard = {
-            .sequence = UINT64_C(0x0102030405060708),
            .paste = true,
            .text = "hello, world!",
        },
@ -234,11 +233,10 @@ static void test_serialize_set_clipboard(void) {

    unsigned char buf[CONTROL_MSG_MAX_SIZE];
    size_t size = control_msg_serialize(&msg, buf);
-    assert(size == 27);
+    assert(size == 19);

    const unsigned char expected[] = {
        CONTROL_MSG_TYPE_SET_CLIPBOARD,
-        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // sequence
        1, // paste
        0x00, 0x00, 0x00, 0x0d, // text length
        'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', // text
--- a/app/tests/test_device_msg_deserialize.c
+++ b/app/tests/test_device_msg_deserialize.c
@ -47,26 +47,11 @@ static void test_deserialize_clipboard_big(void) {
    device_msg_destroy(&msg);
 }

-static void test_deserialize_ack_set_clipboard(void) {
-    const unsigned char input[] = {
-        DEVICE_MSG_TYPE_ACK_CLIPBOARD,
-        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, // sequence
-    };
-
-    struct device_msg msg;
-    ssize_t r = device_msg_deserialize(input, sizeof(input), &msg);
-    assert(r == 9);
-
-    assert(msg.type == DEVICE_MSG_TYPE_ACK_CLIPBOARD);
-    assert(msg.ack_clipboard.sequence == UINT64_C(0x0102030405060708));
-}
-
 int main(int argc, char *argv[]) {
    (void) argc;
    (void) argv;

    test_deserialize_clipboard();
    test_deserialize_clipboard_big();
-    test_deserialize_ack_set_clipboard();
    return 0;
 }
--- a/app/tests/test_str.c
+++ b/app/tests/test_str.c
@ -1,424 +0,0 @@
-#include "common.h"
-
-#include <assert.h>
-#include <limits.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "util/str.h"
-
-static void test_strncpy_simple(void) {
-    char s[] = "xxxxxxxxxx";
-    size_t w = sc_strncpy(s, "abcdef", sizeof(s));
-
-    // returns strlen of copied string
-    assert(w == 6);
-
-    // is nul-terminated
-    assert(s[6] == '\0');
-
-    // does not write useless bytes
-    assert(s[7] == 'x');
-
-    // copies the content as expected
-    assert(!strcmp("abcdef", s));
-}
-
-static void test_strncpy_just_fit(void) {
-    char s[] = "xxxxxx";
-    size_t w = sc_strncpy(s, "abcdef", sizeof(s));
-
-    // returns strlen of copied string
-    assert(w == 6);
-
-    // is nul-terminated
-    assert(s[6] == '\0');
-
-    // copies the content as expected
-    assert(!strcmp("abcdef", s));
-}
-
-static void test_strncpy_truncated(void) {
-    char s[] = "xxx";
-    size_t w = sc_strncpy(s, "abcdef", sizeof(s));
-
-    // returns 'n' (sizeof(s))
-    assert(w == 4);
-
-    // is nul-terminated
-    assert(s[3] == '\0');
-
-    // copies the content as expected
-    assert(!strncmp("abcdef", s, 3));
-}
-
-static void test_join_simple(void) {
-    const char *const tokens[] = { "abc", "de", "fghi", NULL };
-    char s[] = "xxxxxxxxxxxxxx";
-    size_t w = sc_str_join(s, tokens, ' ', sizeof(s));
-
-    // returns strlen of concatenation
-    assert(w == 11);
-
-    // is nul-terminated
-    assert(s[11] == '\0');
-
-    // does not write useless bytes
-    assert(s[12] == 'x');
-
-    // copies the content as expected
-    assert(!strcmp("abc de fghi", s));
-}
-
-static void test_join_just_fit(void) {
-    const char *const tokens[] = { "abc", "de", "fghi", NULL };
-    char s[] = "xxxxxxxxxxx";
-    size_t w = sc_str_join(s, tokens, ' ', sizeof(s));
-
-    // returns strlen of concatenation
-    assert(w == 11);
-
-    // is nul-terminated
-    assert(s[11] == '\0');
-
-    // copies the content as expected
-    assert(!strcmp("abc de fghi", s));
-}
-
-static void test_join_truncated_in_token(void) {
-    const char *const tokens[] = { "abc", "de", "fghi", NULL };
-    char s[] = "xxxxx";
-    size_t w = sc_str_join(s, tokens, ' ', sizeof(s));
-
-    // returns 'n' (sizeof(s))
-    assert(w == 6);
-
-    // is nul-terminated
-    assert(s[5] == '\0');
-
-    // copies the content as expected
-    assert(!strcmp("abc d", s));
-}
-
-static void test_join_truncated_before_sep(void) {
-    const char *const tokens[] = { "abc", "de", "fghi", NULL };
-    char s[] = "xxxxxx";
-    size_t w = sc_str_join(s, tokens, ' ', sizeof(s));
-
-    // returns 'n' (sizeof(s))
-    assert(w == 7);
-
-    // is nul-terminated
-    assert(s[6] == '\0');
-
-    // copies the content as expected
-    assert(!strcmp("abc de", s));
-}
-
-static void test_join_truncated_after_sep(void) {
-    const char *const tokens[] = { "abc", "de", "fghi", NULL };
-    char s[] = "xxxxxxx";
-    size_t w = sc_str_join(s, tokens, ' ', sizeof(s));
-
-    // returns 'n' (sizeof(s))
-    assert(w == 8);
-
-    // is nul-terminated
-    assert(s[7] == '\0');
-
-    // copies the content as expected
-    assert(!strcmp("abc de ", s));
-}
-
-static void test_quote(void) {
-    const char *s = "abcde";
-    char *out = sc_str_quote(s);
-
-    // add '"' at the beginning and the end
-    assert(!strcmp("\"abcde\"", out));
-
-    free(out);
-}
-
-static void test_utf8_truncate(void) {
-    const char *s = "aÉbÔc";
-    assert(strlen(s) == 7); // É and Ô are 2 bytes-wide
-
-    size_t count;
-
-    count = sc_str_utf8_truncation_index(s, 1);
-    assert(count == 1);
-
-    count = sc_str_utf8_truncation_index(s, 2);
-    assert(count == 1); // É is 2 bytes-wide
-
-    count = sc_str_utf8_truncation_index(s, 3);
-    assert(count == 3);
-
-    count = sc_str_utf8_truncation_index(s, 4);
-    assert(count == 4);
-
-    count = sc_str_utf8_truncation_index(s, 5);
-    assert(count == 4); // Ô is 2 bytes-wide
-
-    count = sc_str_utf8_truncation_index(s, 6);
-    assert(count == 6);
-
-    count = sc_str_utf8_truncation_index(s, 7);
-    assert(count == 7);
-
-    count = sc_str_utf8_truncation_index(s, 8);
-    assert(count == 7); // no more chars
-}
-
-static void test_parse_integer(void) {
-    long value;
-    bool ok = sc_str_parse_integer("1234", &value);
-    assert(ok);
-    assert(value == 1234);
-
-    ok = sc_str_parse_integer("-1234", &value);
-    assert(ok);
-    assert(value == -1234);
-
-    ok = sc_str_parse_integer("1234k", &value);
-    assert(!ok);
-
-    ok = sc_str_parse_integer("123456789876543212345678987654321", &value);
-    assert(!ok); // out-of-range
-}
-
-static void test_parse_integers(void) {
-    long values[5];
-
-    size_t count = sc_str_parse_integers("1234", ':', 5, values);
-    assert(count == 1);
-    assert(values[0] == 1234);
-
-    count = sc_str_parse_integers("1234:5678", ':', 5, values);
-    assert(count == 2);
-    assert(values[0] == 1234);
-    assert(values[1] == 5678);
-
-    count = sc_str_parse_integers("1234:5678", ':', 2, values);
-    assert(count == 2);
-    assert(values[0] == 1234);
-    assert(values[1] == 5678);
-
-    count = sc_str_parse_integers("1234:-5678", ':', 2, values);
-    assert(count == 2);
-    assert(values[0] == 1234);
-    assert(values[1] == -5678);
-
-    count = sc_str_parse_integers("1:2:3:4:5", ':', 5, values);
-    assert(count == 5);
-    assert(values[0] == 1);
-    assert(values[1] == 2);
-    assert(values[2] == 3);
-    assert(values[3] == 4);
-    assert(values[4] == 5);
-
-    count = sc_str_parse_integers("1234:5678", ':', 1, values);
-    assert(count == 0); // max_items == 1
-
-    count = sc_str_parse_integers("1:2:3:4:5", ':', 3, values);
-    assert(count == 0); // max_items == 3
-
-    count = sc_str_parse_integers(":1234", ':', 5, values);
-    assert(count == 0); // invalid
-
-    count = sc_str_parse_integers("1234:", ':', 5, values);
-    assert(count == 0); // invalid
-
-    count = sc_str_parse_integers("1234:", ':', 1, values);
-    assert(count == 0); // invalid, even when max_items == 1
-
-    count = sc_str_parse_integers("1234::5678", ':', 5, values);
-    assert(count == 0); // invalid
-}
-
-static void test_parse_integer_with_suffix(void) {
-    long value;
-    bool ok = sc_str_parse_integer_with_suffix("1234", &value);
-    assert(ok);
-    assert(value == 1234);
-
-    ok = sc_str_parse_integer_with_suffix("-1234", &value);
-    assert(ok);
-    assert(value == -1234);
-
-    ok = sc_str_parse_integer_with_suffix("1234k", &value);
-    assert(ok);
-    assert(value == 1234000);
-
-    ok = sc_str_parse_integer_with_suffix("1234m", &value);
-    assert(ok);
-    assert(value == 1234000000);
-
-    ok = sc_str_parse_integer_with_suffix("-1234k", &value);
-    assert(ok);
-    assert(value == -1234000);
-
-    ok = sc_str_parse_integer_with_suffix("-1234m", &value);
-    assert(ok);
-    assert(value == -1234000000);
-
-    ok = sc_str_parse_integer_with_suffix("123456789876543212345678987654321", &value);
-    assert(!ok); // out-of-range
-
-    char buf[32];
-
-    sprintf(buf, "%ldk", LONG_MAX / 2000);
-    ok = sc_str_parse_integer_with_suffix(buf, &value);
-    assert(ok);
-    assert(value == LONG_MAX / 2000 * 1000);
-
-    sprintf(buf, "%ldm", LONG_MAX / 2000);
-    ok = sc_str_parse_integer_with_suffix(buf, &value);
-    assert(!ok);
-
-    sprintf(buf, "%ldk", LONG_MIN / 2000);
-    ok = sc_str_parse_integer_with_suffix(buf, &value);
-    assert(ok);
-    assert(value == LONG_MIN / 2000 * 1000);
-
-    sprintf(buf, "%ldm", LONG_MIN / 2000);
-    ok = sc_str_parse_integer_with_suffix(buf, &value);
-    assert(!ok);
-}
-
-static void test_strlist_contains(void) {
-    assert(sc_str_list_contains("a,bc,def", ',', "bc"));
-    assert(!sc_str_list_contains("a,bc,def", ',', "b"));
-    assert(sc_str_list_contains("", ',', ""));
-    assert(sc_str_list_contains("abc,", ',', ""));
-    assert(sc_str_list_contains(",abc", ',', ""));
-    assert(sc_str_list_contains("abc,,def", ',', ""));
-    assert(!sc_str_list_contains("abc", ',', ""));
-    assert(sc_str_list_contains(",,|x", '|', ",,"));
-    assert(sc_str_list_contains("xyz", '\0', "xyz"));
-}
-
-static void test_wrap_lines(void) {
-    const char *s = "This is a text to test line wrapping. The lines must be "
-                    "wrapped at a space or a line break.\n"
-                    "\n"
-                    "This rectangle must remains a rectangle because it is "
-                    "drawn in lines having lengths lower than the specified "
-                    "number of columns:\n"
-                    "  +----+\n"
-                    "  |    |\n"
-                    "  +----+\n";
-
-    //                     |----      1    1    2  2|
-    //                     |0    5    0    5    0  3| <-- 24 columns
-    const char *expected = "    This is a text to\n"
-                           "    test line wrapping.\n"
-                           "    The lines must be\n"
-                           "    wrapped at a space\n"
-                           "    or a line break.\n"
-                           "    \n"
-                           "    This rectangle must\n"
-                           "    remains a rectangle\n"
-                           "    because it is drawn\n"
-                           "    in lines having\n"
-                           "    lengths lower than\n"
-                           "    the specified number\n"
-                           "    of columns:\n"
-                           "      +----+\n"
-                           "      |    |\n"
-                           "      +----+\n";
-
-    char *formatted = sc_str_wrap_lines(s, 24, 4);
-    assert(formatted);
-
-    assert(!strcmp(formatted, expected));
-
-    free(formatted);
-}
-
-static void test_truncate(void) {
-    char s[] = "hello\nworld\n!";
-    size_t len = sc_str_truncate(s, sizeof(s), "\n");
-
-    assert(len == 5);
-    assert(!strcmp("hello", s));
-
-    char s2[] = "hello\r\nworkd\r\n!";
-    len = sc_str_truncate(s2, sizeof(s2), "\n\r");
-
-    assert(len == 5);
-    assert(!strcmp("hello", s));
-
-    char s3[] = "hello world\n!";
-    len = sc_str_truncate(s3, sizeof(s3), " \n\r");
-
-    assert(len == 5);
-    assert(!strcmp("hello", s3));
-
-    char s4[] = "hello ";
-    len = sc_str_truncate(s4, sizeof(s4), " \n\r");
-
-    assert(len == 5);
-    assert(!strcmp("hello", s4));
-}
-
-static void test_index_of_column(void) {
-    assert(sc_str_index_of_column("a bc  d", 0, " ") == 0);
-    assert(sc_str_index_of_column("a bc  d", 1, " ") == 2);
-    assert(sc_str_index_of_column("a bc  d", 2, " ") == 6);
-    assert(sc_str_index_of_column("a bc  d", 3, " ") == -1);
-
-    assert(sc_str_index_of_column("a  ", 0, " ") == 0);
-    assert(sc_str_index_of_column("a  ", 1, " ") == -1);
-
-    assert(sc_str_index_of_column("", 0, " ") == 0);
-    assert(sc_str_index_of_column("", 1, " ") == -1);
-
-    assert(sc_str_index_of_column("a \t   \t bc  \t  d\t", 0, " \t") == 0);
-    assert(sc_str_index_of_column("a \t   \t bc  \t  d\t", 1, " \t") == 8);
-    assert(sc_str_index_of_column("a \t   \t bc  \t  d\t", 2, " \t") == 15);
-    assert(sc_str_index_of_column("a \t   \t bc  \t  d\t", 3, " \t") == -1);
-
-    assert(sc_str_index_of_column("  a bc  d", 1, " ") == 2);
-}
-
-static void test_remove_trailing_cr() {
-    char s[] = "abc\r";
-    sc_str_remove_trailing_cr(s, sizeof(s) - 1);
-    assert(!strcmp(s, "abc"));
-
-    char s2[] = "def\r\r\r\r";
-    sc_str_remove_trailing_cr(s2, sizeof(s2) - 1);
-    assert(!strcmp(s2, "def"));
-
-    char s3[] = "adb\rdef\r";
-    sc_str_remove_trailing_cr(s3, sizeof(s3) - 1);
-    assert(!strcmp(s3, "adb\rdef"));
-}
-
-int main(int argc, char *argv[]) {
-    (void) argc;
-    (void) argv;
-
-    test_strncpy_simple();
-    test_strncpy_just_fit();
-    test_strncpy_truncated();
-    test_join_simple();
-    test_join_just_fit();
-    test_join_truncated_in_token();
-    test_join_truncated_before_sep();
-    test_join_truncated_after_sep();
-    test_quote();
-    test_utf8_truncate();
-    test_parse_integer();
-    test_parse_integers();
-    test_parse_integer_with_suffix();
-    test_strlist_contains();
-    test_wrap_lines();
-    test_truncate();
-    test_index_of_column();
-    test_remove_trailing_cr();
-    return 0;
-}
--- a/app/tests/test_strbuf.c
+++ b/app/tests/test_strbuf.c
@ -1,48 +0,0 @@
-#include "common.h"
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "util/strbuf.h"
-
-static void test_strbuf_simple(void) {
-    struct sc_strbuf buf;
-    bool ok = sc_strbuf_init(&buf, 10);
-    assert(ok);
-
-    ok = sc_strbuf_append_staticstr(&buf, "Hello");
-    assert(ok);
-
-    ok = sc_strbuf_append_char(&buf, ' ');
-    assert(ok);
-
-    ok = sc_strbuf_append_staticstr(&buf, "world");
-    assert(ok);
-
-    ok = sc_strbuf_append_staticstr(&buf, "!\n");
-    assert(ok);
-
-    ok = sc_strbuf_append_staticstr(&buf, "This is a test");
-    assert(ok);
-
-    ok = sc_strbuf_append_n(&buf, '.', 3);
-    assert(ok);
-
-    assert(!strcmp(buf.s, "Hello world!\nThis is a test..."));
-
-    sc_strbuf_shrink(&buf);
-    assert(buf.len == buf.cap);
-    assert(!strcmp(buf.s, "Hello world!\nThis is a test..."));
-
-    free(buf.s);
-}
-
-int main(int argc, char *argv[]) {
-    (void) argc;
-    (void) argv;
-
-    test_strbuf_simple();
-    return 0;
-}
--- a/app/tests/test_strutil.c
+++ b/app/tests/test_strutil.c
@ -0,0 +1,321 @@
+#include "common.h"
+
+#include <assert.h>
+#include <limits.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "util/str_util.h"
+
+static void test_xstrncpy_simple(void) {
+    char s[] = "xxxxxxxxxx";
+    size_t w = xstrncpy(s, "abcdef", sizeof(s));
+
+    // returns strlen of copied string
+    assert(w == 6);
+
+    // is nul-terminated
+    assert(s[6] == '\0');
+
+    // does not write useless bytes
+    assert(s[7] == 'x');
+
+    // copies the content as expected
+    assert(!strcmp("abcdef", s));
+}
+
+static void test_xstrncpy_just_fit(void) {
+    char s[] = "xxxxxx";
+    size_t w = xstrncpy(s, "abcdef", sizeof(s));
+
+    // returns strlen of copied string
+    assert(w == 6);
+
+    // is nul-terminated
+    assert(s[6] == '\0');
+
+    // copies the content as expected
+    assert(!strcmp("abcdef", s));
+}
+
+static void test_xstrncpy_truncated(void) {
+    char s[] = "xxx";
+    size_t w = xstrncpy(s, "abcdef", sizeof(s));
+
+    // returns 'n' (sizeof(s))
+    assert(w == 4);
+
+    // is nul-terminated
+    assert(s[3] == '\0');
+
+    // copies the content as expected
+    assert(!strncmp("abcdef", s, 3));
+}
+
+static void test_xstrjoin_simple(void) {
+    const char *const tokens[] = { "abc", "de", "fghi", NULL };
+    char s[] = "xxxxxxxxxxxxxx";
+    size_t w = xstrjoin(s, tokens, ' ', sizeof(s));
+
+    // returns strlen of concatenation
+    assert(w == 11);
+
+    // is nul-terminated
+    assert(s[11] == '\0');
+
+    // does not write useless bytes
+    assert(s[12] == 'x');
+
+    // copies the content as expected
+    assert(!strcmp("abc de fghi", s));
+}
+
+static void test_xstrjoin_just_fit(void) {
+    const char *const tokens[] = { "abc", "de", "fghi", NULL };
+    char s[] = "xxxxxxxxxxx";
+    size_t w = xstrjoin(s, tokens, ' ', sizeof(s));
+
+    // returns strlen of concatenation
+    assert(w == 11);
+
+    // is nul-terminated
+    assert(s[11] == '\0');
+
+    // copies the content as expected
+    assert(!strcmp("abc de fghi", s));
+}
+
+static void test_xstrjoin_truncated_in_token(void) {
+    const char *const tokens[] = { "abc", "de", "fghi", NULL };
+    char s[] = "xxxxx";
+    size_t w = xstrjoin(s, tokens, ' ', sizeof(s));
+
+    // returns 'n' (sizeof(s))
+    assert(w == 6);
+
+    // is nul-terminated
+    assert(s[5] == '\0');
+
+    // copies the content as expected
+    assert(!strcmp("abc d", s));
+}
+
+static void test_xstrjoin_truncated_before_sep(void) {
+    const char *const tokens[] = { "abc", "de", "fghi", NULL };
+    char s[] = "xxxxxx";
+    size_t w = xstrjoin(s, tokens, ' ', sizeof(s));
+
+    // returns 'n' (sizeof(s))
+    assert(w == 7);
+
+    // is nul-terminated
+    assert(s[6] == '\0');
+
+    // copies the content as expected
+    assert(!strcmp("abc de", s));
+}
+
+static void test_xstrjoin_truncated_after_sep(void) {
+    const char *const tokens[] = { "abc", "de", "fghi", NULL };
+    char s[] = "xxxxxxx";
+    size_t w = xstrjoin(s, tokens, ' ', sizeof(s));
+
+    // returns 'n' (sizeof(s))
+    assert(w == 8);
+
+    // is nul-terminated
+    assert(s[7] == '\0');
+
+    // copies the content as expected
+    assert(!strcmp("abc de ", s));
+}
+
+static void test_strquote(void) {
+    const char *s = "abcde";
+    char *out = strquote(s);
+
+    // add '"' at the beginning and the end
+    assert(!strcmp("\"abcde\"", out));
+
+    free(out);
+}
+
+static void test_utf8_truncate(void) {
+    const char *s = "aÉbÔc";
+    assert(strlen(s) == 7); // É and Ô are 2 bytes-wide
+
+    size_t count;
+
+    count = utf8_truncation_index(s, 1);
+    assert(count == 1);
+
+    count = utf8_truncation_index(s, 2);
+    assert(count == 1); // É is 2 bytes-wide
+
+    count = utf8_truncation_index(s, 3);
+    assert(count == 3);
+
+    count = utf8_truncation_index(s, 4);
+    assert(count == 4);
+
+    count = utf8_truncation_index(s, 5);
+    assert(count == 4); // Ô is 2 bytes-wide
+
+    count = utf8_truncation_index(s, 6);
+    assert(count == 6);
+
+    count = utf8_truncation_index(s, 7);
+    assert(count == 7);
+
+    count = utf8_truncation_index(s, 8);
+    assert(count == 7); // no more chars
+}
+
+static void test_parse_integer(void) {
+    long value;
+    bool ok = parse_integer("1234", &value);
+    assert(ok);
+    assert(value == 1234);
+
+    ok = parse_integer("-1234", &value);
+    assert(ok);
+    assert(value == -1234);
+
+    ok = parse_integer("1234k", &value);
+    assert(!ok);
+
+    ok = parse_integer("123456789876543212345678987654321", &value);
+    assert(!ok); // out-of-range
+}
+
+static void test_parse_integers(void) {
+    long values[5];
+
+    size_t count = parse_integers("1234", ':', 5, values);
+    assert(count == 1);
+    assert(values[0] == 1234);
+
+    count = parse_integers("1234:5678", ':', 5, values);
+    assert(count == 2);
+    assert(values[0] == 1234);
+    assert(values[1] == 5678);
+
+    count = parse_integers("1234:5678", ':', 2, values);
+    assert(count == 2);
+    assert(values[0] == 1234);
+    assert(values[1] == 5678);
+
+    count = parse_integers("1234:-5678", ':', 2, values);
+    assert(count == 2);
+    assert(values[0] == 1234);
+    assert(values[1] == -5678);
+
+    count = parse_integers("1:2:3:4:5", ':', 5, values);
+    assert(count == 5);
+    assert(values[0] == 1);
+    assert(values[1] == 2);
+    assert(values[2] == 3);
+    assert(values[3] == 4);
+    assert(values[4] == 5);
+
+    count = parse_integers("1234:5678", ':', 1, values);
+    assert(count == 0); // max_items == 1
+
+    count = parse_integers("1:2:3:4:5", ':', 3, values);
+    assert(count == 0); // max_items == 3
+
+    count = parse_integers(":1234", ':', 5, values);
+    assert(count == 0); // invalid
+
+    count = parse_integers("1234:", ':', 5, values);
+    assert(count == 0); // invalid
+
+    count = parse_integers("1234:", ':', 1, values);
+    assert(count == 0); // invalid, even when max_items == 1
+
+    count = parse_integers("1234::5678", ':', 5, values);
+    assert(count == 0); // invalid
+}
+
+static void test_parse_integer_with_suffix(void) {
+    long value;
+    bool ok = parse_integer_with_suffix("1234", &value);
+    assert(ok);
+    assert(value == 1234);
+
+    ok = parse_integer_with_suffix("-1234", &value);
+    assert(ok);
+    assert(value == -1234);
+
+    ok = parse_integer_with_suffix("1234k", &value);
+    assert(ok);
+    assert(value == 1234000);
+
+    ok = parse_integer_with_suffix("1234m", &value);
+    assert(ok);
+    assert(value == 1234000000);
+
+    ok = parse_integer_with_suffix("-1234k", &value);
+    assert(ok);
+    assert(value == -1234000);
+
+    ok = parse_integer_with_suffix("-1234m", &value);
+    assert(ok);
+    assert(value == -1234000000);
+
+    ok = parse_integer_with_suffix("123456789876543212345678987654321", &value);
+    assert(!ok); // out-of-range
+
+    char buf[32];
+
+    sprintf(buf, "%ldk", LONG_MAX / 2000);
+    ok = parse_integer_with_suffix(buf, &value);
+    assert(ok);
+    assert(value == LONG_MAX / 2000 * 1000);
+
+    sprintf(buf, "%ldm", LONG_MAX / 2000);
+    ok = parse_integer_with_suffix(buf, &value);
+    assert(!ok);
+
+    sprintf(buf, "%ldk", LONG_MIN / 2000);
+    ok = parse_integer_with_suffix(buf, &value);
+    assert(ok);
+    assert(value == LONG_MIN / 2000 * 1000);
+
+    sprintf(buf, "%ldm", LONG_MIN / 2000);
+    ok = parse_integer_with_suffix(buf, &value);
+    assert(!ok);
+}
+
+static void test_strlist_contains(void) {
+    assert(strlist_contains("a,bc,def", ',', "bc"));
+    assert(!strlist_contains("a,bc,def", ',', "b"));
+    assert(strlist_contains("", ',', ""));
+    assert(strlist_contains("abc,", ',', ""));
+    assert(strlist_contains(",abc", ',', ""));
+    assert(strlist_contains("abc,,def", ',', ""));
+    assert(!strlist_contains("abc", ',', ""));
+    assert(strlist_contains(",,|x", '|', ",,"));
+    assert(strlist_contains("xyz", '\0', "xyz"));
+}
+
+int main(int argc, char *argv[]) {
+    (void) argc;
+    (void) argv;
+
+    test_xstrncpy_simple();
+    test_xstrncpy_just_fit();
+    test_xstrncpy_truncated();
+    test_xstrjoin_simple();
+    test_xstrjoin_just_fit();
+    test_xstrjoin_truncated_in_token();
+    test_xstrjoin_truncated_before_sep();
+    test_xstrjoin_truncated_after_sep();
+    test_strquote();
+    test_utf8_truncate();
+    test_parse_integer();
+    test_parse_integers();
+    test_parse_integer_with_suffix();
+    test_strlist_contains();
+    return 0;
+}
--- a/build.gradle
+++ b/build.gradle
@ -7,7 +7,7 @@ buildscript {
        jcenter()
    }
    dependencies {
-        classpath 'com.android.tools.build:gradle:7.0.2'
+        classpath 'com.android.tools.build:gradle:4.0.1'

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
--- a/config/android-checkstyle.gradle
+++ b/config/android-checkstyle.gradle
@ -2,7 +2,7 @@ apply plugin: 'checkstyle'
 check.dependsOn 'checkstyle'

 checkstyle {
-    toolVersion = '9.0.1'
+    toolVersion = '6.19'
 }

 task checkstyle(type: Checkstyle) {
--- a/config/checkstyle/checkstyle.xml
+++ b/config/checkstyle/checkstyle.xml
@ -37,14 +37,6 @@ page at http://checkstyle.sourceforge.net/config.html -->

  <module name="SuppressWarningsFilter"/>

-  <module name="LineLength">
-    <!-- what is a good max value? -->
-    <property name="max" value="150" />
-    <!-- ignore lines like "$File: //depot/... $" -->
-    <property name="ignorePattern" value="\$File.*\$" />
-    <property name="severity" value="info" />
-  </module>
-
  <module name="TreeWalker">

    <!-- Checks for Naming Conventions.                  -->
@ -80,6 +72,13 @@ page at http://checkstyle.sourceforge.net/config.html -->

    <!-- Checks for Size Violations.                    -->
    <!-- See http://checkstyle.sf.net/config_sizes.html -->
+    <module name="LineLength">
+      <!-- what is a good max value? -->
+      <property name="max" value="150" />
+      <!-- ignore lines like "$File: //depot/... $" -->
+      <property name="ignorePattern" value="\$File.*\$" />
+      <property name="severity" value="info" />
+    </module>
    <module name="MethodLength" />
    <module name="ParameterNumber">
      <property name="ignoreOverriddenMethods" value="true"/>
@ -153,6 +152,26 @@ page at http://checkstyle.sourceforge.net/config.html -->
    </module>
    <module name="UpperEll" />

+    <module name="FileContentsHolder" />
+    <!-- Required by comment suppression filters -->
+
+  </module>
+
+  <module name="SuppressionFilter">
+    <!--<property name="file" value="team-props/checkstyle/checkstyle-suppressions.xml" />-->
+  </module>
+
+  <!-- Enable suppression comments -->
+  <module name="SuppressionCommentFilter">
+    <property name="offCommentFormat" value="CHECKSTYLE IGNORE\s+(\S+)" />
+    <property name="onCommentFormat" value="CHECKSTYLE END IGNORE\s+(\S+)" />
+    <property name="checkFormat" value="$1" />
+  </module>
+  <module name="SuppressWithNearbyCommentFilter">
+    <!-- Syntax is "SUPPRESS CHECKSTYLE name" -->
+    <property name="commentFormat" value="SUPPRESS CHECKSTYLE (\w+)" />
+    <property name="checkFormat" value="$1" />
+    <property name="influenceFormat" value="1" />
  </module>

 </module>
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.0.2-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.3-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
--- a/install_release.sh
+++ b/install_release.sh
@ -2,8 +2,8 @@
 set -e

 BUILDDIR=build-auto
-PREBUILT_SERVER_URL=https://github.com/Genymobile/scrcpy/releases/download/v1.20/scrcpy-server-v1.20
-PREBUILT_SERVER_SHA256=b20aee4951f99b060c4a44000ba94de973f9604758ef62beb253b371aad3df34
+PREBUILT_SERVER_URL=https://github.com/Genymobile/scrcpy/releases/download/v1.19/scrcpy-server-v1.19
+PREBUILT_SERVER_SHA256=876f9322182e6aac6a58db1334f4225855ef3a17eaebc80aab6601d9d1ecb867

 echo "[scrcpy] Downloading prebuilt server..."
 wget "$PREBUILT_SERVER_URL" -O scrcpy-server
--- a/Show More
+++ b/Show More