refilter_on_resize

swscalewip
scale_filter
2021-02-12 23:26:39 +01:00 · 2021-02-12 23:26:39 +01:00 · 2021-02-12 23:20:26 +01:00 · 2021-02-12 23:20:26 +01:00 · 2021-02-12 22:04:50 +01:00 · 2021-02-12 21:58:38 +01:00
92 changed files with 2983 additions and 898 deletions
--- a/BUILD.md
+++ b/BUILD.md
@ -254,10 +254,10 @@ You can then [run](README.md#run) _scrcpy_.

 ## Prebuilt server

- - [`scrcpy-server-v1.16`][direct-scrcpy-server]  
-   _(SHA-256: 94a79e05b4498d0460ab7bd9d12cbf05156e3a47bf0c5d1420cee1d4493b3832)_
+ - [`scrcpy-server-v1.17`][direct-scrcpy-server]  
+   _(SHA-256: 11b5ad2d1bc9b9730fb7254a78efd71a8ff46b1938ff468e47a21b653a1b6725_

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

 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
--- a/FAQ.ko.md
+++ b/FAQ.ko.md
@ -3,16 +3,16 @@
 다음은 자주 제보되는 문제들과 그들의 현황입니다.


-### Window 운영체제에서, 디바이스가 발견되지 않습니다.
+### Windows 운영체제에서, 디바이스가 발견되지 않습니다.

 가장 흔한 제보는 `adb`에 발견되지 않는 디바이스 혹은 권한 관련 문제입니다.
 다음 명령어를 호출하여 모든 것들에 이상이 없는지 확인하세요:

    adb devices

-Window는 당신의 디바이스를 감지하기 위해 [drivers]가 필요할 수도 있습니다.
+Windows는 당신의 디바이스를 감지하기 위해 [드라이버]가 필요할 수도 있습니다.

-[drivers]: https://developer.android.com/studio/run/oem-usb.html
+[드라이버]: https://developer.android.com/studio/run/oem-usb.html


 ### 내 디바이스의 미러링만 가능하고, 디바이스와 상호작용을 할 수 없습니다.
--- a/FAQ.md
+++ b/FAQ.md
@ -199,3 +199,41 @@ scrcpy -m 1920
 scrcpy -m 1024
 scrcpy -m 800
 ```
+
+You could also try another [encoder](README.md#encoder).
+
+
+## Command line on Windows
+
+Some Windows users are not familiar with the command line. Here is how to open a
+terminal and run `scrcpy` with arguments:
+
+ 1. Press <kbd>Windows</kbd>+<kbd>r</kbd>, this opens a dialog box.
+ 2. Type `cmd` and press <kbd>Enter</kbd>, this opens a terminal.
+ 3. Go to your _scrcpy_ directory, by typing (adapt the path):
+
+    ```bat
+    cd C:\Users\user\Downloads\scrcpy-win64-xxx
+    ```
+
+    and press <kbd>Enter</kbd>
+ 4. Type your command. For example:
+
+    ```bat
+    scrcpy --record file.mkv
+    ```
+
+If you plan to always use the same arguments, create a file `myscrcpy.bat`
+(enable [show file extensions] to avoid confusion) in the `scrcpy` directory,
+containing your command. For example:
+
+```bat
+scrcpy --prefer-text --turn-screen-off --stay-awake
+```
+
+Then just double-click on that file.
+
+You could also edit (a copy of) `scrcpy-console.bat` or `scrcpy-noconsole.vbs`
+to add some arguments.
+
+[show file extensions]: https://www.howtogeek.com/205086/beginner-how-to-make-windows-show-file-extensions/
--- a/2
+++ b/2
@ -188,7 +188,7 @@
      identification within third-party archives.

   Copyright (C) 2018 Genymobile
-   Copyright (C) 2018-2020 Romain Vimont
+   Copyright (C) 2018-2021 Romain Vimont

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
--- a/README.id.md
+++ b/README.id.md
@ -0,0 +1,699 @@
+_Only the original [README](README.md) is guaranteed to be up-to-date._
+
+# scrcpy (v1.16)
+
+Aplikasi ini menyediakan tampilan dan kontrol perangkat Android yang terhubung pada USB (atau [melalui TCP/IP][article-tcpip]). Ini tidak membutuhkan akses _root_ apa pun. Ini bekerja pada _GNU/Linux_, _Windows_ and _macOS_.
+
+![screenshot](assets/screenshot-debian-600.jpg)
+
+Ini berfokus pada:
+
+  - **keringanan** (asli, hanya menampilkan layar perangkat)
+  - **kinerja** (30~60fps)
+  - **kualitas** (1920×1080 atau lebih)
+  - **latensi** rendah ([35~70ms][lowlatency])
+  - **waktu startup rendah** (~1 detik untuk menampilkan gambar pertama)
+  - **tidak mengganggu** (tidak ada yang terpasang di perangkat)
+
+
+[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
+
+
+## Persyaratan
+Perangkat Android membutuhkan setidaknya API 21 (Android 5.0).
+
+Pastikan Anda [mengaktifkan debugging adb][enable-adb] pada perangkat Anda.
+
+[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
+
+Di beberapa perangkat, Anda juga perlu mengaktifkan [opsi tambahan][control] untuk mengontrolnya menggunakan keyboard dan mouse.
+
+[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
+
+
+## Dapatkan aplikasinya
+
+### Linux
+
+Di Debian (_testing_ dan _sid_ untuk saat ini) dan Ubuntu (20.04):
+
+```
+apt install scrcpy
+```
+
+Paket [Snap] tersedia: [`scrcpy`][snap-link].
+
+[snap-link]: https://snapstats.org/snaps/scrcpy
+
+[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
+
+Untuk Fedora, paket [COPR] tersedia: [`scrcpy`][copr-link].
+
+[COPR]: https://fedoraproject.org/wiki/Category:Copr
+[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
+
+Untuk Arch Linux, paket [AUR] tersedia: [`scrcpy`][aur-link].
+
+[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
+[aur-link]: https://aur.archlinux.org/packages/scrcpy/
+
+Untuk Gentoo, tersedia [Ebuild]: [`scrcpy/`][ebuild-link].
+
+[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
+[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
+
+Anda juga bisa [membangun aplikasi secara manual][BUILD] (jangan khawatir, tidak terlalu sulit).
+
+
+### Windows
+
+Untuk Windows, untuk kesederhanaan, arsip prebuilt dengan semua dependensi (termasuk `adb`) tersedia :
+
+ - [`scrcpy-win64-v1.16.zip`][direct-win64]  
+   _(SHA-256: 3f30dc5db1a2f95c2b40a0f5de91ec1642d9f53799250a8c529bc882bc0918f0)_
+
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.16/scrcpy-win64-v1.16.zip
+
+Ini juga tersedia di [Chocolatey]:
+
+[Chocolatey]: https://chocolatey.org/
+
+```bash
+choco install scrcpy
+choco install adb    # jika Anda belum memilikinya
+```
+
+Dan di [Scoop]:
+
+```bash
+scoop install scrcpy
+scoop install adb    # jika Anda belum memilikinya
+```
+
+[Scoop]: https://scoop.sh
+
+Anda juga dapat [membangun aplikasi secara manual][BUILD].
+
+
+### macOS
+
+Aplikasi ini tersedia di [Homebrew]. Instal saja:
+
+[Homebrew]: https://brew.sh/
+
+```bash
+brew install scrcpy
+```
+Anda membutuhkan `adb`, dapat diakses dari `PATH` Anda. Jika Anda belum memilikinya:
+
+```bash
+brew cask install android-platform-tools
+```
+
+Anda juga dapat [membangun aplikasi secara manual][BUILD].
+
+
+## Menjalankan
+
+Pasang perangkat Android, dan jalankan:
+
+```bash
+scrcpy
+```
+
+Ini menerima argumen baris perintah, didaftarkan oleh:
+
+```bash
+scrcpy --help
+```
+
+## Fitur
+
+### Menangkap konfigurasi
+
+#### Mengurangi ukuran
+
+Kadang-kadang, berguna untuk mencerminkan perangkat Android dengan definisi yang lebih rendah untuk meningkatkan kinerja.
+
+Untuk membatasi lebar dan tinggi ke beberapa nilai (mis. 1024):
+
+```bash
+scrcpy --max-size 1024
+scrcpy -m 1024  # versi pendek
+```
+
+Dimensi lain dihitung agar rasio aspek perangkat dipertahankan.
+Dengan begitu, perangkat 1920×1080 akan dicerminkan pada 1024×576.
+
+#### Ubah kecepatan bit
+
+Kecepatan bit default adalah 8 Mbps. Untuk mengubah bitrate video (mis. Menjadi 2 Mbps):
+
+```bash
+scrcpy --bit-rate 2M
+scrcpy -b 2M  # versi pendek
+```
+
+#### Batasi frekuensi gambar
+
+Kecepatan bingkai pengambilan dapat dibatasi:
+
+```bash
+scrcpy --max-fps 15
+```
+
+Ini secara resmi didukung sejak Android 10, tetapi dapat berfungsi pada versi sebelumnya.
+
+#### Memotong
+
+Layar perangkat dapat dipotong untuk mencerminkan hanya sebagian dari layar.
+
+Ini berguna misalnya untuk mencerminkan hanya satu mata dari Oculus Go:
+
+```bash
+scrcpy --crop 1224:1440:0:0   # 1224x1440 Mengimbangi (0,0)
+```
+
+Jika `--max-size` juga ditentukan, pengubahan ukuran diterapkan setelah pemotongan.
+
+
+#### Kunci orientasi video
+
+Untuk mengunci orientasi pencerminan:
+
+```bash
+scrcpy --lock-video-orientation 0   # orientasi alami
+scrcpy --lock-video-orientation 1   # 90° berlawanan arah jarum jam
+scrcpy --lock-video-orientation 2   # 180°
+scrcpy --lock-video-orientation 3   # 90° searah jarum jam
+```
+
+Ini mempengaruhi orientasi perekaman.
+
+
+### Rekaman
+
+Anda dapat merekam layar saat melakukan mirroring:
+
+```bash
+scrcpy --record file.mp4
+scrcpy -r file.mkv
+```
+
+Untuk menonaktifkan pencerminan saat merekam:
+
+```bash
+scrcpy --no-display --record file.mp4
+scrcpy -Nr file.mkv
+# berhenti merekam dengan Ctrl+C
+```
+
+"Skipped frames" are recorded, even if they are not displayed in real time (for
+performance reasons). Frames are _timestamped_ on the device, so [packet delay
+variation] does not impact the recorded file.
+
+"Frame yang dilewati" direkam, meskipun tidak ditampilkan secara real time (untuk alasan performa). Bingkai *diberi stempel waktu* pada perangkat, jadi [variasi penundaan paket] tidak memengaruhi file yang direkam.
+
+[variasi penundaan paket]: https://en.wikipedia.org/wiki/Packet_delay_variation
+
+
+### Koneksi
+
+#### Wireless
+
+_Scrcpy_ menggunakan `adb` untuk berkomunikasi dengan perangkat, dan` adb` dapat [terhubung] ke perangkat melalui TCP / IP:
+
+1. Hubungkan perangkat ke Wi-Fi yang sama dengan komputer Anda.
+2. Dapatkan alamat IP perangkat Anda (dalam Pengaturan → Tentang ponsel → Status).
+3. Aktifkan adb melalui TCP / IP pada perangkat Anda: `adb tcpip 5555`.
+4. Cabut perangkat Anda.
+5. Hubungkan ke perangkat Anda: `adb connect DEVICE_IP: 5555` (*ganti* *`DEVICE_IP`*).
+6. Jalankan `scrcpy` seperti biasa.
+
+Mungkin berguna untuk menurunkan kecepatan bit dan definisi:
+
+```bash
+scrcpy --bit-rate 2M --max-size 800
+scrcpy -b2M -m800  # versi pendek
+```
+
+[terhubung]: https://developer.android.com/studio/command-line/adb.html#wireless
+
+
+#### Multi-perangkat
+
+Jika beberapa perangkat dicantumkan di `adb devices`, Anda harus menentukan _serial_:
+
+```bash
+scrcpy --serial 0123456789abcdef
+scrcpy -s 0123456789abcdef  # versi pendek
+```
+
+If the device is connected over TCP/IP:
+
+```bash
+scrcpy --serial 192.168.0.1:5555
+scrcpy -s 192.168.0.1:5555  # versi pendek
+```
+
+Anda dapat memulai beberapa contoh _scrcpy_ untuk beberapa perangkat.
+
+#### Mulai otomatis pada koneksi perangkat
+
+Anda bisa menggunakan [AutoAdb]:
+
+```bash
+autoadb scrcpy -s '{}'
+```
+
+[AutoAdb]: https://github.com/rom1v/autoadb
+
+#### Koneksi via SSH tunnel
+
+Untuk menyambung ke perangkat jarak jauh, dimungkinkan untuk menghubungkan klien `adb` lokal ke server `adb` jarak jauh (asalkan mereka menggunakan versi yang sama dari _adb_ protocol):
+
+```bash
+adb kill-server    # matikan server adb lokal di 5037
+ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 komputer_jarak_jauh_anda
+# jaga agar tetap terbuka
+```
+
+Dari terminal lain:
+
+```bash
+scrcpy
+```
+
+Untuk menghindari mengaktifkan penerusan port jarak jauh, Anda dapat memaksa sambungan maju sebagai gantinya (perhatikan `-L`, bukan` -R`):
+
+```bash
+adb kill-server    # matikan server adb lokal di 5037
+ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 komputer_jarak_jauh_anda
+# jaga agar tetap terbuka
+```
+
+Dari terminal lain:
+
+```bash
+scrcpy --force-adb-forward
+```
+
+Seperti koneksi nirkabel, mungkin berguna untuk mengurangi kualitas:
+
+```
+scrcpy -b2M -m800 --max-fps 15
+```
+
+### Konfigurasi Jendela
+
+#### Judul
+
+Secara default, judul jendela adalah model perangkat. Itu bisa diubah:
+
+```bash
+scrcpy --window-title 'Perangkat Saya'
+```
+
+#### Posisi dan ukuran
+
+Posisi dan ukuran jendela awal dapat ditentukan:
+
+```bash
+scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
+```
+
+#### Jendela tanpa batas
+
+Untuk menonaktifkan dekorasi jendela:
+
+```bash
+scrcpy --window-borderless
+```
+
+#### Selalu di atas
+
+Untuk menjaga jendela scrcpy selalu di atas:
+
+```bash
+scrcpy --always-on-top
+```
+
+#### Layar penuh
+
+Aplikasi dapat dimulai langsung dalam layar penuh::
+
+```bash
+scrcpy --fullscreen
+scrcpy -f  # versi pendek
+```
+
+Layar penuh kemudian dapat diubah secara dinamis dengan <kbd>MOD</kbd>+<kbd>f</kbd>.
+
+#### Rotasi
+
+Jendela mungkin diputar:
+
+```bash
+scrcpy --rotation 1
+```
+
+Nilai yang mungkin adalah:
+ - `0`: tidak ada rotasi
+ - `1`: 90 derajat berlawanan arah jarum jam
+ - `2`: 180 derajat
+ - `3`: 90 derajat searah jarum jam
+
+Rotasi juga dapat diubah secara dinamis dengan <kbd>MOD</kbd>+<kbd>←</kbd>
+_(kiri)_ and <kbd>MOD</kbd>+<kbd>→</kbd> _(kanan)_.
+
+Perhatikan bahwa _scrcpy_ mengelola 3 rotasi berbeda::
+ - <kbd>MOD</kbd>+<kbd>r</kbd> meminta perangkat untuk beralih antara potret dan lanskap (aplikasi yang berjalan saat ini mungkin menolak, jika mendukung orientasi yang diminta).
+ - `--lock-video-orientation` mengubah orientasi pencerminan (orientasi video yang dikirim dari perangkat ke komputer). Ini mempengaruhi rekaman.
+ - `--rotation` (atau <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>)
+   memutar hanya konten jendela. Ini hanya mempengaruhi tampilan, bukan rekaman.
+
+
+### Opsi pencerminan lainnya
+
+#### Hanya-baca
+
+Untuk menonaktifkan kontrol (semua yang dapat berinteraksi dengan perangkat: tombol input, peristiwa mouse, seret & lepas file):
+
+```bash
+scrcpy --no-control
+scrcpy -n
+```
+
+#### Layar
+
+Jika beberapa tampilan tersedia, Anda dapat memilih tampilan untuk cermin:
+
+```bash
+scrcpy --display 1
+```
+
+Daftar id tampilan dapat diambil dengan::
+
+```
+adb shell dumpsys display   # cari "mDisplayId=" di keluaran
+```
+
+Tampilan sekunder hanya dapat dikontrol jika perangkat menjalankan setidaknya Android 10 (jika tidak maka akan dicerminkan dalam hanya-baca).
+
+
+#### Tetap terjaga
+
+Untuk mencegah perangkat tidur setelah beberapa penundaan saat perangkat dicolokkan:
+
+```bash
+scrcpy --stay-awake
+scrcpy -w
+```
+
+Keadaan awal dipulihkan ketika scrcpy ditutup.
+
+
+#### Matikan layar
+
+Dimungkinkan untuk mematikan layar perangkat saat pencerminan mulai dengan opsi baris perintah:
+
+```bash
+scrcpy --turn-screen-off
+scrcpy -S
+```
+
+Atau dengan menekan <kbd>MOD</kbd>+<kbd>o</kbd> kapan saja.
+
+Untuk menyalakannya kembali, tekan <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>.
+
+Di Android, tombol `POWER` selalu menyalakan layar. Untuk kenyamanan, jika `POWER` dikirim melalui scrcpy (melalui klik kanan atau<kbd>MOD</kbd>+<kbd>p</kbd>), itu akan memaksa untuk mematikan layar setelah penundaan kecil (atas dasar upaya terbaik).
+Tombol fisik `POWER` masih akan menyebabkan layar dihidupkan.
+
+Ini juga berguna untuk mencegah perangkat tidur:
+
+```bash
+scrcpy --turn-screen-off --stay-awake
+scrcpy -Sw
+```
+
+#### Render frame kedaluwarsa
+
+Secara default, untuk meminimalkan latensi, _scrcpy_ selalu menampilkan frame yang terakhir didekodekan tersedia, dan menghapus frame sebelumnya.
+
+Untuk memaksa rendering semua frame (dengan kemungkinan peningkatan latensi), gunakan:
+
+```bash
+scrcpy --render-expired-frames
+```
+
+#### Tunjukkan sentuhan
+
+Untuk presentasi, mungkin berguna untuk menunjukkan sentuhan fisik (pada perangkat fisik).
+
+Android menyediakan fitur ini di _Opsi Pengembang_.
+
+_Scrcpy_ menyediakan opsi untuk mengaktifkan fitur ini saat mulai dan mengembalikan nilai awal saat keluar:
+
+```bash
+scrcpy --show-touches
+scrcpy -t
+```
+
+Perhatikan bahwa ini hanya menunjukkan sentuhan _fisik_ (dengan jari di perangkat).
+
+
+#### Nonaktifkan screensaver
+
+Secara default, scrcpy tidak mencegah screensaver berjalan di komputer.
+
+Untuk menonaktifkannya:
+
+```bash
+scrcpy --disable-screensaver
+```
+
+
+### Kontrol masukan
+
+#### Putar layar perangkat
+
+Tekan <kbd>MOD</kbd>+<kbd>r</kbd> untuk beralih antara mode potret dan lanskap.
+
+Perhatikan bahwa itu berputar hanya jika aplikasi di latar depan mendukung orientasi yang diminta.
+
+#### Salin-tempel
+
+Setiap kali papan klip Android berubah, secara otomatis disinkronkan ke papan klip komputer.
+
+Apa saja <kbd>Ctrl</kbd> pintasan diteruskan ke perangkat. Khususnya:
+ - <kbd>Ctrl</kbd>+<kbd>c</kbd> biasanya salinan
+ - <kbd>Ctrl</kbd>+<kbd>x</kbd> biasanya memotong
+ - <kbd>Ctrl</kbd>+<kbd>v</kbd> biasanya menempel (setelah sinkronisasi papan klip komputer-ke-perangkat)
+
+Ini biasanya berfungsi seperti yang Anda harapkan.
+
+Perilaku sebenarnya tergantung pada aplikasi yang aktif. Sebagai contoh,
+_Termux_ mengirim SIGINT ke <kbd>Ctrl</kbd>+<kbd>c</kbd> sebagai gantinya, dan _K-9 Mail_ membuat pesan baru.
+
+Untuk menyalin, memotong dan menempel dalam kasus seperti itu (tetapi hanya didukung di Android> = 7):
+ - <kbd>MOD</kbd>+<kbd>c</kbd> injeksi `COPY` _(salin)_
+ - <kbd>MOD</kbd>+<kbd>x</kbd> injeksi `CUT` _(potong)_
+ - <kbd>MOD</kbd>+<kbd>v</kbd> injeksi `PASTE` (setelah sinkronisasi papan klip komputer-ke-perangkat)
+
+Tambahan, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> memungkinkan untuk memasukkan teks papan klip komputer sebagai urutan peristiwa penting. Ini berguna ketika komponen tidak menerima penempelan teks (misalnya di _Termux_), tetapi dapat merusak konten non-ASCII.
+
+**PERINGATAN:** Menempelkan papan klip komputer ke perangkat (baik melalui
+<kbd>Ctrl</kbd>+<kbd>v</kbd> or <kbd>MOD</kbd>+<kbd>v</kbd>) menyalin konten ke clipboard perangkat. Akibatnya, aplikasi Android apa pun dapat membaca kontennya. Anda harus menghindari menempelkan konten sensitif (seperti kata sandi) seperti itu.
+
+
+#### Cubit untuk memperbesar/memperkecil
+
+Untuk mensimulasikan "cubit-untuk-memperbesar/memperkecil": <kbd>Ctrl</kbd>+_klik-dan-pindah_.
+
+Lebih tepatnya, tahan <kbd>Ctrl</kbd> sambil menekan tombol klik kiri. Hingga tombol klik kiri dilepaskan, semua gerakan mouse berskala dan memutar konten (jika didukung oleh aplikasi) relatif ke tengah layar.
+
+Secara konkret, scrcpy menghasilkan kejadian sentuh tambahan dari "jari virtual" di lokasi yang dibalik melalui bagian tengah layar.
+
+
+#### Preferensi injeksi teks
+
+Ada dua jenis [peristiwa][textevents] dihasilkan saat mengetik teks:
+- _peristiwa penting_, menandakan bahwa tombol ditekan atau dilepaskan;
+- _peristiwa teks_, menandakan bahwa teks telah dimasukkan.
+
+Secara default, huruf dimasukkan menggunakan peristiwa kunci, sehingga keyboard berperilaku seperti yang diharapkan dalam game (biasanya untuk tombol WASD).
+
+Tapi ini mungkin [menyebabkan masalah][prefertext]. Jika Anda mengalami masalah seperti itu, Anda dapat menghindarinya dengan:
+
+```bash
+scrcpy --prefer-text
+```
+
+(tapi ini akan merusak perilaku keyboard dalam game)
+
+[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
+[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
+
+
+#### Ulangi kunci
+
+Secara default, menahan tombol akan menghasilkan peristiwa kunci yang berulang. Ini dapat menyebabkan masalah kinerja di beberapa game, di mana acara ini tidak berguna.
+
+Untuk menghindari penerusan peristiwa penting yang berulang:
+
+```bash
+scrcpy --no-key-repeat
+```
+
+
+### Seret/jatuhkan file
+
+#### Pasang APK
+
+Untuk menginstal APK, seret & lepas file APK (diakhiri dengan `.apk`) ke jendela _scrcpy_.
+
+Tidak ada umpan balik visual, log dicetak ke konsol.
+
+
+#### Dorong file ke perangkat
+
+Untuk mendorong file ke `/sdcard/` di perangkat, seret & jatuhkan file (non-APK) ke jendela _scrcpy_.
+
+Tidak ada umpan balik visual, log dicetak ke konsol.
+
+Direktori target dapat diubah saat mulai:
+
+```bash
+scrcpy --push-target /sdcard/foo/bar/
+```
+
+
+### Penerusan audio
+
+Audio tidak diteruskan oleh _scrcpy_. Gunakan [sndcpy].
+
+Lihat juga [Masalah #14].
+
+[sndcpy]: https://github.com/rom1v/sndcpy
+[Masalah #14]: https://github.com/Genymobile/scrcpy/issues/14
+
+
+## Pintasan
+
+Dalam daftar berikut, <kbd>MOD</kbd> adalah pengubah pintasan. Secara default, ini (kiri) <kbd>Alt</kbd> atau (kiri) <kbd>Super</kbd>.
+
+Ini dapat diubah menggunakan `--shortcut-mod`. Kunci yang memungkinkan adalah `lctrl`,`rctrl`, `lalt`,` ralt`, `lsuper` dan` rsuper`. Sebagai contoh:
+
+```bash
+# gunakan RCtrl untuk jalan pintas
+scrcpy --shortcut-mod=rctrl
+
+# gunakan baik LCtrl+LAlt atau LSuper untuk jalan pintas
+scrcpy --shortcut-mod=lctrl+lalt,lsuper
+```
+
+_<kbd>[Super]</kbd> biasanya adalah <kbd>Windows</kbd> atau <kbd>Cmd</kbd> key._
+
+[Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
+
+ | Aksi                                                  |   Pintasan
+ | ------------------------------------------------------|:-----------------------------
+ | Alihkan mode layar penuh                              | <kbd>MOD</kbd>+<kbd>f</kbd>
+ | Putar layar kiri                                      | <kbd>MOD</kbd>+<kbd>←</kbd> _(kiri)_
+ | Putar layar kanan                                     | <kbd>MOD</kbd>+<kbd>→</kbd> _(kanan)_
+ | Ubah ukuran jendela menjadi 1:1 (piksel-sempurna)     | <kbd>MOD</kbd>+<kbd>g</kbd>
+ | Ubah ukuran jendela menjadi hapus batas hitam         | <kbd>MOD</kbd>+<kbd>w</kbd> \| _klik-dua-kali¹_
+ | Klik `HOME`                                           | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Klik-tengah_
+ | Klik `BACK`                                           | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Klik-kanan²_
+ | Klik `APP_SWITCH`                                     | <kbd>MOD</kbd>+<kbd>s</kbd>
+ | Klik `MENU` (buka kunci layar)                        | <kbd>MOD</kbd>+<kbd>m</kbd>
+ | Klik `VOLUME_UP`                                      | <kbd>MOD</kbd>+<kbd>↑</kbd> _(naik)_
+ | Klik `VOLUME_DOWN`                                    | <kbd>MOD</kbd>+<kbd>↓</kbd> _(turun)_
+ | Klik `POWER`                                          | <kbd>MOD</kbd>+<kbd>p</kbd>
+ | Menyalakan                                            | _Klik-kanan²_
+ | Matikan layar perangkat (tetap mirroring)             | <kbd>MOD</kbd>+<kbd>o</kbd>
+ | Hidupkan layar perangkat                              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>
+ | Putar layar perangkat                                 | <kbd>MOD</kbd>+<kbd>r</kbd>
+ | Luaskan panel notifikasi                              | <kbd>MOD</kbd>+<kbd>n</kbd>
+ | Ciutkan panel notifikasi                              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
+ | Menyalin ke papan klip³                               | <kbd>MOD</kbd>+<kbd>c</kbd>
+ | Potong ke papan klip³                                 | <kbd>MOD</kbd>+<kbd>x</kbd>
+ | Sinkronkan papan klip dan tempel³                     | <kbd>MOD</kbd>+<kbd>v</kbd>
+ | Masukkan teks papan klip komputer                     | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
+ | Mengaktifkan/menonaktifkan penghitung FPS (di stdout) | <kbd>MOD</kbd>+<kbd>i</kbd>
+ | Cubit-untuk-memperbesar/memperkecil                   | <kbd>Ctrl</kbd>+_klik-dan-pindah_
+
+_¹Klik-dua-kali pada batas hitam untuk menghapusnya._  
+_²Klik-kanan akan menghidupkan layar jika mati, tekan BACK jika tidak._  
+_³Hanya di Android >= 7._
+
+Semua <kbd>Ctrl</kbd>+_key_ pintasan diteruskan ke perangkat, demikian adanya
+ditangani oleh aplikasi aktif.
+
+
+## Jalur kustom
+
+Untuk menggunakan biner _adb_ tertentu, konfigurasikan jalurnya di variabel lingkungan `ADB`:
+
+    ADB=/path/to/adb scrcpy
+
+Untuk mengganti jalur file `scrcpy-server`, konfigurasikan jalurnya di
+`SCRCPY_SERVER_PATH`.
+
+[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
+
+
+## Mengapa _scrcpy_?
+
+Seorang kolega menantang saya untuk menemukan nama yang tidak dapat diucapkan seperti [gnirehtet].
+
+[`strcpy`] menyalin sebuah **str**ing; `scrcpy` menyalin sebuah **scr**een.
+
+[gnirehtet]: https://github.com/Genymobile/gnirehtet
+[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
+
+
+## Bagaimana Cara membangun?
+
+Lihat [BUILD].
+
+[BUILD]: BUILD.md
+
+
+## Masalah umum
+
+Lihat [FAQ](FAQ.md).
+
+
+## Pengembang
+
+Baca [halaman pengembang].
+
+[halaman pengembang]: DEVELOP.md
+
+
+## Lisensi
+
+    Copyright (C) 2018 Genymobile
+    Copyright (C) 2018-2021 Romain Vimont
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+## Artikel
+
+- [Introducing scrcpy][article-intro]
+- [Scrcpy now works wirelessly][article-tcpip]
+
+[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
+[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
+
--- a/README.ko.md
+++ b/README.ko.md
@ -477,7 +477,7 @@ _²화면이 꺼진 상태에서 우클릭 시 다시 켜지며, 그 외의 상
 ## 라이선스

    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2020 Romain Vimont
+    Copyright (C) 2018-2021 Romain Vimont

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
--- a/README.md
+++ b/README.md
@ -1,4 +1,4 @@
-# scrcpy (v1.16)
+# scrcpy (v1.17)

 [Read in another language](#translations)

@ -77,10 +77,10 @@ hard).
 For Windows, for simplicity, a prebuilt archive with all the dependencies
 (including `adb`) is available:

- - [`scrcpy-win64-v1.16.zip`][direct-win64]  
-   _(SHA-256: 3f30dc5db1a2f95c2b40a0f5de91ec1642d9f53799250a8c529bc882bc0918f0)_
+ - [`scrcpy-win64-v1.17.zip`][direct-win64]  
+   _(SHA-256: 8b9e57993c707367ed10ebfe0e1ef563c7a29d9af4a355cd8b6a52a317c73eea)_

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

 It is also available in [Chocolatey]:

@ -116,6 +116,10 @@ brew install scrcpy
 You need `adb`, accessible from your `PATH`. If you don't have it yet:

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

@ -202,6 +206,8 @@ scrcpy --lock-video-orientation 3   # 90° clockwise

 This affects recording orientation.

+The [window may also be rotated](#rotation) independently.
+

 #### Encoder

@ -251,7 +257,13 @@ _Scrcpy_ uses `adb` to communicate with the device, and `adb` can [connect] to a
 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).
+2. Get your device IP address, in Settings → About phone → Status, or by
+   executing this command:
+
+    ```bash
+    adb shell ip route | awk '{print $9}'
+    ```
+
 3. Enable adb over TCP/IP on your device: `adb tcpip 5555`.
 4. Unplug your device.
 5. Connect to your device: `adb connect DEVICE_IP:5555` _(replace `DEVICE_IP`)_.
@ -398,12 +410,12 @@ The rotation can also be changed dynamically with <kbd>MOD</kbd>+<kbd>←</kbd>
 _(left)_ and <kbd>MOD</kbd>+<kbd>→</kbd> _(right)_.

 Note that _scrcpy_ manages 3 different rotations:
- <kbd>MOD</kbd>+<kbd>r</kbd> requests the device to switch between portrait and
-  landscape (the current running app may refuse, if it does support the
-  requested orientation).
- - `--lock-video-orientation` changes the mirroring orientation (the orientation
-   of the video sent from the device to the computer). This affects the
-   recording.
+ - <kbd>MOD</kbd>+<kbd>r</kbd> requests the device to switch between portrait
+   and landscape (the current running app may refuse, if it does support the
+   requested orientation).
+ - [`--lock-video-orientation`](#lock-video-orientation) changes the mirroring
+   orientation (the orientation of the video sent from the device to the
+   computer). This affects the recording.
 - `--rotation` (or <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>)
   rotates only the window content. This affects only the display, not the
   recording.
@ -760,7 +772,7 @@ Read the [developers page].
 ## Licence

    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2020 Romain Vimont
+    Copyright (C) 2018-2021 Romain Vimont

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@ -786,8 +798,10 @@ Read the [developers page].

 This README is available in other languages:

- [繁體中文 (Traditional Chinese, `zh-Hant`) - v1.15](README.zh-Hant.md)
+- [Indonesian (Indonesia, `id`) - v1.16](README.id.md)
 - [한국어 (Korean, `ko`) - v1.11](README.ko.md)
 - [português brasileiro (Brazilian Portuguese, `pt-BR`) - v1.12.1](README.pt-br.md)
+- [简体中文 (Simplified Chinese, `zh-Hans`) - v1.16](README.zh-Hans.md)
+- [繁體中文 (Traditional Chinese, `zh-Hant`) - v1.15](README.zh-Hant.md)

 Only this README file is guaranteed to be up-to-date.
--- a/README.pt-br.md
+++ b/README.pt-br.md
@ -508,7 +508,7 @@ Leia a  [developers page].
 ## Licença

    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2020 Romain Vimont
+    Copyright (C) 2018-2021 Romain Vimont

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
--- a/README.zh-Hans.md
+++ b/README.zh-Hans.md
@ -0,0 +1,726 @@
+_Only the original [README](README.md) is guaranteed to be up-to-date._
+
+只有原版的[README](README.md)会保持最新。
+
+本文根据[479d10d]进行翻译。
+
+[479d10d]: https://github.com/Genymobile/scrcpy/commit/479d10dc22b70272187e0963c6ad24d754a669a2#diff-04c6e90faac2675aa89e2176d2eec7d8
+
+
+
+# scrcpy (v1.16)
+
+本应用程序可以通过USB（或 [TCP/IP][article-tcpip] ）连接用于显示或控制安卓设备。这不需要获取 _root_ 权限。
+
+该应用程序可以在 _GNU/Linux_, _Windows_ 和 _macOS_ 环境下运行。
+
+[article-tcpip]:https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
+
+![screenshot](assets/screenshot-debian-600.jpg)
+
+它专注于：
+
+ - **轻量** （原生，仅显示设备屏幕）
+ - **性能** （30~60fps）
+ - **质量** （分辨率可达1920x1080或更高）
+ - **低延迟** (35-70ms)
+ - **快速启动** （数秒内即能开始显示）
+ - **无侵入性** （不需要在安卓设备上安装任何程序）
+
+
+## 使用要求
+
+安卓设备系统版本需要在Android 5.0（API 21)或以上。
+
+确保您在设备上开启了[adb调试]。
+
+[adb调试]: https://developer.android.com/studio/command-line/adb.html#Enabling
+
+在某些设备上，你还需要开启[额外的选项]以用鼠标和键盘进行控制。
+
+[额外的选项]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
+
+
+## 获取scrcpy
+
+<a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>
+
+### Linux
+
+在Debian（目前仅测试版和不稳定版，即 _testing_ 和 _sid_ 版本）和Ubuntu （20.04）上：
+
+```
+apt install scrcpy
+```
+
+[Snap]包也是可用的： [`scrcpy`][snap-link].
+
+[snap-link]: https://snapstats.org/snaps/scrcpy
+
+[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
+
+对于Fedora用户，我们提供[COPR]包： [`scrcpy`][copr-link].
+
+[COPR]: https://fedoraproject.org/wiki/Category:Copr
+[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
+
+对于Arch Linux用户，我们提供[AUR]包： [`scrcpy`][aur-link].
+
+[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
+[aur-link]: https://aur.archlinux.org/packages/scrcpy/
+
+对于Gentoo用户，我们提供[Ebuild]包：[`scrcpy/`][ebuild-link].
+
+[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
+[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
+
+您也可以[自行编译][编译](不必担心，这并不困难)。
+
+
+
+### Windows
+
+在Windows上，简便起见，我们准备了包含所有依赖项（包括adb）的程序包。
+
+ - [`scrcpy-win64-v1.16.zip`][direct-win64]  
+   _(SHA-256: 3f30dc5db1a2f95c2b40a0f5de91ec1642d9f53799250a8c529bc882bc0918f0)_
+
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.16/scrcpy-win64-v1.16.zip
+
+您也可以在[Chocolatey]下载：
+
+[Chocolatey]: https://chocolatey.org/
+
+```bash
+choco install scrcpy
+choco install adb    # 如果你没有adb
+```
+
+也可以使用 [Scoop]:
+
+```bash
+scoop install scrcpy
+scoop install adb    # 如果你没有adb
+```
+
+[Scoop]: https://scoop.sh
+
+您也可以[自行编译][编译]。
+
+
+### macOS
+
+您可以使用[Homebrew]下载scrcpy。直接安装就可以了：
+
+[Homebrew]: https://brew.sh/
+
+```bash
+brew install scrcpy
+```
+
+您需要 `adb`以使用scrcpy，并且它需要可以通过 `PATH`被访问。如果您没有：
+
+```bash
+brew cask install android-platform-tools
+```
+
+您也可以[自行编译][编译]。
+
+
+## 运行scrcpy
+
+用USB链接电脑和安卓设备，并执行：
+
+```bash
+scrcpy
+```
+
+支持带命令行参数执行，查看参数列表：
+
+```bash
+scrcpy --help
+```
+
+## 功能介绍
+
+### 画面设置
+
+#### 缩小分辨率
+
+有时候，将设备屏幕镜像分辨率降低可以有效地提升性能。
+
+我们可以将高度和宽度都限制在一定大小内（如 1024）：
+
+```bash
+scrcpy --max-size 1024
+scrcpy -m 1024  # short version
+```
+
+较短的一边会被按比例缩小以保持设备的显示比例。
+这样，1920x1080 的设备会以 1024x576 的分辨率显示。
+
+
+#### 修改画面比特率
+
+默认的比特率是8Mbps。如果要改变画面的比特率 (比如说改成2Mbps)：
+
+```bash
+scrcpy --bit-rate 2M
+scrcpy -b 2M  # short version
+```
+
+#### 限制画面帧率
+
+画面的帧率可以通过下面的命令被限制：
+
+```bash
+scrcpy --max-fps 15
+```
+
+这个功能仅在Android 10和以后的版本被Android官方支持，但也有可能在更早的版本可用。
+
+#### 画面裁剪
+
+设备画面可在裁切后进行镜像，以显示部分屏幕。
+
+这项功能可以用于，例如，只显示Oculus Go的一只眼睛。
+
+```bash
+scrcpy --crop 1224:1440:0:0   # 1224x1440 at offset (0,0)
+```
+
+如果`--max-size`在同时被指定，分辨率的改变将在画面裁切后进行。
+
+
+#### 锁定屏幕朝向
+
+
+可以使用如下命令锁定屏幕朝向：
+
+```bash
+scrcpy --lock-video-orientation 0   # 自然朝向
+scrcpy --lock-video-orientation 1   # 90° 逆时针旋转
+scrcpy --lock-video-orientation 2   # 180°
+scrcpy --lock-video-orientation 3   # 90° 顺时针旋转
+```
+
+该设定影响录制。
+
+
+### 屏幕录制
+
+可以在屏幕镜像的同时录制视频：
+
+```bash
+scrcpy --record file.mp4
+scrcpy -r file.mkv
+```
+
+在不开启屏幕镜像的同时录制：
+
+```bash
+scrcpy --no-display --record file.mp4
+scrcpy -Nr file.mkv
+# 按Ctrl+C以停止录制
+```
+
+在显示中“被跳过的帧”会被录制，虽然它们由于性能原因没有实时显示。
+在传输中每一帧都有 _时间戳_ ，所以 [包时延变化] 并不影响录制的文件。
+
+[包时延变化]: https://en.wikipedia.org/wiki/Packet_delay_variation
+
+
+### 连接方式
+
+#### 无线
+
+_Scrcpy_ 使用`adb`来与安卓设备连接。同时，`adb`能够通过TCP/IP[连接]到安卓设备:
+
+1. 将您的安卓设备和电脑连接至同一Wi-Fi。
+2. 获取安卓设备的IP地址（在设置-关于手机-状态信息）。
+3. 打开安卓设备的网络adb功能`adb tcpip 5555`。
+4. 将您的设备与电脑断开连接。
+5. 连接到您的设备：`adb connect DEVICE_IP:5555` _(用设备IP替换 `DEVICE_IP`)_.
+6. 运行`scrcpy`。
+
+降低比特率和分辨率可能有助于性能：
+
+```bash
+scrcpy --bit-rate 2M --max-size 800
+scrcpy -b2M -m800  # short version
+```
+
+[连接]: https://developer.android.com/studio/command-line/adb.html#wireless
+
+
+#### 多设备
+
+如果多个设备在执行`adb devices`后被列出，您必须指定设备的 _序列号_ ：
+
+```bash
+scrcpy --serial 0123456789abcdef
+scrcpy -s 0123456789abcdef  # short version
+```
+
+如果设备是通过TCP/IP方式连接到电脑的：
+
+```bash
+scrcpy --serial 192.168.0.1:5555
+scrcpy -s 192.168.0.1:5555  # short version
+```
+
+您可以同时启动多个 _scrcpy_ 实例以同时显示多个设备的画面。
+
+#### 在设备连接时自动启动
+
+您可以使用 [AutoAdb]:
+
+```bash
+autoadb scrcpy -s '{}'
+```
+
+[AutoAdb]: https://github.com/rom1v/autoadb
+
+#### SSH 连接
+
+本地的 adb 可以远程连接到另一个 adb 服务器（假设两者的adb版本相同），来远程连接到设备：
+
+```bash
+adb kill-server    # 关闭本地5037端口上的adb服务器
+ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
+# 保持该窗口开启
+```
+
+从另一个终端：
+
+```bash
+scrcpy
+```
+
+为了避免启动远程端口转发，你可以强制启动一个转发连接（注意`-L`和`-R`的区别：
+
+```bash
+adb kill-server    # kill the local adb server on 5037
+ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
+# 保持该窗口开启
+```
+
+从另一个终端:
+
+```bash
+scrcpy --force-adb-forward
+```
+
+
+和无线网络连接类似，下列设置可能对改善性能有帮助：
+
+```
+scrcpy -b2M -m800 --max-fps 15
+```
+
+### 窗口设置
+
+#### 标题
+
+窗口的标题默认为设备型号。您可以通过如下命令修改它：
+
+```bash
+scrcpy --window-title 'My device'
+```
+
+#### 位置和大小
+
+您可以指定初始的窗口位置和大小：
+
+```bash
+scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
+```
+
+#### 无边框
+
+关闭边框：
+
+```bash
+scrcpy --window-borderless
+```
+
+#### 保持窗口在最前
+
+您可以通过如下命令保持窗口在最前面：
+
+```bash
+scrcpy --always-on-top
+```
+
+#### 全屏
+
+您可以通过如下命令直接全屏启动scrcpy：
+
+```bash
+scrcpy --fullscreen
+scrcpy -f  # short version
+```
+
+全屏状态可以通过<kbd>MOD</kbd>+<kbd>f</kbd>实时改变。
+
+#### 旋转
+
+通过如下命令，窗口可以旋转：
+
+```bash
+scrcpy --rotation 1
+```
+
+可选的值有：
+ - `0`: 无旋转
+ - `1`: 逆时针旋转90°
+ - `2`: 旋转180°
+ - `3`: 顺时针旋转90°
+
+这同样可以使用<kbd>MOD</kbd>+<kbd>←</kbd>
+_(左)_ 和 <kbd>MOD</kbd>+<kbd>→</kbd> _(右)_ 的快捷键实时更改。
+
+需要注意的是， _scrcpy_ 控制三个不同的朝向：
+ - <kbd>MOD</kbd>+<kbd>r</kbd> 请求设备在竖屏和横屏之间切换（如果前台应用程序不支持所请求的朝向，可能会拒绝该请求）。
+
+ - `--lock-video-orientation` 改变镜像的朝向（设备镜像到电脑的画面朝向）。这会影响录制。
+
+ - `--rotation` （或<kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>）
+   只旋转窗口的画面。这只影响显示，不影响录制。
+
+
+### 其他镜像设置
+
+#### 只读
+
+关闭电脑对设备的控制（如键盘输入、鼠标移动和文件传输）：
+
+```bash
+scrcpy --no-control
+scrcpy -n
+```
+
+#### 显示屏
+
+如果有多个显示屏可用，您可以选择特定显示屏进行镜像：
+
+```bash
+scrcpy --display 1
+```
+
+您可以通过如下命令找到显示屏的id：
+
+```
+adb shell dumpsys display   # 在回显中搜索“mDisplayId=”
+```
+
+第二显示屏可能只能在设备运行Android 10或以上的情况下被控制（它可能会在电脑上显示，但无法通过电脑操作）。
+
+
+#### 保持常亮
+
+防止设备在已连接的状态下休眠：
+
+```bash
+scrcpy --stay-awake
+scrcpy -w
+```
+
+程序关闭后，设备设置会恢复原样。
+
+
+#### 关闭设备屏幕
+
+在启动屏幕镜像时，可以通过如下命令关闭设备的屏幕：
+
+```bash
+scrcpy --turn-screen-off
+scrcpy -S
+```
+
+或者在需要的时候按<kbd>MOD</kbd>+<kbd>o</kbd>。
+
+要重新打开屏幕的话，需要按<kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>.
+
+在Android上,`电源`按钮始终能把屏幕打开。
+
+为了方便，如果按下`电源`按钮的事件是通过 _scrcpy_ 发出的（通过点按鼠标右键或<kbd>MOD</kbd>+<kbd>p</kbd>），它会在短暂的延迟后将屏幕关闭。
+
+物理的`电源`按钮仍然能打开设备屏幕。
+
+同时，这项功能还能被用于防止设备休眠：
+
+```bash
+scrcpy --turn-screen-off --stay-awake
+scrcpy -Sw
+```
+
+
+#### 渲染超时帧
+
+为了降低延迟， _scrcpy_ 默认渲染解码成功的最近一帧，并跳过前面任意帧。
+
+强制渲染所有帧（可能导致延迟变高）：
+
+```bash
+scrcpy --render-expired-frames
+```
+
+#### 显示触摸
+
+在展示时，有些时候可能会用到显示触摸点这项功能（在设备上显示）。
+
+Android在 _开发者设置_ 中提供了这项功能。
+
+_Scrcpy_ 提供一个选项可以在启动时开启这项功能并在退出时恢复初始设置：
+
+```bash
+scrcpy --show-touches
+scrcpy -t
+```
+
+请注意这项功能只能显示 _物理_ 触摸（要用手在屏幕上触摸）。
+
+
+#### 关闭屏保
+
+_Scrcpy_ 不会默认关闭屏幕保护。
+
+关闭屏幕保护：
+
+```bash
+scrcpy --disable-screensaver
+```
+
+
+### 输入控制
+
+#### 旋转设备屏幕
+
+使用<kbd>MOD</kbd>+<kbd>r</kbd>以在竖屏和横屏模式之间切换。
+
+需要注意的是，只有在前台应用程序支持所要求的模式时，才会进行切换。
+
+#### 复制黏贴
+
+每次Android的剪贴板变化的时候，它都会被自动同步到电脑的剪贴板上。
+
+所有的 <kbd>Ctrl</kbd> 快捷键都会被转发至设备。其中：
+ - <kbd>Ctrl</kbd>+<kbd>c</kbd> 复制
+ - <kbd>Ctrl</kbd>+<kbd>x</kbd> 剪切
+ - <kbd>Ctrl</kbd>+<kbd>v</kbd> 黏贴 （在电脑到设备的剪贴板同步完成之后）
+
+这通常如您所期望的那样运作。
+
+但实际的行为取决于设备上的前台程序。
+例如 _Termux_ 在<kbd>Ctrl</kbd>+<kbd>c</kbd>被按下时发送 SIGINT，
+又如 _K-9 Mail_ 会新建一封新邮件。
+
+在这种情况下剪切复制黏贴（仅在Android >= 7时可用）：
+ - <kbd>MOD</kbd>+<kbd>c</kbd> 注入 `COPY`（复制）
+ - <kbd>MOD</kbd>+<kbd>x</kbd> 注入 `CUT`（剪切）
+ - <kbd>MOD</kbd>+<kbd>v</kbd> 注入 `PASTE`（黏贴）（在电脑到设备的剪贴板同步完成之后）
+
+另外，<kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>可以将电脑的剪贴板内容转换为一串按键事件输入到设备。
+在应用程序不接受黏贴时（比如 _Termux_ ），这项功能可以排上一定的用场。
+需要注意的是，这项功能可能会导致非ASCII编码的内容出现错误。
+
+**警告：** 将电脑剪贴板的内容黏贴至设备（无论是通过<kbd>Ctrl</kbd>+<kbd>v</kbd>还是<kbd>MOD</kbd>+<kbd>v</kbd>）
+都需要将内容保存至设备的剪贴板。如此，任何一个应用程序都可以读取它。
+您应当避免将敏感内容通过这种方式传输（如密码）。
+
+
+#### 捏拉缩放
+
+模拟 “捏拉缩放”：<kbd>Ctrl</kbd>+_按住并移动鼠标_。
+
+更准确的说，您需要在按住<kbd>Ctrl</kbd>的同时按住并移动鼠标。
+在鼠标左键松开之后，光标的任何操作都会相对于屏幕的中央进行。
+
+具体来说， _scrcpy_ 使用“虚拟手指”以在相对于屏幕中央相反的位置产生触摸事件。
+
+
+#### 文字注入偏好
+
+打字的时候，系统会产生两种[事件][textevents]：
+ - _按键事件_ ，代表一个按键被按下/松开。
+ - _文本事件_ ，代表一个文本被输入。
+
+程序默认使用按键事件来输入字母。只有这样，键盘才会在游戏中正常运作（尤其WASD键）。
+
+但这也有可能[造成问题][prefertext]。如果您遇到了这样的问题，您可以通过下列操作避免它：
+
+```bash
+scrcpy --prefer-text
+```
+
+（这会导致键盘在游戏中工作不正常）
+
+[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
+[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
+
+
+#### 按键重复
+
+当你一直按着一个按键不放时，程序默认产生多个按键事件。
+在某些游戏中这可能会导致性能问题。
+
+避免转发重复按键事件：
+
+```bash
+scrcpy --no-key-repeat
+```
+
+
+### 文件传输
+
+#### 安装APK
+
+如果您要要安装APK，请拖放APK文件（文件名以`.apk`结尾）到 _scrcpy_ 窗口。
+
+该操作在屏幕上不会出现任何变化，而会在控制台输出一条日志。
+
+
+#### 将文件推送至设备
+
+如果您要推送文件到设备的 `/sdcard/`，请拖放文件至（不能是APK文件）_scrcpy_ 窗口。
+
+该操作没有可见的响应，只会在控制台输出日志。
+
+在启动时可以修改目标目录：
+
+```bash
+scrcpy --push-target /sdcard/foo/bar/
+```
+
+
+### 音频转发
+
+_scrcpy_ 不支持音频。请使用 [sndcpy].
+
+另外请阅读 [issue #14]。
+
+[sndcpy]: https://github.com/rom1v/sndcpy
+[issue #14]: https://github.com/Genymobile/scrcpy/issues/14
+
+
+## 热键
+
+在下列表格中, <kbd>MOD</kbd> 是热键的修饰键。
+默认是（左）<kbd>Alt</kbd>或者（左）<kbd>Super</kbd>。
+
+您可以使用 `--shortcut-mod`后缀来修改它。可选的按键有`lctrl`、`rctrl`、
+`lalt`、`ralt`、`lsuper`和`rsuper`。如下例：
+
+```bash
+# 使用右侧的Ctrl键
+scrcpy --shortcut-mod=rctrl
+
+# 使用左侧的Ctrl键、Alt键或Super键
+scrcpy --shortcut-mod=lctrl+lalt,lsuper
+```
+
+_一般来说，<kbd>[Super]</kbd>就是<kbd>Windows</kbd>或者<kbd>Cmd</kbd>。_
+
+[Super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
+
+ | 操作                                        |   快捷键
+ | ------------------------------------------- |:-----------------------------
+ | 全屏                                        | <kbd>MOD</kbd>+<kbd>f</kbd>
+ | 向左旋转屏幕                                 | <kbd>MOD</kbd>+<kbd>←</kbd> _(左)_
+ | 向右旋转屏幕                                 | <kbd>MOD</kbd>+<kbd>→</kbd> _(右)_
+ | 将窗口大小重置为1:1 (像素优先)                | <kbd>MOD</kbd>+<kbd>g</kbd>
+ | 将窗口大小重置为消除黑边                      | <kbd>MOD</kbd>+<kbd>w</kbd> \| _双击¹_
+ | 点按 `主屏幕`                                | <kbd>MOD</kbd>+<kbd>h</kbd> \| _点击鼠标中键_
+ | 点按 `返回`                                  | <kbd>MOD</kbd>+<kbd>b</kbd> \| _点击鼠标右键²_
+ | 点按 `切换应用`                              | <kbd>MOD</kbd>+<kbd>s</kbd>
+ | 点按 `菜单` （解锁屏幕）                      | <kbd>MOD</kbd>+<kbd>m</kbd>
+ | 点按 `音量+`                                | <kbd>MOD</kbd>+<kbd>↑</kbd> _(up)_
+ | 点按 `音量-`                                | <kbd>MOD</kbd>+<kbd>↓</kbd> _(down)_
+ | 点按 `电源`                                 | <kbd>MOD</kbd>+<kbd>p</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>
+ | 展开快捷操作                                 | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>
+ | 复制到剪贴板³                                | <kbd>MOD</kbd>+<kbd>c</kbd>
+ | 剪切到剪贴板³                                | <kbd>MOD</kbd>+<kbd>x</kbd>
+ | 同步剪贴板并黏贴³                            | <kbd>MOD</kbd>+<kbd>v</kbd>
+ | 导入电脑剪贴板文本                           | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>
+ | 打开/关闭FPS显示（在 stdout)                 | <kbd>MOD</kbd>+<kbd>i</kbd>
+ | 捏拉缩放                                    | <kbd>Ctrl</kbd>+_点按并移动鼠标_
+
+_¹双击黑色边界以关闭黑色边界_  
+_²点击鼠标右键将在屏幕熄灭时点亮屏幕，其余情况则视为按下 返回键 。_  
+_³需要安卓版本 Android >= 7。_
+
+所有的 <kbd>Ctrl</kbd>+_按键_ 的热键都是被转发到设备进行处理的，所以实际上会由当前应用程序对其做出响应。
+
+
+## 自定义路径
+
+为了使用您想使用的 _adb_ ，您可以在环境变量
+`ADB`中设置它的路径：
+
+    ADB=/path/to/adb scrcpy
+
+如果需要覆盖`scrcpy-server`的路径，您可以在
+`SCRCPY_SERVER_PATH`中设置它。
+
+[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
+
+
+## 为什么叫 _scrcpy_ ？
+
+一个同事让我找出一个和[gnirehtet]一样难以发音的名字。
+
+[`strcpy`] 可以复制**str**ing； `scrcpy` 可以复制**scr**een。
+
+[gnirehtet]: https://github.com/Genymobile/gnirehtet
+[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
+
+
+## 如何编译？
+
+请查看[编译]。
+
+[编译]: BUILD.md
+
+
+## 常见问题
+
+请查看[FAQ](FAQ.md).
+
+
+## 开发者
+
+请查看[开发者页面]。
+
+[开发者页面]: DEVELOP.md
+
+
+## 许可协议
+
+    Copyright (C) 2018 Genymobile
+    Copyright (C) 2018-2021 Romain Vimont
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+## 相关文章
+
+- [Introducing scrcpy][article-intro]
+- [Scrcpy now works wirelessly][article-tcpip]
+
+[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
+[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
--- a/README.zh-Hant.md
+++ b/README.zh-Hant.md
@ -682,7 +682,7 @@ _³只支援 Android 7+。_
 ## Licence

    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2020 Romain Vimont
+    Copyright (C) 2018-2021 Romain Vimont

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
--- a/app/meson.build
+++ b/app/meson.build
@ -1,7 +1,8 @@
 src = [
    'src/main.c',
+    'src/adb.c',
    'src/cli.c',
-    'src/command.c',
+    'src/compat.c',
    'src/control_msg.c',
    'src/controller.c',
    'src/decoder.c',
@ -10,6 +11,7 @@ src = [
    'src/event_converter.c',
    'src/file_handler.c',
    'src/fps_counter.c',
+    'src/frame_texture.c',
    'src/input_manager.c',
    'src/opengl.c',
    'src/receiver.c',
@ -21,9 +23,23 @@ src = [
    'src/tiny_xpm.c',
    'src/video_buffer.c',
    'src/util/net.c',
-    'src/util/str_util.c'
+    'src/util/process.c',
+    'src/util/str_util.c',
+    'src/util/thread.c',
 ]

+if host_machine.system() == 'windows'
+    src += [ 'src/sys/win/process.c' ]
+else
+    src += [ 'src/sys/unix/process.c' ]
+endif
+
+check_functions = [
+    'strdup'
+]
+
+cc = meson.get_compiler('c')
+
 if not get_option('crossbuild_windows')

    # native build
@ -31,14 +47,13 @@ if not get_option('crossbuild_windows')
        dependency('libavformat'),
        dependency('libavcodec'),
        dependency('libavutil'),
+        dependency('libswscale'),
        dependency('sdl2'),
    ]

 else

    # cross-compile mingw32 build (from Linux to Windows)
-    cc = meson.get_compiler('c')
-
    prebuilt_sdl2 = meson.get_cross_property('prebuilt_sdl2')
    sdl2_bin_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/bin'
    sdl2_lib_dir = meson.current_source_dir() + '/../prebuilt-deps/' + prebuilt_sdl2 + '/lib'
@ -73,17 +88,19 @@ else

 endif

-cc = meson.get_compiler('c')
-
 if host_machine.system() == 'windows'
-    src += [ 'src/sys/win/command.c' ]
    dependencies += cc.find_library('ws2_32')
-else
-    src += [ 'src/sys/unix/command.c' ]
 endif

 conf = configuration_data()

+foreach f : check_functions
+  if cc.has_function(f)
+    define = 'HAVE_' + f.underscorify().to_upper()
+    conf.set(define, true)
+  endif
+endforeach
+
 # expose the build type
 conf.set('NDEBUG', get_option('buildtype') != 'debug')

@ -119,9 +136,6 @@ conf.set('DEFAULT_BIT_RATE', '8000000')  # 8Mbps
 # enable High DPI support
 conf.set('HIDPI_SUPPORT', get_option('hidpi_support'))

-# disable console on Windows
-conf.set('WINDOWS_NOCONSOLE', get_option('windows_noconsole'))
-
 # run a server debugger and wait for a client to be attached
 conf.set('SERVER_DEBUGGER', get_option('server_debugger'))

@ -132,18 +146,11 @@ configure_file(configuration: conf, output: 'config.h')

 src_dir = include_directories('src')

-if get_option('windows_noconsole')
-    link_args = [ '-Wl,--subsystem,windows' ]
-else
-    link_args = []
-endif
-
 executable('scrcpy', src,
           dependencies: dependencies,
           include_directories: src_dir,
           install: true,
-           c_args: [],
-           link_args: link_args)
+           c_args: [])

 install_man('scrcpy.1')

--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@ -167,6 +167,13 @@ Set the initial display rotation. Possibles values are 0, 1, 2 and 3. Each incre
 .BI "\-s, \-\-serial " number
 The device serial number. Mandatory only if several devices are connected to adb.

+.TP
+.BI "\-\-scale\-filter filter
+Supported filters are "none" and "trilinear".
+
+Trilinear filtering is only available if the renderer is OpenGL 3.0+ or OpenGL
+ES 2.0+.
+
 .TP
 .BI "\-\-shortcut\-mod " key[+...]][,...]
 Specify the modifiers to use for scrcpy shortcuts. Possible keys are "lctrl", "rctrl", "lalt", "ralt", "lsuper" and "rsuper".
--- a/app/src/command.c
+++ b/app/src/command.c
@ -1,12 +1,10 @@
-#include "command.h"
+#include "adb.h"

 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

-#include "config.h"
-#include "common.h"
 #include "util/log.h"
 #include "util/str_util.h"

@ -70,7 +68,7 @@ show_adb_installation_msg() {
        {"pacman", "pacman -S android-tools"},
    };
    for (size_t i = 0; i < ARRAY_LEN(pkg_managers); ++i) {
-        if (cmd_search(pkg_managers[i].binary)) {
+        if (search_executable(pkg_managers[i].binary)) {
            LOGI("You may install 'adb' by \"%s\"", pkg_managers[i].command);
            return;
        }
@ -118,7 +116,7 @@ adb_execute(const char *serial, const char *const adb_cmd[], size_t len) {

    memcpy(&cmd[i], adb_cmd, len * sizeof(const char *));
    cmd[len + i] = NULL;
-    enum process_result r = cmd_execute(cmd, &process);
+    enum process_result r = process_execute(cmd, &process);
    if (r != PROCESS_SUCCESS) {
        show_adb_err_msg(r, cmd);
        return PROCESS_NONE;
@ -175,7 +173,7 @@ adb_push(const char *serial, const char *local, const char *remote) {
    }
    remote = strquote(remote);
    if (!remote) {
-        SDL_free((void *) local);
+        free((void *) local);
        return PROCESS_NONE;
    }
 #endif
@ -184,8 +182,8 @@ adb_push(const char *serial, const char *local, const char *remote) {
    process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));

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

    return proc;
@ -206,26 +204,8 @@ adb_install(const char *serial, const char *local) {
    process_t proc = adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));

 #ifdef __WINDOWS__
-    SDL_free((void *) local);
+    free((void *) local);
 #endif

    return proc;
 }
-
-bool
-process_check_success(process_t proc, const char *name) {
-    if (proc == PROCESS_NONE) {
-        LOGE("Could not execute \"%s\"", name);
-        return false;
-    }
-    exit_code_t exit_code;
-    if (!cmd_simple_wait(proc, &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;
-}
--- a/app/src/adb.h
+++ b/app/src/adb.h
@ -0,0 +1,34 @@
+#ifndef SC_ADB_H
+#define SC_ADB_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <inttypes.h>
+
+#include "util/process.h"
+
+process_t
+adb_execute(const char *serial, const char *const adb_cmd[], size_t len);
+
+process_t
+adb_forward(const char *serial, uint16_t local_port,
+            const char *device_socket_name);
+
+process_t
+adb_forward_remove(const char *serial, uint16_t local_port);
+
+process_t
+adb_reverse(const char *serial, const char *device_socket_name,
+            uint16_t local_port);
+
+process_t
+adb_reverse_remove(const char *serial, const char *device_socket_name);
+
+process_t
+adb_push(const char *serial, const char *local, const char *remote);
+
+process_t
+adb_install(const char *serial, const char *local);
+
+#endif
--- a/app/src/cli.c
+++ b/app/src/cli.c
@ -6,7 +6,6 @@
 #include <stdio.h>
 #include <unistd.h>

-#include "config.h"
 #include "scrcpy.h"
 #include "util/log.h"
 #include "util/str_util.h"
@ -104,11 +103,6 @@ scrcpy_print_usage(const char *arg0) {
        "    --no-key-repeat\n"
        "        Do not forward repeated key events when a key is held down.\n"
        "\n"
-        "    --no-mipmaps\n"
-        "        If the renderer is OpenGL 3.0+ or OpenGL ES 2.0+, then\n"
-        "        mipmaps are automatically generated to improve downscaling\n"
-        "        quality. This option disables the generation of mipmaps.\n"
-        "\n"
        "    -p, --port port[:port]\n"
        "        Set the TCP port (range) used by the client to listen.\n"
        "        Default is %d:%d.\n"
@ -155,6 +149,11 @@ scrcpy_print_usage(const char *arg0) {
        "        The device serial number. Mandatory only if several devices\n"
        "        are connected to adb.\n"
        "\n"
+        "    --scale-filter filter\n"
+        "        Supported filters are \"none\" and \"trilinear\".\n"
+        "        Trilinear filtering is only available if the renderer is\n"
+        "        OpenGL 3.0+ or OpenGL ES 2.0+.\n"
+        "\n"
        "    --shortcut-mod key[+...]][,...]\n"
        "        Specify the modifiers to use for scrcpy shortcuts.\n"
        "        Possible keys are \"lctrl\", \"rctrl\", \"lalt\", \"ralt\",\n"
@ -478,14 +477,14 @@ parse_port_range(const char *s, struct sc_port_range *port_range) {
 }

 static bool
-parse_display_id(const char *s, uint16_t *display_id) {
+parse_display_id(const char *s, uint32_t *display_id) {
    long value;
-    bool ok = parse_integer_arg(s, &value, false, 0, 0xFFFF, "display id");
+    bool ok = parse_integer_arg(s, &value, false, 0, 0x7FFFFFFF, "display id");
    if (!ok) {
        return false;
    }

-    *display_id = (uint16_t) value;
+    *display_id = (uint32_t) value;
    return true;
 }

@ -642,6 +641,62 @@ guess_record_format(const char *filename) {
    return 0;
 }

+static bool
+parse_scale_filter(const char *optarg, enum sc_scale_filter *filter) {
+    // TODO store in a map and loop over the entries instead
+    if (!strcmp(optarg, "none")) {
+        *filter = SC_SCALE_FILTER_NONE;
+        return true;
+    }
+    if (!strcmp(optarg, "trilinear")) {
+        *filter = SC_SCALE_FILTER_TRILINEAR;
+        return true;
+    }
+    if (!strcmp(optarg, "bilinear")) {
+        *filter = SC_SCALE_FILTER_BILINEAR;
+        return true;
+    }
+    if (!strcmp(optarg, "bicubic")) {
+        *filter = SC_SCALE_FILTER_BICUBIC;
+        return true;
+    }
+    if (!strcmp(optarg, "x")) {
+        *filter = SC_SCALE_FILTER_X;
+        return true;
+    }
+    if (!strcmp(optarg, "point")) {
+        *filter = SC_SCALE_FILTER_POINT;
+        return true;
+    }
+    if (!strcmp(optarg, "area")) {
+        *filter = SC_SCALE_FILTER_AREA;
+        return true;
+    }
+    if (!strcmp(optarg, "bicublin")) {
+        *filter = SC_SCALE_FILTER_BICUBLIN;
+        return true;
+    }
+    if (!strcmp(optarg, "gauss")) {
+        *filter = SC_SCALE_FILTER_GAUSS;
+        return true;
+    }
+    if (!strcmp(optarg, "sinc")) {
+        *filter = SC_SCALE_FILTER_SINC;
+        return true;
+    }
+    if (!strcmp(optarg, "lanczos")) {
+        *filter = SC_SCALE_FILTER_LANCZOS;
+        return true;
+    }
+    if (!strcmp(optarg, "spline")) {
+        *filter = SC_SCALE_FILTER_SPLINE;
+        return true;
+    }
+    LOGE("Unsupported scale filter: %s "
+         "(expected one of [TODO])", optarg);
+    return false;
+}
+
 #define OPT_RENDER_EXPIRED_FRAMES  1000
 #define OPT_WINDOW_TITLE           1001
 #define OPT_PUSH_TARGET            1002
@ -668,6 +723,7 @@ guess_record_format(const char *filename) {
 #define OPT_FORWARD_ALL_CLICKS     1023
 #define OPT_LEGACY_PASTE           1024
 #define OPT_ENCODER_NAME           1025
+#define OPT_SCALE_FILTER           1026

 bool
 scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
@ -704,6 +760,7 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
        {"render-expired-frames",  no_argument,       NULL,
                                                  OPT_RENDER_EXPIRED_FRAMES},
        {"rotation",               required_argument, NULL, OPT_ROTATION},
+        {"scale-filter",           required_argument, NULL, OPT_SCALE_FILTER},
        {"serial",                 required_argument, NULL, 's'},
        {"shortcut-mod",           required_argument, NULL, OPT_SHORTCUT_MOD},
        {"show-touches",           no_argument,       NULL, 't'},
@ -858,7 +915,9 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
                opts->render_driver = optarg;
                break;
            case OPT_NO_MIPMAPS:
-                opts->mipmaps = false;
+                LOGW("Deprecated option --no-mipmaps. "
+                     "Use --scale-filter=none instead.");
+                opts->scale_filter = SC_SCALE_FILTER_NONE;
                break;
            case OPT_NO_KEY_REPEAT:
                opts->forward_key_repeat = false;
@ -886,6 +945,11 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
            case OPT_LEGACY_PASTE:
                opts->legacy_paste = true;
                break;
+            case OPT_SCALE_FILTER:
+                if (!parse_scale_filter(optarg, &opts->scale_filter)) {
+                    return false;
+                }
+                break;
            default:
                // getopt prints the error message on stderr
                return false;
--- a/app/src/cli.h
+++ b/app/src/cli.h
@ -1,9 +1,10 @@
 #ifndef SCRCPY_CLI_H
 #define SCRCPY_CLI_H

+#include "common.h"
+
 #include <stdbool.h>

-#include "config.h"
 #include "scrcpy.h"

 struct scrcpy_cli_args {
--- a/app/src/common.h
+++ b/app/src/common.h
@ -1,35 +1,11 @@
 #ifndef COMMON_H
 #define COMMON_H

-#include <stdint.h>
-
 #include "config.h"
+#include "compat.h"

 #define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0]))
 #define MIN(X,Y) (X) < (Y) ? (X) : (Y)
 #define MAX(X,Y) (X) > (Y) ? (X) : (Y)

-struct size {
-    uint16_t width;
-    uint16_t height;
-};
-
-struct point {
-    int32_t x;
-    int32_t y;
-};
-
-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 size screen_size;
-    struct point point;
-};
-
-struct port_range {
-    uint16_t first;
-    uint16_t last;
-};
-
 #endif
--- a/app/src/compat.c
+++ b/app/src/compat.c
@ -0,0 +1,14 @@
+#include "compat.h"
+
+#include "config.h"
+
+#ifndef HAVE_STRDUP
+char *strdup(const char *s) {
+    size_t size = strlen(s) + 1;
+    char *dup = malloc(size);
+    if (dup) {
+        memcpy(dup, s, size);
+    }
+    return dup;
+}
+#endif
--- a/app/src/compat.h
+++ b/app/src/compat.h
@ -1,6 +1,14 @@
 #ifndef COMPAT_H
 #define COMPAT_H

+#define _POSIX_C_SOURCE 200809L
+#define _XOPEN_SOURCE 700
+#define _GNU_SOURCE
+#ifdef __APPLE__
+# define _DARWIN_C_SOURCE
+#endif
+
+#include <libavcodec/version.h>
 #include <libavformat/version.h>
 #include <SDL2/SDL_version.h>

@ -48,4 +56,8 @@
 # define SCRCPY_SDL_HAS_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR
 #endif

+#ifdef HAVE_STRDUP
+char *strdup(const char *s);
+#endif
+
 #endif
--- a/app/src/control_msg.c
+++ b/app/src/control_msg.c
@ -1,9 +1,9 @@
 #include "control_msg.h"

 #include <assert.h>
+#include <stdlib.h>
 #include <string.h>

-#include "config.h"
 #include "util/buffer_util.h"
 #include "util/log.h"
 #include "util/str_util.h"
@ -94,10 +94,10 @@ void
 control_msg_destroy(struct control_msg *msg) {
    switch (msg->type) {
        case CONTROL_MSG_TYPE_INJECT_TEXT:
-            SDL_free(msg->inject_text.text);
+            free(msg->inject_text.text);
            break;
        case CONTROL_MSG_TYPE_SET_CLIPBOARD:
-            SDL_free(msg->set_clipboard.text);
+            free(msg->set_clipboard.text);
            break;
        default:
            // do nothing
--- a/app/src/control_msg.h
+++ b/app/src/control_msg.h
@ -1,14 +1,15 @@
 #ifndef CONTROLMSG_H
 #define CONTROLMSG_H

+#include "common.h"
+
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>

-#include "config.h"
 #include "android/input.h"
 #include "android/keycodes.h"
-#include "common.h"
+#include "coords.h"

 #define CONTROL_MSG_MAX_SIZE (1 << 18) // 256k

@ -49,7 +50,7 @@ struct control_msg {
            enum android_metastate metastate;
        } inject_keycode;
        struct {
-            char *text; // owned, to be freed by SDL_free()
+            char *text; // owned, to be freed by free()
        } inject_text;
        struct {
            enum android_motionevent_action action;
@ -64,7 +65,7 @@ struct control_msg {
            int32_t vscroll;
        } inject_scroll_event;
        struct {
-            char *text; // owned, to be freed by SDL_free()
+            char *text; // owned, to be freed by free()
            bool paste;
        } set_clipboard;
        struct {
--- a/app/src/controller.c
+++ b/app/src/controller.c
@ -2,26 +2,27 @@

 #include <assert.h>

-#include "config.h"
-#include "util/lock.h"
 #include "util/log.h"

 bool
 controller_init(struct controller *controller, socket_t control_socket) {
    cbuf_init(&controller->queue);

-    if (!receiver_init(&controller->receiver, control_socket)) {
+    bool ok = receiver_init(&controller->receiver, control_socket);
+    if (!ok) {
        return false;
    }

-    if (!(controller->mutex = SDL_CreateMutex())) {
+    ok = sc_mutex_init(&controller->mutex);
+    if (!ok) {
        receiver_destroy(&controller->receiver);
        return false;
    }

-    if (!(controller->msg_cond = SDL_CreateCond())) {
+    ok = sc_cond_init(&controller->msg_cond);
+    if (!ok) {
        receiver_destroy(&controller->receiver);
-        SDL_DestroyMutex(controller->mutex);
+        sc_mutex_destroy(&controller->mutex);
        return false;
    }

@ -33,8 +34,8 @@ controller_init(struct controller *controller, socket_t control_socket) {

 void
 controller_destroy(struct controller *controller) {
-    SDL_DestroyCond(controller->msg_cond);
-    SDL_DestroyMutex(controller->mutex);
+    sc_cond_destroy(&controller->msg_cond);
+    sc_mutex_destroy(&controller->mutex);

    struct control_msg msg;
    while (cbuf_take(&controller->queue, &msg)) {
@ -47,13 +48,13 @@ controller_destroy(struct controller *controller) {
 bool
 controller_push_msg(struct controller *controller,
                      const struct control_msg *msg) {
-    mutex_lock(controller->mutex);
+    sc_mutex_lock(&controller->mutex);
    bool was_empty = cbuf_is_empty(&controller->queue);
    bool res = cbuf_push(&controller->queue, *msg);
    if (was_empty) {
-        cond_signal(controller->msg_cond);
+        sc_cond_signal(&controller->msg_cond);
    }
-    mutex_unlock(controller->mutex);
+    sc_mutex_unlock(&controller->mutex);
    return res;
 }

@ -61,12 +62,12 @@ static bool
 process_msg(struct controller *controller,
              const struct control_msg *msg) {
    static unsigned char serialized_msg[CONTROL_MSG_MAX_SIZE];
-    int length = control_msg_serialize(msg, serialized_msg);
+    size_t length = control_msg_serialize(msg, serialized_msg);
    if (!length) {
        return false;
    }
    int w = net_send_all(controller->control_socket, serialized_msg, length);
-    return w == length;
+    return (size_t) w == length;
 }

 static int
@ -74,20 +75,20 @@ run_controller(void *data) {
    struct controller *controller = data;

    for (;;) {
-        mutex_lock(controller->mutex);
+        sc_mutex_lock(&controller->mutex);
        while (!controller->stopped && cbuf_is_empty(&controller->queue)) {
-            cond_wait(controller->msg_cond, controller->mutex);
+            sc_cond_wait(&controller->msg_cond, &controller->mutex);
        }
        if (controller->stopped) {
            // stop immediately, do not process further msgs
-            mutex_unlock(controller->mutex);
+            sc_mutex_unlock(&controller->mutex);
            break;
        }
        struct control_msg msg;
        bool non_empty = cbuf_take(&controller->queue, &msg);
        assert(non_empty);
        (void) non_empty;
-        mutex_unlock(controller->mutex);
+        sc_mutex_unlock(&controller->mutex);

        bool ok = process_msg(controller, &msg);
        control_msg_destroy(&msg);
@ -103,16 +104,16 @@ bool
 controller_start(struct controller *controller) {
    LOGD("Starting controller thread");

-    controller->thread = SDL_CreateThread(run_controller, "controller",
-                                          controller);
-    if (!controller->thread) {
+    bool ok = sc_thread_create(&controller->thread, run_controller,
+                               "controller", controller);
+    if (!ok) {
        LOGC("Could not start controller thread");
        return false;
    }

    if (!receiver_start(&controller->receiver)) {
        controller_stop(controller);
-        SDL_WaitThread(controller->thread, NULL);
+        sc_thread_join(&controller->thread, NULL);
        return false;
    }

@ -121,14 +122,14 @@ controller_start(struct controller *controller) {

 void
 controller_stop(struct controller *controller) {
-    mutex_lock(controller->mutex);
+    sc_mutex_lock(&controller->mutex);
    controller->stopped = true;
-    cond_signal(controller->msg_cond);
-    mutex_unlock(controller->mutex);
+    sc_cond_signal(&controller->msg_cond);
+    sc_mutex_unlock(&controller->mutex);
 }

 void
 controller_join(struct controller *controller) {
-    SDL_WaitThread(controller->thread, NULL);
+    sc_thread_join(&controller->thread, NULL);
    receiver_join(&controller->receiver);
 }
--- a/app/src/controller.h
+++ b/app/src/controller.h
@ -1,23 +1,23 @@
 #ifndef CONTROLLER_H
 #define CONTROLLER_H

-#include <stdbool.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>
+#include "common.h"
+
+#include <stdbool.h>

-#include "config.h"
 #include "control_msg.h"
 #include "receiver.h"
 #include "util/cbuf.h"
 #include "util/net.h"
+#include "util/thread.h"

 struct control_msg_queue CBUF(struct control_msg, 64);

 struct controller {
    socket_t control_socket;
-    SDL_Thread *thread;
-    SDL_mutex *mutex;
-    SDL_cond *msg_cond;
+    sc_thread thread;
+    sc_mutex mutex;
+    sc_cond msg_cond;
    bool stopped;
    struct control_msg_queue queue;
    struct receiver receiver;
--- a/app/src/coords.h
+++ b/app/src/coords.h
@ -0,0 +1,24 @@
+#ifndef SC_COORDS
+#define SC_COORDS
+
+#include <stdint.h>
+
+struct size {
+    uint16_t width;
+    uint16_t height;
+};
+
+struct point {
+    int32_t x;
+    int32_t y;
+};
+
+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 size screen_size;
+    struct point point;
+};
+
+#endif
--- a/app/src/decoder.c
+++ b/app/src/decoder.c
@ -3,12 +3,8 @@
 #include <libavformat/avformat.h>
 #include <libavutil/time.h>
 #include <SDL2/SDL_events.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>
 #include <unistd.h>

-#include "config.h"
-#include "compat.h"
 #include "events.h"
 #include "recorder.h"
 #include "video_buffer.h"
--- a/app/src/decoder.h
+++ b/app/src/decoder.h
@ -1,11 +1,11 @@
 #ifndef DECODER_H
 #define DECODER_H

+#include "common.h"
+
 #include <stdbool.h>
 #include <libavformat/avformat.h>

-#include "config.h"
-
 struct video_buffer;

 struct decoder {
--- a/app/src/device.c
+++ b/app/src/device.c
@ -1,6 +1,5 @@
 #include "device.h"

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

 bool
--- a/app/src/device.h
+++ b/app/src/device.h
@ -1,10 +1,11 @@
 #ifndef DEVICE_H
 #define DEVICE_H

+#include "common.h"
+
 #include <stdbool.h>

-#include "config.h"
-#include "common.h"
+#include "coords.h"
 #include "util/net.h"

 #define DEVICE_NAME_FIELD_LENGTH 64
--- a/app/src/device_msg.c
+++ b/app/src/device_msg.c
@ -1,8 +1,8 @@
 #include "device_msg.h"

+#include <stdlib.h>
 #include <string.h>

-#include "config.h"
 #include "util/buffer_util.h"
 #include "util/log.h"

@ -21,7 +21,7 @@ device_msg_deserialize(const unsigned char *buf, size_t len,
            if (clipboard_len > len - 5) {
                return 0; // not available
            }
-            char *text = SDL_malloc(clipboard_len + 1);
+            char *text = malloc(clipboard_len + 1);
            if (!text) {
                LOGW("Could not allocate text for clipboard");
                return -1;
@ -43,6 +43,6 @@ device_msg_deserialize(const unsigned char *buf, size_t len,
 void
 device_msg_destroy(struct device_msg *msg) {
    if (msg->type == DEVICE_MSG_TYPE_CLIPBOARD) {
-        SDL_free(msg->clipboard.text);
+        free(msg->clipboard.text);
    }
 }
--- a/app/src/device_msg.h
+++ b/app/src/device_msg.h
@ -1,12 +1,12 @@
 #ifndef DEVICEMSG_H
 #define DEVICEMSG_H

+#include "common.h"
+
 #include <stdbool.h>
 #include <stdint.h>
 #include <unistd.h>

-#include "config.h"
-
 #define DEVICE_MSG_MAX_SIZE (1 << 18) // 256k
 // type: 1 byte; length: 4 bytes
 #define DEVICE_MSG_TEXT_MAX_LENGTH (DEVICE_MSG_MAX_SIZE - 5)
@ -19,7 +19,7 @@ struct device_msg {
    enum device_msg_type type;
    union {
        struct {
-            char *text; // owned, to be freed by SDL_free()
+            char *text; // owned, to be freed by free()
        } clipboard;
    };
 };
--- a/app/src/event_converter.c
+++ b/app/src/event_converter.c
@ -1,7 +1,5 @@
 #include "event_converter.h"

-#include "config.h"
-
 #define MAP(FROM, TO) case FROM: *to = TO; return true
 #define FAIL default: return false

--- a/app/src/event_converter.h
+++ b/app/src/event_converter.h
@ -1,10 +1,11 @@
 #ifndef CONVERT_H
 #define CONVERT_H

+#include "common.h"
+
 #include <stdbool.h>
 #include <SDL2/SDL_events.h>

-#include "config.h"
 #include "control_msg.h"

 bool
--- a/app/src/file_handler.c
+++ b/app/src/file_handler.c
@ -3,16 +3,14 @@
 #include <assert.h>
 #include <string.h>

-#include "config.h"
-#include "command.h"
-#include "util/lock.h"
+#include "adb.h"
 #include "util/log.h"

 #define DEFAULT_PUSH_TARGET "/sdcard/"

 static void
 file_handler_request_destroy(struct file_handler_request *req) {
-    SDL_free(req->file);
+    free(req->file);
 }

 bool
@ -21,21 +19,23 @@ file_handler_init(struct file_handler *file_handler, const char *serial,

    cbuf_init(&file_handler->queue);

-    if (!(file_handler->mutex = SDL_CreateMutex())) {
+    bool ok = sc_mutex_init(&file_handler->mutex);
+    if (!ok) {
        return false;
    }

-    if (!(file_handler->event_cond = SDL_CreateCond())) {
-        SDL_DestroyMutex(file_handler->mutex);
+    ok = sc_cond_init(&file_handler->event_cond);
+    if (!ok) {
+        sc_mutex_destroy(&file_handler->mutex);
        return false;
    }

    if (serial) {
-        file_handler->serial = SDL_strdup(serial);
+        file_handler->serial = strdup(serial);
        if (!file_handler->serial) {
            LOGW("Could not strdup serial");
-            SDL_DestroyCond(file_handler->event_cond);
-            SDL_DestroyMutex(file_handler->mutex);
+            sc_cond_destroy(&file_handler->event_cond);
+            sc_mutex_destroy(&file_handler->mutex);
            return false;
        }
    } else {
@ -55,9 +55,9 @@ file_handler_init(struct file_handler *file_handler, const char *serial,

 void
 file_handler_destroy(struct file_handler *file_handler) {
-    SDL_DestroyCond(file_handler->event_cond);
-    SDL_DestroyMutex(file_handler->mutex);
-    SDL_free(file_handler->serial);
+    sc_cond_destroy(&file_handler->event_cond);
+    sc_mutex_destroy(&file_handler->mutex);
+    free(file_handler->serial);

    struct file_handler_request req;
    while (cbuf_take(&file_handler->queue, &req)) {
@ -93,13 +93,13 @@ file_handler_request(struct file_handler *file_handler,
        .file = file,
    };

-    mutex_lock(file_handler->mutex);
+    sc_mutex_lock(&file_handler->mutex);
    bool was_empty = cbuf_is_empty(&file_handler->queue);
    bool res = cbuf_push(&file_handler->queue, req);
    if (was_empty) {
-        cond_signal(file_handler->event_cond);
+        sc_cond_signal(&file_handler->event_cond);
    }
-    mutex_unlock(file_handler->mutex);
+    sc_mutex_unlock(&file_handler->mutex);
    return res;
 }

@ -108,14 +108,14 @@ run_file_handler(void *data) {
    struct file_handler *file_handler = data;

    for (;;) {
-        mutex_lock(file_handler->mutex);
+        sc_mutex_lock(&file_handler->mutex);
        file_handler->current_process = PROCESS_NONE;
        while (!file_handler->stopped && cbuf_is_empty(&file_handler->queue)) {
-            cond_wait(file_handler->event_cond, file_handler->mutex);
+            sc_cond_wait(&file_handler->event_cond, &file_handler->mutex);
        }
        if (file_handler->stopped) {
            // stop immediately, do not process further events
-            mutex_unlock(file_handler->mutex);
+            sc_mutex_unlock(&file_handler->mutex);
            break;
        }
        struct file_handler_request req;
@ -133,16 +133,16 @@ run_file_handler(void *data) {
                                file_handler->push_target);
        }
        file_handler->current_process = process;
-        mutex_unlock(file_handler->mutex);
+        sc_mutex_unlock(&file_handler->mutex);

        if (req.action == ACTION_INSTALL_APK) {
-            if (process_check_success(process, "adb install")) {
+            if (process_check_success(process, "adb install", false)) {
                LOGI("%s successfully installed", req.file);
            } else {
                LOGE("Failed to install %s", req.file);
            }
        } else {
-            if (process_check_success(process, "adb push")) {
+            if (process_check_success(process, "adb push", false)) {
                LOGI("%s successfully pushed to %s", req.file,
                                                     file_handler->push_target);
            } else {
@ -151,6 +151,14 @@ run_file_handler(void *data) {
            }
        }

+        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;
@ -160,9 +168,9 @@ bool
 file_handler_start(struct file_handler *file_handler) {
    LOGD("Starting file_handler thread");

-    file_handler->thread = SDL_CreateThread(run_file_handler, "file_handler",
-                                            file_handler);
-    if (!file_handler->thread) {
+    bool ok = sc_thread_create(&file_handler->thread, run_file_handler,
+                               "file_handler", file_handler);
+    if (!ok) {
        LOGC("Could not start file_handler thread");
        return false;
    }
@ -172,20 +180,18 @@ file_handler_start(struct file_handler *file_handler) {

 void
 file_handler_stop(struct file_handler *file_handler) {
-    mutex_lock(file_handler->mutex);
+    sc_mutex_lock(&file_handler->mutex);
    file_handler->stopped = true;
-    cond_signal(file_handler->event_cond);
+    sc_cond_signal(&file_handler->event_cond);
    if (file_handler->current_process != PROCESS_NONE) {
-        if (!cmd_terminate(file_handler->current_process)) {
-            LOGW("Could not terminate install process");
+        if (!process_terminate(file_handler->current_process)) {
+            LOGW("Could not terminate push/install process");
        }
-        cmd_simple_wait(file_handler->current_process, NULL);
-        file_handler->current_process = PROCESS_NONE;
    }
-    mutex_unlock(file_handler->mutex);
+    sc_mutex_unlock(&file_handler->mutex);
 }

 void
 file_handler_join(struct file_handler *file_handler) {
-    SDL_WaitThread(file_handler->thread, NULL);
+    sc_thread_join(&file_handler->thread, NULL);
 }
--- a/app/src/file_handler.h
+++ b/app/src/file_handler.h
@ -1,13 +1,13 @@
 #ifndef FILE_HANDLER_H
 #define FILE_HANDLER_H

-#include <stdbool.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>
+#include "common.h"

-#include "config.h"
-#include "command.h"
+#include <stdbool.h>
+
+#include "adb.h"
 #include "util/cbuf.h"
+#include "util/thread.h"

 typedef enum {
    ACTION_INSTALL_APK,
@ -24,9 +24,9 @@ struct file_handler_request_queue CBUF(struct file_handler_request, 16);
 struct file_handler {
    char *serial;
    const char *push_target;
-    SDL_Thread *thread;
-    SDL_mutex *mutex;
-    SDL_cond *event_cond;
+    sc_thread thread;
+    sc_mutex mutex;
+    sc_cond event_cond;
    bool stopped;
    bool initialized;
    process_t current_process;
@ -49,7 +49,7 @@ file_handler_stop(struct file_handler *file_handler);
 void
 file_handler_join(struct file_handler *file_handler);

-// take ownership of file, and will SDL_free() it
+// take ownership of file, and will free() it
 bool
 file_handler_request(struct file_handler *file_handler,
                     file_handler_action_t action,
--- a/app/src/fps_counter.c
+++ b/app/src/fps_counter.c
@ -3,26 +3,24 @@
 #include <assert.h>
 #include <SDL2/SDL_timer.h>

-#include "config.h"
-#include "util/lock.h"
 #include "util/log.h"

 #define FPS_COUNTER_INTERVAL_MS 1000

 bool
 fps_counter_init(struct fps_counter *counter) {
-    counter->mutex = SDL_CreateMutex();
-    if (!counter->mutex) {
+    bool ok = sc_mutex_init(&counter->mutex);
+    if (!ok) {
        return false;
    }

-    counter->state_cond = SDL_CreateCond();
-    if (!counter->state_cond) {
-        SDL_DestroyMutex(counter->mutex);
+    ok = sc_cond_init(&counter->state_cond);
+    if (!ok) {
+        sc_mutex_destroy(&counter->mutex);
        return false;
    }

-    counter->thread = NULL;
+    counter->thread_started = false;
    atomic_init(&counter->started, 0);
    // no need to initialize the other fields, they are unused until started

@ -31,8 +29,8 @@ fps_counter_init(struct fps_counter *counter) {

 void
 fps_counter_destroy(struct fps_counter *counter) {
-    SDL_DestroyCond(counter->state_cond);
-    SDL_DestroyMutex(counter->mutex);
+    sc_cond_destroy(&counter->state_cond);
+    sc_mutex_destroy(&counter->mutex);
 }

 static inline bool
@ -78,10 +76,10 @@ static int
 run_fps_counter(void *data) {
    struct fps_counter *counter = data;

-    mutex_lock(counter->mutex);
+    sc_mutex_lock(&counter->mutex);
    while (!counter->interrupted) {
        while (!counter->interrupted && !is_started(counter)) {
-            cond_wait(counter->state_cond, counter->mutex);
+            sc_cond_wait(&counter->state_cond, &counter->mutex);
        }
        while (!counter->interrupted && is_started(counter)) {
            uint32_t now = SDL_GetTicks();
@ -91,32 +89,35 @@ run_fps_counter(void *data) {
            uint32_t remaining = counter->next_timestamp - now;

            // ignore the reason (timeout or signaled), we just loop anyway
-            cond_wait_timeout(counter->state_cond, counter->mutex, remaining);
+            sc_cond_timedwait(&counter->state_cond, &counter->mutex, remaining);
        }
    }
-    mutex_unlock(counter->mutex);
+    sc_mutex_unlock(&counter->mutex);
    return 0;
 }

 bool
 fps_counter_start(struct fps_counter *counter) {
-    mutex_lock(counter->mutex);
+    sc_mutex_lock(&counter->mutex);
    counter->next_timestamp = SDL_GetTicks() + FPS_COUNTER_INTERVAL_MS;
    counter->nr_rendered = 0;
    counter->nr_skipped = 0;
-    mutex_unlock(counter->mutex);
+    sc_mutex_unlock(&counter->mutex);

    set_started(counter, true);
-    cond_signal(counter->state_cond);
+    sc_cond_signal(&counter->state_cond);

-    // counter->thread is always accessed from the same thread, no need to lock
-    if (!counter->thread) {
-        counter->thread =
-            SDL_CreateThread(run_fps_counter, "fps counter", counter);
-        if (!counter->thread) {
+    // counter->thread_started and counter->thread are always accessed from the
+    // same thread, no need to lock
+    if (!counter->thread_started) {
+        bool ok = sc_thread_create(&counter->thread, run_fps_counter,
+                                   "fps counter", counter);
+        if (!ok) {
            LOGE("Could not start FPS counter thread");
            return false;
        }
+
+        counter->thread_started = true;
    }

    return true;
@ -125,7 +126,7 @@ fps_counter_start(struct fps_counter *counter) {
 void
 fps_counter_stop(struct fps_counter *counter) {
    set_started(counter, false);
-    cond_signal(counter->state_cond);
+    sc_cond_signal(&counter->state_cond);
 }

 bool
@ -135,21 +136,21 @@ fps_counter_is_started(struct fps_counter *counter) {

 void
 fps_counter_interrupt(struct fps_counter *counter) {
-    if (!counter->thread) {
+    if (!counter->thread_started) {
        return;
    }

-    mutex_lock(counter->mutex);
+    sc_mutex_lock(&counter->mutex);
    counter->interrupted = true;
-    mutex_unlock(counter->mutex);
+    sc_mutex_unlock(&counter->mutex);
    // wake up blocking wait
-    cond_signal(counter->state_cond);
+    sc_cond_signal(&counter->state_cond);
 }

 void
 fps_counter_join(struct fps_counter *counter) {
-    if (counter->thread) {
-        SDL_WaitThread(counter->thread, NULL);
+    if (counter->thread_started) {
+        sc_thread_join(&counter->thread, NULL);
    }
 }

@ -159,11 +160,11 @@ fps_counter_add_rendered_frame(struct fps_counter *counter) {
        return;
    }

-    mutex_lock(counter->mutex);
+    sc_mutex_lock(&counter->mutex);
    uint32_t now = SDL_GetTicks();
    check_interval_expired(counter, now);
    ++counter->nr_rendered;
-    mutex_unlock(counter->mutex);
+    sc_mutex_unlock(&counter->mutex);
 }

 void
@ -172,9 +173,9 @@ fps_counter_add_skipped_frame(struct fps_counter *counter) {
        return;
    }

-    mutex_lock(counter->mutex);
+    sc_mutex_lock(&counter->mutex);
    uint32_t now = SDL_GetTicks();
    check_interval_expired(counter, now);
    ++counter->nr_skipped;
-    mutex_unlock(counter->mutex);
+    sc_mutex_unlock(&counter->mutex);
 }
--- a/app/src/fps_counter.h
+++ b/app/src/fps_counter.h
@ -1,18 +1,20 @@
 #ifndef FPSCOUNTER_H
 #define FPSCOUNTER_H

+#include "common.h"
+
 #include <stdatomic.h>
 #include <stdbool.h>
 #include <stdint.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>

-#include "config.h"
+#include "util/thread.h"

 struct fps_counter {
-    SDL_Thread *thread;
-    SDL_mutex *mutex;
-    SDL_cond *state_cond;
+    sc_thread thread;
+    sc_mutex mutex;
+    sc_cond state_cond;
+
+    bool thread_started;

    // atomic so that we can check without locking the mutex
    // if the FPS counter is disabled, we don't want to lock unnecessarily
--- a/app/src/frame_texture.c
+++ b/app/src/frame_texture.c
@ -0,0 +1,247 @@
+#include "frame_texture.h"
+
+#include <assert.h>
+#include <libavutil/imgutils.h>
+#include <libswscale/swscale.h>
+
+#include "util/log.h"
+
+static inline bool
+is_swscale_enabled(enum sc_scale_filter scale_filter) {
+    return scale_filter != SC_SCALE_FILTER_NONE
+        && scale_filter != SC_SCALE_FILTER_TRILINEAR;
+}
+
+static SDL_Texture *
+create_texture(struct sc_frame_texture *ftex, struct size size) {
+    SDL_Renderer *renderer = ftex->renderer;
+    SDL_PixelFormatEnum fmt = is_swscale_enabled(ftex->scale_filter)
+                            ? SDL_PIXELFORMAT_RGB24
+                            : SDL_PIXELFORMAT_YV12;
+    SDL_Texture *texture = SDL_CreateTexture(renderer, fmt,
+                                             SDL_TEXTUREACCESS_STREAMING,
+                                             size.width, size.height);
+    if (!texture) {
+        return NULL;
+    }
+
+    if (ftex->scale_filter == SC_SCALE_FILTER_TRILINEAR) {
+        struct sc_opengl *gl = &ftex->gl;
+
+        SDL_GL_BindTexture(texture, NULL, NULL);
+
+        // Enable trilinear filtering for downscaling
+        gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                          GL_LINEAR_MIPMAP_LINEAR);
+        gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -1.f);
+
+        SDL_GL_UnbindTexture(texture);
+    }
+
+    return texture;
+}
+
+bool
+sc_frame_texture_init(struct sc_frame_texture *ftex, SDL_Renderer *renderer,
+                      enum sc_scale_filter scale_filter,
+                      struct size initial_size) {
+    SDL_RendererInfo renderer_info;
+    int r = SDL_GetRendererInfo(renderer, &renderer_info);
+    const char *renderer_name = r ? NULL : renderer_info.name;
+    LOGI("Renderer: %s", renderer_name ? renderer_name : "(unknown)");
+
+    ftex->scale_filter = scale_filter;
+
+    // starts with "opengl"
+    bool use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
+    if (use_opengl) {
+        struct sc_opengl *gl = &ftex->gl;
+        sc_opengl_init(gl);
+
+        LOGI("OpenGL version: %s", gl->version);
+
+        if (scale_filter == SC_SCALE_FILTER_TRILINEAR) {
+            bool supports_mipmaps =
+                sc_opengl_version_at_least(gl, 3, 0, /* OpenGL 3.0+ */
+                                               2, 0  /* OpenGL ES 2.0+ */);
+            if (!supports_mipmaps) {
+                LOGW("Trilinear filtering disabled "
+                     "(OpenGL 3.0+ or ES 2.0+ required)");
+                ftex->scale_filter = SC_SCALE_FILTER_NONE;
+            }
+        }
+    } else if (scale_filter == SC_SCALE_FILTER_TRILINEAR) {
+        LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
+    }
+
+    LOGD("Scale filter: %s\n", sc_scale_filter_name(ftex->scale_filter));
+
+    LOGI("Initial texture: %" PRIu16 "x%" PRIu16, initial_size.width,
+                                                  initial_size.height);
+    ftex->renderer = renderer;
+    ftex->texture = create_texture(ftex, initial_size);
+    if (!ftex->texture) {
+        LOGC("Could not create texture: %s", SDL_GetError());
+        SDL_DestroyRenderer(ftex->renderer);
+        return false;
+    }
+
+    ftex->texture_size = initial_size;
+    ftex->decoded_frame = NULL;
+    memset(ftex->data, 0, sizeof(ftex->data));
+    memset(ftex->linesize, 0, sizeof(ftex->linesize));
+
+    return true;
+}
+
+void
+sc_frame_texture_destroy(struct sc_frame_texture *ftex) {
+    if (ftex->texture) {
+        SDL_DestroyTexture(ftex->texture);
+    }
+}
+
+static int
+to_sws_filter(enum sc_scale_filter scale_filter) {
+    switch (scale_filter) {
+        case SC_SCALE_FILTER_BILINEAR:  return SWS_BILINEAR;
+        case SC_SCALE_FILTER_BICUBIC:   return SWS_BICUBIC;
+        case SC_SCALE_FILTER_X:         return SWS_X;
+        case SC_SCALE_FILTER_POINT:     return SWS_POINT;
+        case SC_SCALE_FILTER_AREA:      return SWS_AREA;
+        case SC_SCALE_FILTER_BICUBLIN:  return SWS_BICUBLIN;
+        case SC_SCALE_FILTER_GAUSS:     return SWS_GAUSS;
+        case SC_SCALE_FILTER_SINC:      return SWS_SINC;
+        case SC_SCALE_FILTER_LANCZOS:   return SWS_LANCZOS;
+        case SC_SCALE_FILTER_SPLINE:    return SWS_SPLINE;
+        default: assert(!"unsupported filter");
+    }
+}
+
+static bool
+screen_generate_resized_frame(struct sc_frame_texture *ftex,
+                              struct size target_size) {
+    assert(is_swscale_enabled(ftex->scale_filter));
+    // TODO
+
+    if (ftex->data[0]) {
+        av_freep(&ftex->data[0]);
+    }
+
+    int ret = av_image_alloc(ftex->data, ftex->linesize, target_size.width,
+                             target_size.height, AV_PIX_FMT_RGB24, 16);
+    if (ret < 0) {
+        return false;
+    }
+
+    const AVFrame *input = ftex->decoded_frame;
+    assert(input);
+
+    int flags = to_sws_filter(ftex->scale_filter);
+    struct SwsContext *ctx =
+        sws_getContext(input->width, input->height, AV_PIX_FMT_YUV420P,
+                       target_size.width, target_size.height, AV_PIX_FMT_RGB24,
+                       flags, NULL, NULL, NULL);
+    if (!ctx) {
+        return false;
+    }
+
+    sws_scale(ctx, (const uint8_t *const *) input->data, input->linesize, 0,
+              input->height, ftex->data, ftex->linesize);
+    sws_freeContext(ctx);
+
+    return true;
+}
+
+static bool
+sc_frame_texture_update_direct(struct sc_frame_texture *ftex,
+                               const AVFrame *frame) {
+    struct size frame_size = {frame->width, frame->height};
+    if (ftex->texture_size.width != frame_size.width
+            || ftex->texture_size.height != frame_size.height) {
+        // Frame dimensions changed, destroy texture
+        SDL_DestroyTexture(ftex->texture);
+
+        LOGI("New texture: %" PRIu16 "x%" PRIu16, frame_size.width,
+                                                  frame_size.height);
+        ftex->texture = create_texture(ftex, frame_size);
+        if (!ftex->texture) {
+            LOGC("Could not create texture: %s", SDL_GetError());
+            return false;
+        }
+
+        ftex->texture_size = frame_size;
+    }
+
+    SDL_UpdateYUVTexture(ftex->texture, NULL,
+            frame->data[0], frame->linesize[0],
+            frame->data[1], frame->linesize[1],
+            frame->data[2], frame->linesize[2]);
+
+    if (ftex->scale_filter == SC_SCALE_FILTER_TRILINEAR) {
+        SDL_GL_BindTexture(ftex->texture, NULL, NULL);
+        ftex->gl.GenerateMipmap(GL_TEXTURE_2D);
+        SDL_GL_UnbindTexture(ftex->texture);
+    }
+
+    return true;
+}
+
+static bool
+sc_frame_texture_update_swscale(struct sc_frame_texture *ftex,
+                                const AVFrame *frame, struct size target_size) {
+    if (ftex->texture_size.width != target_size.width
+            || ftex->texture_size.height != target_size.height) {
+        // Frame dimensions changed, destroy texture
+        SDL_DestroyTexture(ftex->texture);
+
+        ftex->texture = create_texture(ftex, target_size);
+        if (!ftex->texture) {
+            LOGC("Could not create texture: %s", SDL_GetError());
+            return false;
+        }
+
+        ftex->texture_size = target_size;
+    }
+
+    // The frame is valid until the next call to
+    // video_buffer_take_rendering_frame()
+    ftex->decoded_frame = frame;
+
+    bool ok = screen_generate_resized_frame(ftex, target_size);
+    if (!ok) {
+        LOGE("Failed to resize frame\n");
+        return false;
+    }
+
+    SDL_UpdateTexture(ftex->texture, NULL, ftex->data[0], ftex->linesize[0]);
+
+    if (ftex->scale_filter == SC_SCALE_FILTER_TRILINEAR) {
+        SDL_GL_BindTexture(ftex->texture, NULL, NULL);
+        ftex->gl.GenerateMipmap(GL_TEXTURE_2D);
+        SDL_GL_UnbindTexture(ftex->texture);
+    }
+
+    return true;
+}
+
+bool
+sc_frame_texture_update(struct sc_frame_texture *ftex, const AVFrame *frame,
+                        struct size target_size) {
+    if (is_swscale_enabled(ftex->scale_filter)) {
+        return sc_frame_texture_update_swscale(ftex, frame, target_size);
+    }
+    return sc_frame_texture_update_direct(ftex, frame);
+}
+
+bool
+sc_frame_texture_resize(struct sc_frame_texture *ftex,
+                        struct size target_size) {
+    if (is_swscale_enabled(ftex->scale_filter)) {
+        return sc_frame_texture_update_swscale(ftex, ftex->decoded_frame,
+                                               target_size);
+    }
+
+    // Nothing to do
+    return true;
+}
--- a/app/src/frame_texture.h
+++ b/app/src/frame_texture.h
@ -0,0 +1,44 @@
+#ifndef SC_FRAME_TEXTURE_H
+#define SC_FRAME_TEXTURE_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <SDL2/SDL.h>
+#include <libavformat/avformat.h>
+
+#include "coords.h"
+#include "opengl.h"
+#include "scrcpy.h"
+
+struct sc_frame_texture {
+    SDL_Renderer *renderer; // owned by struct screen
+
+    enum sc_scale_filter scale_filter;
+    struct sc_opengl gl;
+
+    SDL_Texture *texture;
+    struct size texture_size;
+
+    // For swscaling
+    const AVFrame *decoded_frame; // owned by the video_buffer
+    uint8_t *data[4];
+    int linesize[4];
+};
+
+bool
+sc_frame_texture_init(struct sc_frame_texture *ftex, SDL_Renderer *renderer,
+                      enum sc_scale_filter scale_filter,
+                      struct size initial_size);
+
+void
+sc_frame_texture_destroy(struct sc_frame_texture *ftex);
+
+bool
+sc_frame_texture_update(struct sc_frame_texture *ftex, const AVFrame *frame,
+                        struct size target_size);
+
+bool
+sc_frame_texture_resize(struct sc_frame_texture *ftex, struct size target_size);
+
+#endif
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
@ -3,9 +3,7 @@
 #include <assert.h>
 #include <SDL2/SDL_keycode.h>

-#include "config.h"
 #include "event_converter.h"
-#include "util/lock.h"
 #include "util/log.h"

 static const int ACTION_DOWN = 1;
@ -191,13 +189,20 @@ set_device_clipboard(struct controller *controller, bool paste) {
        return;
    }

+    char *text_dup = strdup(text);
+    SDL_free(text);
+    if (!text_dup) {
+        LOGW("Could not strdup input text");
+        return;
+    }
+
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_SET_CLIPBOARD;
-    msg.set_clipboard.text = text;
+    msg.set_clipboard.text = text_dup;
    msg.set_clipboard.paste = paste;

    if (!controller_push_msg(controller, &msg)) {
-        SDL_free(text);
+        free(text_dup);
        LOGW("Could not request 'set device clipboard'");
    }
 }
@ -243,11 +248,18 @@ clipboard_paste(struct controller *controller) {
        return;
    }

+    char *text_dup = strdup(text);
+    SDL_free(text);
+    if (!text_dup) {
+        LOGW("Could not strdup input text");
+        return;
+    }
+
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
-    msg.inject_text.text = text;
+    msg.inject_text.text = text_dup;
    if (!controller_push_msg(controller, &msg)) {
-        SDL_free(text);
+        free(text_dup);
        LOGW("Could not request 'paste clipboard'");
    }
 }
@ -292,13 +304,13 @@ input_manager_process_text_input(struct input_manager *im,

    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_INJECT_TEXT;
-    msg.inject_text.text = SDL_strdup(event->text);
+    msg.inject_text.text = strdup(event->text);
    if (!msg.inject_text.text) {
        LOGW("Could not strdup input text");
        return;
    }
    if (!controller_push_msg(im->controller, &msg)) {
-        SDL_free(msg.inject_text.text);
+        free(msg.inject_text.text);
        LOGW("Could not request 'inject text'");
    }
 }
--- a/app/src/input_manager.h
+++ b/app/src/input_manager.h
@ -1,12 +1,12 @@
 #ifndef INPUTMANAGER_H
 #define INPUTMANAGER_H

+#include "common.h"
+
 #include <stdbool.h>

 #include <SDL2/SDL.h>

-#include "config.h"
-#include "common.h"
 #include "controller.h"
 #include "fps_counter.h"
 #include "scrcpy.h"
--- a/app/src/main.c
+++ b/app/src/main.c
@ -1,5 +1,7 @@
 #include "scrcpy.h"

+#include "common.h"
+
 #include <assert.h>
 #include <stdbool.h>
 #include <unistd.h>
@ -7,9 +9,7 @@
 #define SDL_MAIN_HANDLED // avoid link error on Linux Windows Subsystem
 #include <SDL2/SDL.h>

-#include "config.h"
 #include "cli.h"
-#include "compat.h"
 #include "util/log.h"

 static void
@ -98,11 +98,5 @@ main(int argc, char *argv[]) {

    avformat_network_deinit(); // ignore failure

-#if defined (__WINDOWS__) && ! defined (WINDOWS_NOCONSOLE)
-    if (res != 0) {
-        fprintf(stderr, "Press Enter to continue...\n");
-        getchar();
-    }
-#endif
    return res;
 }
--- a/app/src/opengl.h
+++ b/app/src/opengl.h
@ -1,11 +1,11 @@
 #ifndef SC_OPENGL_H
 #define SC_OPENGL_H

+#include "common.h"
+
 #include <stdbool.h>
 #include <SDL2/SDL_opengl.h>

-#include "config.h"
-
 struct sc_opengl {
    const char *version;
    bool is_opengles;
--- a/app/src/receiver.c
+++ b/app/src/receiver.c
@ -3,14 +3,13 @@
 #include <assert.h>
 #include <SDL2/SDL_clipboard.h>

-#include "config.h"
 #include "device_msg.h"
-#include "util/lock.h"
 #include "util/log.h"

 bool
 receiver_init(struct receiver *receiver, socket_t control_socket) {
-    if (!(receiver->mutex = SDL_CreateMutex())) {
+    bool ok = sc_mutex_init(&receiver->mutex);
+    if (!ok) {
        return false;
    }
    receiver->control_socket = control_socket;
@ -19,7 +18,7 @@ receiver_init(struct receiver *receiver, socket_t control_socket) {

 void
 receiver_destroy(struct receiver *receiver) {
-    SDL_DestroyMutex(receiver->mutex);
+    sc_mutex_destroy(&receiver->mutex);
 }

 static void
@ -102,8 +101,9 @@ bool
 receiver_start(struct receiver *receiver) {
    LOGD("Starting receiver thread");

-    receiver->thread = SDL_CreateThread(run_receiver, "receiver", receiver);
-    if (!receiver->thread) {
+    bool ok = sc_thread_create(&receiver->thread, run_receiver, "receiver",
+                               receiver);
+    if (!ok) {
        LOGC("Could not start receiver thread");
        return false;
    }
@ -113,5 +113,5 @@ receiver_start(struct receiver *receiver) {

 void
 receiver_join(struct receiver *receiver) {
-    SDL_WaitThread(receiver->thread, NULL);
+    sc_thread_join(&receiver->thread, NULL);
 }
--- a/app/src/receiver.h
+++ b/app/src/receiver.h
@ -1,19 +1,19 @@
 #ifndef RECEIVER_H
 #define RECEIVER_H

-#include <stdbool.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>
+#include "common.h"
+
+#include <stdbool.h>

-#include "config.h"
 #include "util/net.h"
+#include "util/thread.h"

 // receive events from the device
 // managed by the controller
 struct receiver {
    socket_t control_socket;
-    SDL_Thread *thread;
-    SDL_mutex *mutex;
+    sc_thread thread;
+    sc_mutex mutex;
 };

 bool
--- a/app/src/recorder.c
+++ b/app/src/recorder.c
@ -3,9 +3,6 @@
 #include <assert.h>
 #include <libavutil/time.h>

-#include "config.h"
-#include "compat.h"
-#include "util/lock.h"
 #include "util/log.h"

 static const AVRational SCRCPY_TIME_BASE = {1, 1000000}; // timestamps in us
@ -29,7 +26,7 @@ find_muxer(const char *name) {

 static struct record_packet *
 record_packet_new(const AVPacket *packet) {
-    struct record_packet *rec = SDL_malloc(sizeof(*rec));
+    struct record_packet *rec = malloc(sizeof(*rec));
    if (!rec) {
        return NULL;
    }
@ -39,7 +36,7 @@ record_packet_new(const AVPacket *packet) {
    av_init_packet(&rec->packet);

    if (av_packet_ref(&rec->packet, packet)) {
-        SDL_free(rec);
+        free(rec);
        return NULL;
    }
    return rec;
@ -48,7 +45,7 @@ record_packet_new(const AVPacket *packet) {
 static void
 record_packet_delete(struct record_packet *rec) {
    av_packet_unref(&rec->packet);
-    SDL_free(rec);
+    free(rec);
 }

 static void
@ -65,24 +62,24 @@ recorder_init(struct recorder *recorder,
              const char *filename,
              enum sc_record_format format,
              struct size declared_frame_size) {
-    recorder->filename = SDL_strdup(filename);
+    recorder->filename = strdup(filename);
    if (!recorder->filename) {
        LOGE("Could not strdup filename");
        return false;
    }

-    recorder->mutex = SDL_CreateMutex();
-    if (!recorder->mutex) {
+    bool ok = sc_mutex_init(&recorder->mutex);
+    if (!ok) {
        LOGC("Could not create mutex");
-        SDL_free(recorder->filename);
+        free(recorder->filename);
        return false;
    }

-    recorder->queue_cond = SDL_CreateCond();
-    if (!recorder->queue_cond) {
+    ok = sc_cond_init(&recorder->queue_cond);
+    if (!ok) {
        LOGC("Could not create cond");
-        SDL_DestroyMutex(recorder->mutex);
-        SDL_free(recorder->filename);
+        sc_mutex_destroy(&recorder->mutex);
+        free(recorder->filename);
        return false;
    }

@ -99,9 +96,9 @@ recorder_init(struct recorder *recorder,

 void
 recorder_destroy(struct recorder *recorder) {
-    SDL_DestroyCond(recorder->queue_cond);
-    SDL_DestroyMutex(recorder->mutex);
-    SDL_free(recorder->filename);
+    sc_cond_destroy(&recorder->queue_cond);
+    sc_mutex_destroy(&recorder->mutex);
+    free(recorder->filename);
 }

 static const char *
@ -260,17 +257,17 @@ run_recorder(void *data) {
    struct recorder *recorder = data;

    for (;;) {
-        mutex_lock(recorder->mutex);
+        sc_mutex_lock(&recorder->mutex);

        while (!recorder->stopped && queue_is_empty(&recorder->queue)) {
-            cond_wait(recorder->queue_cond, recorder->mutex);
+            sc_cond_wait(&recorder->queue_cond, &recorder->mutex);
        }

        // if stopped is set, continue to process the remaining events (to
        // finish the recording) before actually stopping

        if (recorder->stopped && queue_is_empty(&recorder->queue)) {
-            mutex_unlock(recorder->mutex);
+            sc_mutex_unlock(&recorder->mutex);
            struct record_packet *last = recorder->previous;
            if (last) {
                // assign an arbitrary duration to the last packet
@ -290,7 +287,7 @@ run_recorder(void *data) {
        struct record_packet *rec;
        queue_take(&recorder->queue, next, &rec);

-        mutex_unlock(recorder->mutex);
+        sc_mutex_unlock(&recorder->mutex);

        // recorder->previous is only written from this thread, no need to lock
        struct record_packet *previous = recorder->previous;
@ -313,11 +310,11 @@ run_recorder(void *data) {
        if (!ok) {
            LOGE("Could not record packet");

-            mutex_lock(recorder->mutex);
+            sc_mutex_lock(&recorder->mutex);
            recorder->failed = true;
            // discard pending packets
            recorder_queue_clear(&recorder->queue);
-            mutex_unlock(recorder->mutex);
+            sc_mutex_unlock(&recorder->mutex);
            break;
        }

@ -332,8 +329,9 @@ bool
 recorder_start(struct recorder *recorder) {
    LOGD("Starting recorder thread");

-    recorder->thread = SDL_CreateThread(run_recorder, "recorder", recorder);
-    if (!recorder->thread) {
+    bool ok = sc_thread_create(&recorder->thread, run_recorder, "recorder",
+                               recorder);
+    if (!ok) {
        LOGC("Could not start recorder thread");
        return false;
    }
@ -343,38 +341,38 @@ recorder_start(struct recorder *recorder) {

 void
 recorder_stop(struct recorder *recorder) {
-    mutex_lock(recorder->mutex);
+    sc_mutex_lock(&recorder->mutex);
    recorder->stopped = true;
-    cond_signal(recorder->queue_cond);
-    mutex_unlock(recorder->mutex);
+    sc_cond_signal(&recorder->queue_cond);
+    sc_mutex_unlock(&recorder->mutex);
 }

 void
 recorder_join(struct recorder *recorder) {
-    SDL_WaitThread(recorder->thread, NULL);
+    sc_thread_join(&recorder->thread, NULL);
 }

 bool
 recorder_push(struct recorder *recorder, const AVPacket *packet) {
-    mutex_lock(recorder->mutex);
+    sc_mutex_lock(&recorder->mutex);
    assert(!recorder->stopped);

    if (recorder->failed) {
        // reject any new packet (this will stop the stream)
-        mutex_unlock(recorder->mutex);
+        sc_mutex_unlock(&recorder->mutex);
        return false;
    }

    struct record_packet *rec = record_packet_new(packet);
    if (!rec) {
        LOGC("Could not allocate record packet");
-        mutex_unlock(recorder->mutex);
+        sc_mutex_unlock(&recorder->mutex);
        return false;
    }

    queue_push(&recorder->queue, next, rec);
-    cond_signal(recorder->queue_cond);
+    sc_cond_signal(&recorder->queue_cond);

-    mutex_unlock(recorder->mutex);
+    sc_mutex_unlock(&recorder->mutex);
    return true;
 }
--- a/app/src/recorder.h
+++ b/app/src/recorder.h
@ -1,15 +1,15 @@
 #ifndef RECORDER_H
 #define RECORDER_H

+#include "common.h"
+
 #include <stdbool.h>
 #include <libavformat/avformat.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>

-#include "config.h"
-#include "common.h"
+#include "coords.h"
 #include "scrcpy.h"
 #include "util/queue.h"
+#include "util/thread.h"

 struct record_packet {
    AVPacket packet;
@ -25,9 +25,9 @@ struct recorder {
    struct size declared_frame_size;
    bool header_written;

-    SDL_Thread *thread;
-    SDL_mutex *mutex;
-    SDL_cond *queue_cond;
+    sc_thread thread;
+    sc_mutex mutex;
+    sc_cond queue_cond;
    bool stopped; // set on recorder_stop() by the stream reader
    bool failed; // set on packet write failure
    struct recorder_queue queue;
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@ -13,10 +13,6 @@
 # include <windows.h>
 #endif

-#include "config.h"
-#include "command.h"
-#include "common.h"
-#include "compat.h"
 #include "controller.h"
 #include "decoder.h"
 #include "device.h"
@ -30,11 +26,30 @@
 #include "stream.h"
 #include "tiny_xpm.h"
 #include "video_buffer.h"
-#include "util/lock.h"
 #include "util/log.h"
 #include "util/net.h"

-static struct server server = SERVER_INITIALIZER;
+static const char *sc_scale_filter_names[SC_SCALE_FILTER__COUNT] = {
+    [SC_SCALE_FILTER_NONE] = "none",
+    [SC_SCALE_FILTER_TRILINEAR] = "trilinear",
+    [SC_SCALE_FILTER_BILINEAR] = "bilinear",
+    [SC_SCALE_FILTER_BICUBIC] = "bicubic",
+    [SC_SCALE_FILTER_X] = "x",
+    [SC_SCALE_FILTER_POINT] = "point",
+    [SC_SCALE_FILTER_AREA] = "area",
+    [SC_SCALE_FILTER_BICUBLIN] = "bicublin",
+    [SC_SCALE_FILTER_GAUSS] = "gauss",
+    [SC_SCALE_FILTER_SINC] = "sinc",
+    [SC_SCALE_FILTER_LANCZOS] = "lanczos",
+    [SC_SCALE_FILTER_SPLINE] = "spline",
+};
+
+const char *
+sc_scale_filter_name(enum sc_scale_filter scale_filter) {
+    return sc_scale_filter_names[scale_filter];
+}
+
+static struct server server;
 static struct screen screen = SCREEN_INITIALIZER;
 static struct fps_counter fps_counter;
 static struct video_buffer video_buffer;
@ -189,7 +204,9 @@ handle_event(SDL_Event *event, const struct scrcpy_options *options) {
            }
            break;
        case SDL_WINDOWEVENT:
-            screen_handle_window_event(&screen, &event->window);
+            if (screen.has_frame) {
+                screen_handle_window_event(&screen, &event->window);
+            }
            break;
        case SDL_TEXTINPUT:
            if (!options->control) {
@ -230,13 +247,20 @@ handle_event(SDL_Event *event, const struct scrcpy_options *options) {
            if (!options->control) {
                break;
            }
+            char *file = strdup(event->drop.file);
+            SDL_free(event->drop.file);
+            if (!file) {
+                LOGW("Could not strdup drop filename\n");
+                break;
+            }
+
            file_handler_action_t action;
-            if (is_apk(event->drop.file)) {
+            if (is_apk(file)) {
                action = ACTION_INSTALL_APK;
            } else {
                action = ACTION_PUSH_FILE;
            }
-            file_handler_request(&file_handler, action, event->drop.file);
+            file_handler_request(&file_handler, action, file);
            break;
        }
    }
@ -290,7 +314,7 @@ av_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
    if (priority == 0) {
        return;
    }
-    char *local_fmt = SDL_malloc(strlen(fmt) + 10);
+    char *local_fmt = malloc(strlen(fmt) + 10);
    if (!local_fmt) {
        LOGC("Could not allocate string");
        return;
@ -299,11 +323,26 @@ av_log_callback(void *avcl, int level, const char *fmt, va_list vl) {
    strcpy(local_fmt, "[FFmpeg] ");
    strcpy(local_fmt + 9, fmt);
    SDL_LogMessageV(SDL_LOG_CATEGORY_VIDEO, priority, local_fmt, vl);
-    SDL_free(local_fmt);
+    free(local_fmt);
 }

 bool
 scrcpy(const struct scrcpy_options *options) {
+    if (!server_init(&server)) {
+        return false;
+    }
+
+    bool ret = false;
+
+    bool server_started = false;
+    bool fps_counter_initialized = false;
+    bool video_buffer_initialized = false;
+    bool file_handler_initialized = false;
+    bool recorder_initialized = false;
+    bool stream_started = false;
+    bool controller_initialized = false;
+    bool controller_started = false;
+
    bool record = !!options->record_filename;
    struct server_params params = {
        .log_level = options->log_level,
@ -322,18 +361,10 @@ scrcpy(const struct scrcpy_options *options) {
        .force_adb_forward = options->force_adb_forward,
    };
    if (!server_start(&server, options->serial, &params)) {
-        return false;
+        goto end;
    }

-    bool ret = false;
-
-    bool fps_counter_initialized = false;
-    bool video_buffer_initialized = false;
-    bool file_handler_initialized = false;
-    bool recorder_initialized = false;
-    bool stream_started = false;
-    bool controller_initialized = false;
-    bool controller_started = false;
+    server_started = true;

    if (!sdl_init_and_configure(options->display, options->render_driver,
                                options->disable_screensaver)) {
@ -423,7 +454,7 @@ scrcpy(const struct scrcpy_options *options) {
                                   options->window_y, options->window_width,
                                   options->window_height,
                                   options->window_borderless,
-                                   options->rotation, options->mipmaps)) {
+                                   options->rotation, options->scale_filter)) {
            goto end;
        }

@ -465,8 +496,10 @@ end:
        fps_counter_interrupt(&fps_counter);
    }

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

    // now that the sockets are shutdown, the stream and controller are
    // interrupted, we can join them
--- a/app/src/scrcpy.h
+++ b/app/src/scrcpy.h
@ -1,12 +1,12 @@
 #ifndef SCRCPY_H
 #define SCRCPY_H

+#include "common.h"
+
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>

-#include "config.h"
-
 enum sc_log_level {
    SC_LOG_LEVEL_DEBUG,
    SC_LOG_LEVEL_INFO,
@ -41,6 +41,25 @@ struct sc_port_range {
    uint16_t last;
 };

+enum sc_scale_filter {
+    SC_SCALE_FILTER_NONE,
+    SC_SCALE_FILTER_TRILINEAR, // mipmaps
+    SC_SCALE_FILTER_BILINEAR,
+    SC_SCALE_FILTER_BICUBIC,
+    SC_SCALE_FILTER_X,
+    SC_SCALE_FILTER_POINT,
+    SC_SCALE_FILTER_AREA,
+    SC_SCALE_FILTER_BICUBLIN,
+    SC_SCALE_FILTER_GAUSS,
+    SC_SCALE_FILTER_SINC,
+    SC_SCALE_FILTER_LANCZOS,
+    SC_SCALE_FILTER_SPLINE,
+    SC_SCALE_FILTER__COUNT,
+};
+
+const char *
+sc_scale_filter_name(enum sc_scale_filter scale_filter);
+
 #define SC_WINDOW_POSITION_UNDEFINED (-0x8000)

 struct scrcpy_options {
@ -56,6 +75,7 @@ struct scrcpy_options {
    enum sc_record_format record_format;
    struct sc_port_range port_range;
    struct sc_shortcut_mods shortcut_mods;
+    enum sc_scale_filter scale_filter;
    uint16_t max_size;
    uint32_t bit_rate;
    uint16_t max_fps;
@ -65,7 +85,7 @@ struct scrcpy_options {
    int16_t window_y; // SC_WINDOW_POSITION_UNDEFINED for "auto"
    uint16_t window_width;
    uint16_t window_height;
-    uint16_t display_id;
+    uint32_t display_id;
    bool show_touches;
    bool fullscreen;
    bool always_on_top;
@ -75,7 +95,6 @@ struct scrcpy_options {
    bool render_expired_frames;
    bool prefer_text;
    bool window_borderless;
-    bool mipmaps;
    bool stay_awake;
    bool force_adb_forward;
    bool disable_screensaver;
@ -103,6 +122,7 @@ struct scrcpy_options {
        .data = {SC_MOD_LALT, SC_MOD_LSUPER}, \
        .count = 2, \
    }, \
+    .scale_filter = SC_SCALE_FILTER_TRILINEAR, \
    .max_size = DEFAULT_MAX_SIZE, \
    .bit_rate = DEFAULT_BIT_RATE, \
    .max_fps = 0, \
@ -122,7 +142,6 @@ struct scrcpy_options {
    .render_expired_frames = false, \
    .prefer_text = false, \
    .window_borderless = false, \
-    .mipmaps = true, \
    .stay_awake = false, \
    .force_adb_forward = false, \
    .disable_screensaver = false, \
--- a/app/src/screen.c
+++ b/app/src/screen.c
@ -4,14 +4,9 @@
 #include <string.h>
 #include <SDL2/SDL.h>

-#include "config.h"
-#include "common.h"
-#include "compat.h"
 #include "icon.xpm"
-#include "scrcpy.h"
 #include "tiny_xpm.h"
 #include "video_buffer.h"
-#include "util/lock.h"
 #include "util/log.h"

 #define DISPLAY_MARGINS 96
@ -199,39 +194,12 @@ screen_init(struct screen *screen) {
    *screen = (struct screen) SCREEN_INITIALIZER;
 }

-static inline SDL_Texture *
-create_texture(struct screen *screen) {
-    SDL_Renderer *renderer = screen->renderer;
-    struct size size = screen->frame_size;
-    SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
-                                             SDL_TEXTUREACCESS_STREAMING,
-                                             size.width, size.height);
-    if (!texture) {
-        return NULL;
-    }
-
-    if (screen->mipmaps) {
-        struct sc_opengl *gl = &screen->gl;
-
-        SDL_GL_BindTexture(texture, NULL, NULL);
-
-        // Enable trilinear filtering for downscaling
-        gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
-                          GL_LINEAR_MIPMAP_LINEAR);
-        gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -1.f);
-
-        SDL_GL_UnbindTexture(texture);
-    }
-
-    return texture;
-}
-
 bool
 screen_init_rendering(struct screen *screen, const char *window_title,
                      struct size frame_size, bool always_on_top,
                      int16_t window_x, int16_t window_y, uint16_t window_width,
                      uint16_t window_height, bool window_borderless,
-                      uint8_t rotation, bool mipmaps) {
+                      uint8_t rotation, enum sc_scale_filter scale_filter) {
    screen->frame_size = frame_size;
    screen->rotation = rotation;
    if (rotation) {
@ -274,39 +242,17 @@ screen_init_rendering(struct screen *screen, const char *window_title,
                                          SDL_RENDERER_ACCELERATED);
    if (!screen->renderer) {
        LOGC("Could not create renderer: %s", SDL_GetError());
-        screen_destroy(screen);
+        SDL_DestroyWindow(screen->window);
        return false;
    }

-    SDL_RendererInfo renderer_info;
-    int r = SDL_GetRendererInfo(screen->renderer, &renderer_info);
-    const char *renderer_name = r ? NULL : renderer_info.name;
-    LOGI("Renderer: %s", renderer_name ? renderer_name : "(unknown)");
-
-    // starts with "opengl"
-    screen->use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
-    if (screen->use_opengl) {
-        struct sc_opengl *gl = &screen->gl;
-        sc_opengl_init(gl);
-
-        LOGI("OpenGL version: %s", gl->version);
-
-        if (mipmaps) {
-            bool supports_mipmaps =
-                sc_opengl_version_at_least(gl, 3, 0, /* OpenGL 3.0+ */
-                                               2, 0  /* OpenGL ES 2.0+ */);
-            if (supports_mipmaps) {
-                LOGI("Trilinear filtering enabled");
-                screen->mipmaps = true;
-            } else {
-                LOGW("Trilinear filtering disabled "
-                     "(OpenGL 3.0+ or ES 2.0+ required)");
-            }
-        } else {
-            LOGI("Trilinear filtering disabled");
-        }
-    } else {
-        LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
+    bool ok = sc_frame_texture_init(&screen->ftex, screen->renderer,
+                                    scale_filter, frame_size);
+    if (!ok) {
+        LOGC("Could not init frame texture");
+        SDL_DestroyRenderer(screen->renderer);
+        SDL_DestroyWindow(screen->window);
+        return false;
    }

    SDL_Surface *icon = read_xpm(icon_xpm);
@ -317,15 +263,6 @@ screen_init_rendering(struct screen *screen, const char *window_title,
        LOGW("Could not load icon");
    }

-    LOGI("Initial texture: %" PRIu16 "x%" PRIu16, frame_size.width,
-                                                  frame_size.height);
-    screen->texture = create_texture(screen);
-    if (!screen->texture) {
-        LOGC("Could not create texture: %s", SDL_GetError());
-        screen_destroy(screen);
-        return false;
-    }
-
    // Reset the window size to trigger a SIZE_CHANGED event, to workaround
    // HiDPI issues with some SDL renderers when several displays having
    // different HiDPI scaling are connected
@ -343,15 +280,9 @@ screen_show_window(struct screen *screen) {

 void
 screen_destroy(struct screen *screen) {
-    if (screen->texture) {
-        SDL_DestroyTexture(screen->texture);
-    }
-    if (screen->renderer) {
-        SDL_DestroyRenderer(screen->renderer);
-    }
-    if (screen->window) {
-        SDL_DestroyWindow(screen->window);
-    }
+    sc_frame_texture_destroy(&screen->ftex);
+    SDL_DestroyRenderer(screen->renderer);
+    SDL_DestroyWindow(screen->window);
 }

 static void
@ -412,13 +343,10 @@ screen_set_rotation(struct screen *screen, unsigned rotation) {
 }

 // recreate the texture and resize the window if the frame size has changed
-static bool
+static void
 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
-        SDL_DestroyTexture(screen->texture);
-
        screen->frame_size = new_frame_size;

        struct size new_content_size =
@ -426,46 +354,20 @@ prepare_for_frame(struct screen *screen, struct size new_frame_size) {
        set_content_size(screen, new_content_size);

        screen_update_content_rect(screen);
-
-        LOGI("New texture: %" PRIu16 "x%" PRIu16,
-                     screen->frame_size.width, screen->frame_size.height);
-        screen->texture = create_texture(screen);
-        if (!screen->texture) {
-            LOGC("Could not create texture: %s", SDL_GetError());
-            return false;
-        }
-    }
-
-    return true;
-}
-
-// write the frame into the texture
-static void
-update_texture(struct screen *screen, const AVFrame *frame) {
-    SDL_UpdateYUVTexture(screen->texture, NULL,
-            frame->data[0], frame->linesize[0],
-            frame->data[1], frame->linesize[1],
-            frame->data[2], frame->linesize[2]);
-
-    if (screen->mipmaps) {
-        assert(screen->use_opengl);
-        SDL_GL_BindTexture(screen->texture, NULL, NULL);
-        screen->gl.GenerateMipmap(GL_TEXTURE_2D);
-        SDL_GL_UnbindTexture(screen->texture);
    }
 }

 bool
 screen_update_frame(struct screen *screen, struct video_buffer *vb) {
-    mutex_lock(vb->mutex);
-    const AVFrame *frame = video_buffer_consume_rendered_frame(vb);
+    const AVFrame *frame = video_buffer_take_rendering_frame(vb);
    struct size new_frame_size = {frame->width, frame->height};
-    if (!prepare_for_frame(screen, new_frame_size)) {
-        mutex_unlock(vb->mutex);
+    prepare_for_frame(screen, new_frame_size);
+
+    struct size rect_size = {screen->rect.w, screen->rect.h};
+    bool ok = sc_frame_texture_update(&screen->ftex, frame, rect_size);
+    if (!ok) {
        return false;
    }
-    update_texture(screen, frame);
-    mutex_unlock(vb->mutex);

    screen_render(screen, false);
    return true;
@ -475,11 +377,18 @@ void
 screen_render(struct screen *screen, bool update_content_rect) {
    if (update_content_rect) {
        screen_update_content_rect(screen);
+        struct size rect_size = {screen->rect.w, screen->rect.h};
+        if (!sc_frame_texture_resize(&screen->ftex, rect_size)) {
+            // FIXME return error
+            LOGC("oops");
+        }
    }

-    SDL_RenderClear(screen->renderer);
+    struct sc_frame_texture *ftex = &screen->ftex;
+    SDL_RenderClear(ftex->renderer);
    if (screen->rotation == 0) {
-        SDL_RenderCopy(screen->renderer, screen->texture, NULL, &screen->rect);
+        SDL_RenderCopy(screen->renderer, ftex->texture, NULL,
+                       &screen->rect);
    } else {
        // rotation in RenderCopyEx() is clockwise, while screen->rotation is
        // counterclockwise (to be consistent with --lock-video-orientation)
@ -499,10 +408,10 @@ screen_render(struct screen *screen, bool update_content_rect) {
            dstrect = &screen->rect;
        }

-        SDL_RenderCopyEx(screen->renderer, screen->texture, NULL, dstrect,
+        SDL_RenderCopyEx(screen->renderer, ftex->texture, NULL, dstrect,
                         angle, NULL, 0);
    }
-    SDL_RenderPresent(screen->renderer);
+    SDL_RenderPresent(ftex->renderer);
 }

 void
--- a/app/src/screen.h
+++ b/app/src/screen.h
@ -1,22 +1,24 @@
 #ifndef SCREEN_H
 #define SCREEN_H

+#include "common.h"
+
 #include <stdbool.h>
 #include <SDL2/SDL.h>
 #include <libavformat/avformat.h>

-#include "config.h"
-#include "common.h"
+#include "coords.h"
+#include "frame_texture.h"
 #include "opengl.h"
+#include "scrcpy.h"

 struct video_buffer;

 struct screen {
    SDL_Window *window;
    SDL_Renderer *renderer;
-    SDL_Texture *texture;
-    bool use_opengl;
-    struct sc_opengl gl;
+    struct sc_frame_texture ftex;
+
    struct size frame_size;
    struct size content_size; // rotated frame_size

@ -33,15 +35,12 @@ struct screen {
    bool fullscreen;
    bool maximized;
    bool no_window;
-    bool mipmaps;
 };

 #define SCREEN_INITIALIZER { \
    .window = NULL, \
    .renderer = NULL, \
-    .texture = NULL, \
-    .use_opengl = false, \
-    .gl = {0}, \
+    .ftex = {0}, \
    .frame_size = { \
        .width = 0, \
        .height = 0, \
@ -66,7 +65,6 @@ struct screen {
    .fullscreen = false, \
    .maximized = false, \
    .no_window = false, \
-    .mipmaps = false, \
 }

 // initialize default values
@ -80,7 +78,7 @@ screen_init_rendering(struct screen *screen, const char *window_title,
                      struct size frame_size, bool always_on_top,
                      int16_t window_x, int16_t window_y, uint16_t window_width,
                      uint16_t window_height, bool window_borderless,
-                      uint8_t rotation, bool mipmaps);
+                      uint8_t rotation, enum sc_scale_filter scale_filter);

 // show the window
 void
--- a/app/src/server.c
+++ b/app/src/server.c
@ -5,12 +5,10 @@
 #include <inttypes.h>
 #include <libgen.h>
 #include <stdio.h>
-#include <SDL2/SDL_thread.h>
 #include <SDL2/SDL_timer.h>
 #include <SDL2/SDL_platform.h>

-#include "config.h"
-#include "command.h"
+#include "adb.h"
 #include "util/log.h"
 #include "util/net.h"
 #include "util/str_util.h"
@ -33,7 +31,7 @@ get_server_path(void) {
 #ifdef __WINDOWS__
        char *server_path = utf8_from_wide_char(server_path_env);
 #else
-        char *server_path = SDL_strdup(server_path_env);
+        char *server_path = strdup(server_path_env);
 #endif
        if (!server_path) {
            LOGE("Could not allocate memory");
@ -45,7 +43,7 @@ get_server_path(void) {

 #ifndef PORTABLE
    LOGD("Using server: " DEFAULT_SERVER_PATH);
-    char *server_path = SDL_strdup(DEFAULT_SERVER_PATH);
+    char *server_path = strdup(DEFAULT_SERVER_PATH);
    if (!server_path) {
        LOGE("Could not allocate memory");
        return NULL;
@ -67,11 +65,11 @@ get_server_path(void) {

    // sizeof(SERVER_FILENAME) gives statically the size including the null byte
    size_t len = dirlen + 1 + sizeof(SERVER_FILENAME);
-    char *server_path = SDL_malloc(len);
+    char *server_path = malloc(len);
    if (!server_path) {
        LOGE("Could not alloc server path string, "
             "using " SERVER_FILENAME " from current directory");
-        SDL_free(executable_path);
+        free(executable_path);
        return SERVER_FILENAME;
    }

@ -80,7 +78,7 @@ get_server_path(void) {
    memcpy(&server_path[dirlen + 1], SERVER_FILENAME, sizeof(SERVER_FILENAME));
    // the final null byte has been copied with SERVER_FILENAME

-    SDL_free(executable_path);
+    free(executable_path);

    LOGD("Using server (portable): %s", server_path);
    return server_path;
@ -95,36 +93,36 @@ push_server(const char *serial) {
    }
    if (!is_regular_file(server_path)) {
        LOGE("'%s' does not exist or is not a regular file\n", server_path);
-        SDL_free(server_path);
+        free(server_path);
        return false;
    }
    process_t process = adb_push(serial, server_path, DEVICE_SERVER_PATH);
-    SDL_free(server_path);
-    return process_check_success(process, "adb push");
+    free(server_path);
+    return process_check_success(process, "adb push", true);
 }

 static bool
 enable_tunnel_reverse(const char *serial, uint16_t local_port) {
    process_t process = adb_reverse(serial, SOCKET_NAME, local_port);
-    return process_check_success(process, "adb reverse");
+    return process_check_success(process, "adb reverse", true);
 }

 static bool
 disable_tunnel_reverse(const char *serial) {
    process_t process = adb_reverse_remove(serial, SOCKET_NAME);
-    return process_check_success(process, "adb reverse --remove");
+    return process_check_success(process, "adb reverse --remove", true);
 }

 static bool
 enable_tunnel_forward(const char *serial, uint16_t local_port) {
    process_t process = adb_forward(serial, local_port, SOCKET_NAME);
-    return process_check_success(process, "adb forward");
+    return process_check_success(process, "adb forward", true);
 }

 static bool
 disable_tunnel_forward(const char *serial, uint16_t local_port) {
    process_t process = adb_forward_remove(serial, local_port);
-    return process_check_success(process, "adb forward --remove");
+    return process_check_success(process, "adb forward --remove", true);
 }

 static bool
@ -257,12 +255,12 @@ execute_server(struct server *server, const struct server_params *params) {
    char bit_rate_string[11];
    char max_fps_string[6];
    char lock_video_orientation_string[5];
-    char display_id_string[6];
+    char display_id_string[11];
    sprintf(max_size_string, "%"PRIu16, params->max_size);
    sprintf(bit_rate_string, "%"PRIu32, params->bit_rate);
    sprintf(max_fps_string, "%"PRIu16, params->max_fps);
    sprintf(lock_video_orientation_string, "%"PRIi8, params->lock_video_orientation);
-    sprintf(display_id_string, "%"PRIu16, params->display_id);
+    sprintf(display_id_string, "%"PRIu32, params->display_id);
    const char *const cmd[] = {
        "shell",
        "CLASSPATH=" DEVICE_SERVER_PATH,
@ -353,15 +351,50 @@ close_socket(socket_t socket) {
    }
 }

-void
+bool
 server_init(struct server *server) {
-    *server = (struct server) SERVER_INITIALIZER;
+    server->serial = NULL;
+    server->process = PROCESS_NONE;
+    atomic_flag_clear_explicit(&server->server_socket_closed,
+                               memory_order_relaxed);
+
+    bool ok = sc_mutex_init(&server->mutex);
+    if (!ok) {
+        return false;
+    }
+
+    ok = sc_cond_init(&server->process_terminated_cond);
+    if (!ok) {
+        sc_mutex_destroy(&server->mutex);
+        return false;
+    }
+
+    server->process_terminated = false;
+
+    server->server_socket = INVALID_SOCKET;
+    server->video_socket = INVALID_SOCKET;
+    server->control_socket = INVALID_SOCKET;
+
+    server->port_range.first = 0;
+    server->port_range.last = 0;
+    server->local_port = 0;
+
+    server->tunnel_enabled = false;
+    server->tunnel_forward = false;
+
+    return true;
 }

 static int
 run_wait_server(void *data) {
    struct server *server = data;
-    cmd_simple_wait(server->process, NULL); // ignore exit code
+    process_wait(server->process, false); // ignore exit code
+
+    sc_mutex_lock(&server->mutex);
+    server->process_terminated = true;
+    sc_cond_signal(&server->process_terminated_cond);
+    sc_mutex_unlock(&server->mutex);
+
    // no need for synchronization, server_socket is initialized before this
    // thread was created
    if (server->server_socket != INVALID_SOCKET
@ -380,7 +413,7 @@ server_start(struct server *server, const char *serial,
    server->port_range = params->port_range;

    if (serial) {
-        server->serial = SDL_strdup(serial);
+        server->serial = strdup(serial);
        if (!server->serial) {
            return false;
        }
@ -407,11 +440,11 @@ server_start(struct server *server, const char *serial,
    // things simple and multiplatform, just spawn a new thread waiting for the
    // server process and calling shutdown()/close() on the server socket if
    // necessary to wake up any accept() blocking call.
-    server->wait_server_thread =
-        SDL_CreateThread(run_wait_server, "wait-server", server);
-    if (!server->wait_server_thread) {
-        cmd_terminate(server->process);
-        cmd_simple_wait(server->process, NULL); // ignore exit code
+    bool ok = sc_thread_create(&server->wait_server_thread, run_wait_server,
+                               "wait-server", server);
+    if (!ok) {
+        process_terminate(server->process);
+        process_wait(server->process, true); // ignore exit code
        goto error2;
    }

@ -430,7 +463,7 @@ error2:
    }
    disable_tunnel(server);
 error1:
-    SDL_free(server->serial);
+    free(server->serial);
    return false;
 }

@ -493,17 +526,39 @@ server_stop(struct server *server) {

    assert(server->process != PROCESS_NONE);

-    cmd_terminate(server->process);
-
    if (server->tunnel_enabled) {
        // ignore failure
        disable_tunnel(server);
    }

-    SDL_WaitThread(server->wait_server_thread, NULL);
+    // Give some delay for the server to terminate properly
+    sc_mutex_lock(&server->mutex);
+    bool signaled = false;
+    if (!server->process_terminated) {
+#define WATCHDOG_DELAY_MS 1000
+        signaled = sc_cond_timedwait(&server->process_terminated_cond,
+                                     &server->mutex,
+                                     WATCHDOG_DELAY_MS);
+    }
+    sc_mutex_unlock(&server->mutex);
+
+    // After this delay, kill the server if it's not dead already.
+    // On some devices, closing the sockets is not sufficient to wake up the
+    // blocking calls while the device is asleep.
+    if (!signaled) {
+        // The process is terminated, but not reaped (closed) yet, so its PID
+        // is still valid.
+        LOGW("Killing the server...");
+        process_terminate(server->process);
+    }
+
+    sc_thread_join(&server->wait_server_thread, NULL);
+    process_close(server->process);
 }

 void
 server_destroy(struct server *server) {
-    SDL_free(server->serial);
+    free(server->serial);
+    sc_cond_destroy(&server->process_terminated_cond);
+    sc_mutex_destroy(&server->mutex);
 }
--- a/app/src/server.h
+++ b/app/src/server.h
@ -1,23 +1,28 @@
 #ifndef SERVER_H
 #define SERVER_H

+#include "common.h"
+
 #include <stdatomic.h>
 #include <stdbool.h>
 #include <stdint.h>
-#include <SDL2/SDL_thread.h>

-#include "config.h"
-#include "command.h"
-#include "common.h"
+#include "adb.h"
 #include "scrcpy.h"
 #include "util/log.h"
 #include "util/net.h"
+#include "util/thread.h"

 struct server {
    char *serial;
    process_t process;
-    SDL_Thread *wait_server_thread;
+    sc_thread wait_server_thread;
    atomic_flag server_socket_closed;
+
+    sc_mutex mutex;
+    sc_cond process_terminated_cond;
+    bool process_terminated;
+
    socket_t server_socket; // only used if !tunnel_forward
    socket_t video_socket;
    socket_t control_socket;
@ -27,23 +32,6 @@ struct server {
    bool tunnel_forward; // use "adb forward" instead of "adb reverse"
 };

-#define SERVER_INITIALIZER { \
-    .serial = NULL, \
-    .process = PROCESS_NONE, \
-    .wait_server_thread = NULL, \
-    .server_socket_closed = ATOMIC_FLAG_INIT, \
-    .server_socket = INVALID_SOCKET, \
-    .video_socket = INVALID_SOCKET, \
-    .control_socket = INVALID_SOCKET, \
-    .port_range = { \
-        .first = 0, \
-        .last = 0, \
-    }, \
-    .local_port = 0, \
-    .tunnel_enabled = false, \
-    .tunnel_forward = false, \
-}
-
 struct server_params {
    enum sc_log_level log_level;
    const char *crop;
@ -55,14 +43,14 @@ struct server_params {
    uint16_t max_fps;
    int8_t lock_video_orientation;
    bool control;
-    uint16_t display_id;
+    uint32_t display_id;
    bool show_touches;
    bool stay_awake;
    bool force_adb_forward;
 };

 // init default values
-void
+bool
 server_init(struct server *server);

 // push, enable tunnel et start the server
--- a/app/src/stream.c
+++ b/app/src/stream.c
@ -4,12 +4,8 @@
 #include <libavformat/avformat.h>
 #include <libavutil/time.h>
 #include <SDL2/SDL_events.h>
-#include <SDL2/SDL_mutex.h>
-#include <SDL2/SDL_thread.h>
 #include <unistd.h>

-#include "config.h"
-#include "compat.h"
 #include "decoder.h"
 #include "events.h"
 #include "recorder.h"
@ -281,8 +277,8 @@ bool
 stream_start(struct stream *stream) {
    LOGD("Starting stream thread");

-    stream->thread = SDL_CreateThread(run_stream, "stream", stream);
-    if (!stream->thread) {
+    bool ok = sc_thread_create(&stream->thread, run_stream, "stream", stream);
+    if (!ok) {
        LOGC("Could not start stream thread");
        return false;
    }
@ -298,5 +294,5 @@ stream_stop(struct stream *stream) {

 void
 stream_join(struct stream *stream) {
-    SDL_WaitThread(stream->thread, NULL);
+    sc_thread_join(&stream->thread, NULL);
 }
--- a/app/src/stream.h
+++ b/app/src/stream.h
@ -1,20 +1,21 @@
 #ifndef STREAM_H
 #define STREAM_H

+#include "common.h"
+
 #include <stdbool.h>
 #include <stdint.h>
 #include <libavformat/avformat.h>
 #include <SDL2/SDL_atomic.h>
-#include <SDL2/SDL_thread.h>

-#include "config.h"
 #include "util/net.h"
+#include "util/thread.h"

 struct video_buffer;

 struct stream {
    socket_t socket;
-    SDL_Thread *thread;
+    sc_thread thread;
    struct decoder *decoder;
    struct recorder *recorder;
    AVCodecContext *codec_ctx;
--- a/app/src/sys/unix/process.c
+++ b/app/src/sys/unix/process.c
@ -1,13 +1,4 @@
-// for portability (kill, readlink, strdup, strtok_r)
-#define _POSIX_C_SOURCE 200809L
-#define _BSD_SOURCE
-
-// modern glibc will complain without this
-#define _DEFAULT_SOURCE
-
-#include "command.h"
-
-#include "config.h"
+#include "util/process.h"

 #include <errno.h>
 #include <fcntl.h>
@ -17,14 +8,13 @@
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
-#include <sys/stat.h>
 #include <sys/wait.h>
 #include <unistd.h>

 #include "util/log.h"

 bool
-cmd_search(const char *file) {
+search_executable(const char *file) {
    char *path = getenv("PATH");
    if (!path)
        return false;
@ -60,7 +50,7 @@ cmd_search(const char *file) {
 }

 enum process_result
-cmd_execute(const char *const argv[], pid_t *pid) {
+process_execute(const char *const argv[], pid_t *pid) {
    int fd[2];

    if (pipe(fd) == -1) {
@ -122,29 +112,37 @@ end:
 }

 bool
-cmd_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);
        abort();
    }
-    return kill(pid, SIGTERM) != -1;
+    return kill(pid, SIGKILL) != -1;
 }

-bool
-cmd_simple_wait(pid_t pid, int *exit_code) {
-    int status;
+exit_code_t
+process_wait(pid_t pid, bool close) {
    int code;
-    if (waitpid(pid, &status, 0) == -1 || !WIFEXITED(status)) {
+    int options = WEXITED;
+    if (!close) {
+        options |= WNOWAIT;
+    }
+
+    siginfo_t info;
+    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 = -1;
+        code = NO_EXIT_CODE;
    } else {
-        code = WEXITSTATUS(status);
+        code = info.si_status;
    }
-    if (exit_code) {
-        *exit_code = code;
-    }
-    return !code;
+    return code;
+}
+
+void
+process_close(pid_t pid) {
+    process_wait(pid, true); // ignore exit code
 }

 char *
@ -158,7 +156,7 @@ get_executable_path(void) {
        return NULL;
    }
    buf[len] = '\0';
-    return SDL_strdup(buf);
+    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
--- a/app/src/sys/win/process.c
+++ b/app/src/sys/win/process.c
@ -1,8 +1,8 @@
-#include "command.h"
+#include "util/process.h"

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

-#include "config.h"
 #include "util/log.h"
 #include "util/str_util.h"

@ -21,7 +21,7 @@ build_cmd(char *cmd, size_t len, const char *const argv[]) {
 }

 enum process_result
-cmd_execute(const char *const argv[], HANDLE *handle) {
+process_execute(const char *const argv[], HANDLE *handle) {
    STARTUPINFOW si;
    PROCESS_INFORMATION pi;
    memset(&si, 0, sizeof(si));
@ -39,14 +39,9 @@ cmd_execute(const char *const argv[], HANDLE *handle) {
        return PROCESS_ERROR_GENERIC;
    }

-#ifdef WINDOWS_NOCONSOLE
-    int flags = CREATE_NO_WINDOW;
-#else
-    int flags = 0;
-#endif
-    if (!CreateProcessW(NULL, wide, NULL, NULL, FALSE, flags, NULL, NULL, &si,
+    if (!CreateProcessW(NULL, wide, NULL, NULL, FALSE, 0, NULL, NULL, &si,
                        &pi)) {
-        SDL_free(wide);
+        free(wide);
        *handle = NULL;
        if (GetLastError() == ERROR_FILE_NOT_FOUND) {
            return PROCESS_ERROR_MISSING_BINARY;
@ -54,28 +49,35 @@ cmd_execute(const char *const argv[], HANDLE *handle) {
        return PROCESS_ERROR_GENERIC;
    }

-    SDL_free(wide);
+    free(wide);
    *handle = pi.hProcess;
    return PROCESS_SUCCESS;
 }

 bool
-cmd_terminate(HANDLE handle) {
-    return TerminateProcess(handle, 1) && CloseHandle(handle);
+process_terminate(HANDLE handle) {
+    return TerminateProcess(handle, 1);
 }

-bool
-cmd_simple_wait(HANDLE handle, DWORD *exit_code) {
+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 = -1; // max value, it's unsigned
+        code = NO_EXIT_CODE; // max value, it's unsigned
    }
-    if (exit_code) {
-        *exit_code = code;
+    if (close) {
+        CloseHandle(handle);
    }
-    return !code;
+    return code;
+}
+
+void
+process_close(HANDLE handle) {
+    bool closed = CloseHandle(handle);
+    assert(closed);
+    (void) closed;
 }

 char *
@ -103,7 +105,7 @@ is_regular_file(const char *path) {

    struct _stat path_stat;
    int r = _wstat(wide_path, &path_stat);
-    SDL_free(wide_path);
+    free(wide_path);

    if (r) {
        perror("stat");
--- a/app/src/tiny_xpm.c
+++ b/app/src/tiny_xpm.c
@ -6,7 +6,6 @@
 #include <stdio.h>
 #include <stdlib.h>

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

 struct index {
--- a/app/src/tiny_xpm.h
+++ b/app/src/tiny_xpm.h
@ -1,9 +1,9 @@
 #ifndef TINYXPM_H
 #define TINYXPM_H

-#include <SDL2/SDL.h>
+#include "common.h"

-#include "config.h"
+#include <SDL2/SDL.h>

 SDL_Surface *
 read_xpm(char *xpm[]);
--- a/app/src/util/buffer_util.h
+++ b/app/src/util/buffer_util.h
@ -1,11 +1,11 @@
 #ifndef BUFFER_UTIL_H
 #define BUFFER_UTIL_H

+#include "common.h"
+
 #include <stdbool.h>
 #include <stdint.h>

-#include "config.h"
-
 static inline void
 buffer_write16be(uint8_t *buf, uint16_t value) {
    buf[0] = value >> 8;
@ -33,7 +33,7 @@ buffer_read16be(const uint8_t *buf) {

 static inline uint32_t
 buffer_read32be(const uint8_t *buf) {
-    return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
+    return ((uint32_t) buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
 }

 static inline uint64_t
--- a/app/src/util/cbuf.h
+++ b/app/src/util/cbuf.h
@ -2,11 +2,11 @@
 #ifndef CBUF_H
 #define CBUF_H

+#include "common.h"
+
 #include <stdbool.h>
 #include <unistd.h>

-#include "config.h"
-
 // To define a circular buffer type of 20 ints:
 //     struct cbuf_int CBUF(int, 20);
 //
--- a/app/src/util/lock.h
+++ b/app/src/util/lock.h
@ -1,74 +0,0 @@
-#ifndef LOCK_H
-#define LOCK_H
-
-#include <stdint.h>
-#include <SDL2/SDL_mutex.h>
-
-#include "config.h"
-#include "log.h"
-
-static inline void
-mutex_lock(SDL_mutex *mutex) {
-    int r = SDL_LockMutex(mutex);
-#ifndef NDEBUG
-    if (r) {
-        LOGC("Could not lock mutex: %s", SDL_GetError());
-        abort();
-    }
-#else
-    (void) r;
-#endif
-}
-
-static inline void
-mutex_unlock(SDL_mutex *mutex) {
-    int r = SDL_UnlockMutex(mutex);
-#ifndef NDEBUG
-    if (r) {
-        LOGC("Could not unlock mutex: %s", SDL_GetError());
-        abort();
-    }
-#else
-    (void) r;
-#endif
-}
-
-static inline void
-cond_wait(SDL_cond *cond, SDL_mutex *mutex) {
-    int r = SDL_CondWait(cond, mutex);
-#ifndef NDEBUG
-    if (r) {
-        LOGC("Could not wait on condition: %s", SDL_GetError());
-        abort();
-    }
-#else
-    (void) r;
-#endif
-}
-
-static inline int
-cond_wait_timeout(SDL_cond *cond, SDL_mutex *mutex, uint32_t ms) {
-    int r = SDL_CondWaitTimeout(cond, mutex, ms);
-#ifndef NDEBUG
-    if (r < 0) {
-        LOGC("Could not wait on condition with timeout: %s", SDL_GetError());
-        abort();
-    }
-#endif
-    return r;
-}
-
-static inline void
-cond_signal(SDL_cond *cond) {
-    int r = SDL_CondSignal(cond);
-#ifndef NDEBUG
-    if (r) {
-        LOGC("Could not signal a condition: %s", SDL_GetError());
-        abort();
-    }
-#else
-    (void) r;
-#endif
-}
-
-#endif
--- a/app/src/util/net.c
+++ b/app/src/util/net.c
@ -3,7 +3,6 @@
 #include <stdio.h>
 #include <SDL2/SDL_platform.h>

-#include "config.h"
 #include "log.h"

 #ifdef __WINDOWS__
--- a/app/src/util/net.h
+++ b/app/src/util/net.h
@ -1,6 +1,8 @@
 #ifndef NET_H
 #define NET_H

+#include "common.h"
+
 #include <stdbool.h>
 #include <stdint.h>
 #include <SDL2/SDL_platform.h>
@ -17,8 +19,6 @@
  typedef int socket_t;
 #endif

-#include "config.h"
-
 bool
 net_init(void);

--- a/app/src/util/process.c
+++ b/app/src/util/process.c
@ -0,0 +1,21 @@
+#include "process.h"
+
+#include "log.h"
+
+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;
+}
--- a/app/src/util/process.h
+++ b/app/src/util/process.h
@ -1,8 +1,9 @@
-#ifndef COMMAND_H
-#define COMMAND_H
+#ifndef SC_PROCESS_H
+#define SC_PROCESS_H
+
+#include "common.h"

 #include <stdbool.h>
-#include <inttypes.h>

 #ifdef _WIN32

@ -12,11 +13,7 @@
 # define PATH_SEPARATOR '\\'
 # define PRIexitcode "lu"
 // <https://stackoverflow.com/a/44383330/1987178>
-# ifdef _WIN64
-#   define PRIsizet PRIu64
-# else
-#   define PRIsizet PRIu32
-# endif
+# define PRIsizet "Iu"
 # define PROCESS_NONE NULL
 # define NO_EXIT_CODE -1u // max value as unsigned
  typedef HANDLE process_t;
@ -35,58 +32,45 @@

 #endif

-#include "config.h"
-
 enum process_result {
    PROCESS_SUCCESS,
    PROCESS_ERROR_GENERIC,
    PROCESS_ERROR_MISSING_BINARY,
 };

-#ifndef __WINDOWS__
-bool
-cmd_search(const char *file);
-#endif
-
+// execute the command and write the result to the output parameter "process"
 enum process_result
-cmd_execute(const char *const argv[], process_t *process);
+process_execute(const char *const argv[], process_t *process);

+// kill the process
 bool
-cmd_terminate(process_t pid);
+process_terminate(process_t pid);

-bool
-cmd_simple_wait(process_t pid, exit_code_t *exit_code);
+// 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);

-process_t
-adb_execute(const char *serial, const char *const adb_cmd[], size_t len);
-
-process_t
-adb_forward(const char *serial, uint16_t local_port,
-            const char *device_socket_name);
-
-process_t
-adb_forward_remove(const char *serial, uint16_t local_port);
-
-process_t
-adb_reverse(const char *serial, const char *device_socket_name,
-            uint16_t local_port);
-
-process_t
-adb_reverse_remove(const char *serial, const char *device_socket_name);
-
-process_t
-adb_push(const char *serial, const char *local, const char *remote);
-
-process_t
-adb_install(const char *serial, const char *local);
+// close the process
+//
+// Semantically, process_wait(close) = process_wait(noclose) + process_close
+void
+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);
+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 SDL_free
+// may be NULL on error; to be freed by free()
 char *
 get_executable_path(void);

--- a/app/src/util/queue.h
+++ b/app/src/util/queue.h
@ -2,12 +2,12 @@
 #ifndef QUEUE_H
 #define QUEUE_H

+#include "common.h"
+
 #include <assert.h>
 #include <stdbool.h>
 #include <stddef.h>

-#include "config.h"
-
 // To define a queue type of "struct foo":
 //    struct queue_foo QUEUE(struct foo);
 #define QUEUE(TYPE) { \
--- a/app/src/util/str_util.c
+++ b/app/src/util/str_util.c
@ -10,10 +10,6 @@
 # include <tchar.h>
 #endif

-#include <SDL2/SDL_stdinc.h>
-
-#include "config.h"
-
 size_t
 xstrncpy(char *dest, const char *src, size_t n) {
    size_t i;
@ -51,7 +47,7 @@ truncated:
 char *
 strquote(const char *src) {
    size_t len = strlen(src);
-    char *quoted = SDL_malloc(len + 3);
+    char *quoted = malloc(len + 3);
    if (!quoted) {
        return NULL;
    }
@ -169,7 +165,7 @@ utf8_to_wide_char(const char *utf8) {
        return NULL;
    }

-    wchar_t *wide = SDL_malloc(len * sizeof(wchar_t));
+    wchar_t *wide = malloc(len * sizeof(wchar_t));
    if (!wide) {
        return NULL;
    }
@ -185,7 +181,7 @@ utf8_from_wide_char(const wchar_t *ws) {
        return NULL;
    }

-    char *utf8 = SDL_malloc(len);
+    char *utf8 = malloc(len);
    if (!utf8) {
        return NULL;
    }
--- a/app/src/util/str_util.h
+++ b/app/src/util/str_util.h
@ -1,11 +1,11 @@
 #ifndef STRUTIL_H
 #define STRUTIL_H

+#include "common.h"
+
 #include <stdbool.h>
 #include <stddef.h>

-#include "config.h"
-
 // like strncpy, except:
 //  - it copies at most n-1 chars
 //  - the dest string is nul-terminated
--- a/app/src/util/thread.c
+++ b/app/src/util/thread.c
@ -0,0 +1,160 @@
+#include "thread.h"
+
+#include <assert.h>
+#include <SDL2/SDL_thread.h>
+
+#include "log.h"
+
+bool
+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) {
+        return false;
+    }
+
+    thread->thread = sdl_thread;
+    return true;
+}
+
+void
+sc_thread_join(sc_thread *thread, int *status) {
+    SDL_WaitThread(thread->thread, status);
+}
+
+bool
+sc_mutex_init(sc_mutex *mutex) {
+    SDL_mutex *sdl_mutex = SDL_CreateMutex();
+    if (!sdl_mutex) {
+        return false;
+    }
+
+    mutex->mutex = sdl_mutex;
+#ifndef NDEBUG
+    mutex->locker = 0;
+#endif
+    return true;
+}
+
+void
+sc_mutex_destroy(sc_mutex *mutex) {
+    SDL_DestroyMutex(mutex->mutex);
+}
+
+void
+sc_mutex_lock(sc_mutex *mutex) {
+    // SDL mutexes are recursive, but we don't want to use recursive mutexes
+    assert(!sc_mutex_held(mutex));
+    int r = SDL_LockMutex(mutex->mutex);
+#ifndef NDEBUG
+    if (r) {
+        LOGC("Could not lock mutex: %s", SDL_GetError());
+        abort();
+    }
+
+    mutex->locker = sc_thread_get_id();
+#else
+    (void) r;
+#endif
+}
+
+void
+sc_mutex_unlock(sc_mutex *mutex) {
+#ifndef NDEBUG
+    assert(sc_mutex_held(mutex));
+    mutex->locker = 0;
+#endif
+    int r = SDL_UnlockMutex(mutex->mutex);
+#ifndef NDEBUG
+    if (r) {
+        LOGC("Could not lock mutex: %s", SDL_GetError());
+        abort();
+    }
+#else
+    (void) r;
+#endif
+}
+
+sc_thread_id
+sc_thread_get_id(void) {
+    return SDL_ThreadID();
+}
+
+#ifndef NDEBUG
+bool
+sc_mutex_held(struct sc_mutex *mutex) {
+    return mutex->locker == sc_thread_get_id();
+}
+#endif
+
+bool
+sc_cond_init(sc_cond *cond) {
+    SDL_cond *sdl_cond = SDL_CreateCond();
+    if (!sdl_cond) {
+        return false;
+    }
+
+    cond->cond = sdl_cond;
+    return true;
+}
+
+void
+sc_cond_destroy(sc_cond *cond) {
+    SDL_DestroyCond(cond->cond);
+}
+
+void
+sc_cond_wait(sc_cond *cond, sc_mutex *mutex) {
+    int r = SDL_CondWait(cond->cond, mutex->mutex);
+#ifndef NDEBUG
+    if (r) {
+        LOGC("Could not wait on condition: %s", SDL_GetError());
+        abort();
+    }
+
+    mutex->locker = sc_thread_get_id();
+#else
+    (void) r;
+#endif
+}
+
+bool
+sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, uint32_t ms) {
+    int r = SDL_CondWaitTimeout(cond->cond, mutex->mutex, ms);
+#ifndef NDEBUG
+    if (r < 0) {
+        LOGC("Could not wait on condition with timeout: %s", SDL_GetError());
+        abort();
+    }
+
+    mutex->locker = sc_thread_get_id();
+#endif
+    assert(r == 0 || r == SDL_MUTEX_TIMEDOUT);
+    return r == 0;
+}
+
+void
+sc_cond_signal(sc_cond *cond) {
+    int r = SDL_CondSignal(cond->cond);
+#ifndef NDEBUG
+    if (r) {
+        LOGC("Could not signal a condition: %s", SDL_GetError());
+        abort();
+    }
+#else
+    (void) r;
+#endif
+}
+
+void
+sc_cond_broadcast(sc_cond *cond) {
+    int r = SDL_CondBroadcast(cond->cond);
+#ifndef NDEBUG
+    if (r) {
+        LOGC("Could not broadcast a condition: %s", SDL_GetError());
+        abort();
+    }
+#else
+    (void) r;
+#endif
+}
--- a/app/src/util/thread.h
+++ b/app/src/util/thread.h
@ -0,0 +1,81 @@
+#ifndef SC_THREAD_H
+#define SC_THREAD_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+
+/* Forward declarations */
+typedef struct SDL_Thread SDL_Thread;
+typedef struct SDL_mutex SDL_mutex;
+typedef struct SDL_cond SDL_cond;
+
+typedef int sc_thread_fn(void *);
+typedef unsigned int sc_thread_id;
+
+typedef struct sc_thread {
+    SDL_Thread *thread;
+} sc_thread;
+
+typedef struct sc_mutex {
+    SDL_mutex *mutex;
+#ifndef NDEBUG
+    sc_thread_id locker;
+#endif
+} sc_mutex;
+
+typedef struct sc_cond {
+    SDL_cond *cond;
+} sc_cond;
+
+bool
+sc_thread_create(sc_thread *thread, sc_thread_fn fn, const char *name,
+                 void *userdata);
+
+void
+sc_thread_join(sc_thread *thread, int *status);
+
+bool
+sc_mutex_init(sc_mutex *mutex);
+
+void
+sc_mutex_destroy(sc_mutex *mutex);
+
+void
+sc_mutex_lock(sc_mutex *mutex);
+
+void
+sc_mutex_unlock(sc_mutex *mutex);
+
+sc_thread_id
+sc_thread_get_id(void);
+
+#ifndef NDEBUG
+bool
+sc_mutex_held(struct sc_mutex *mutex);
+# define sc_mutex_assert(mutex) assert(sc_mutex_held(mutex))
+#else
+# define sc_mutex_assert(mutex)
+#endif
+
+bool
+sc_cond_init(sc_cond *cond);
+
+void
+sc_cond_destroy(sc_cond *cond);
+
+void
+sc_cond_wait(sc_cond *cond, sc_mutex *mutex);
+
+// return true on signaled, false on timeout
+bool
+sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, uint32_t ms);
+
+void
+sc_cond_signal(sc_cond *cond);
+
+void
+sc_cond_broadcast(sc_cond *cond);
+
+#endif
--- a/app/src/video_buffer.c
+++ b/app/src/video_buffer.c
@ -1,12 +1,9 @@
 #include "video_buffer.h"

 #include <assert.h>
-#include <SDL2/SDL_mutex.h>
 #include <libavutil/avutil.h>
 #include <libavformat/avformat.h>

-#include "config.h"
-#include "util/lock.h"
 #include "util/log.h"

 bool
@ -14,22 +11,31 @@ video_buffer_init(struct video_buffer *vb, struct fps_counter *fps_counter,
                  bool render_expired_frames) {
    vb->fps_counter = fps_counter;

-    if (!(vb->decoding_frame = av_frame_alloc())) {
+    vb->decoding_frame = av_frame_alloc();
+    if (!vb->decoding_frame) {
        goto error_0;
    }

-    if (!(vb->rendering_frame = av_frame_alloc())) {
+    vb->pending_frame = av_frame_alloc();
+    if (!vb->pending_frame) {
        goto error_1;
    }

-    if (!(vb->mutex = SDL_CreateMutex())) {
+    vb->rendering_frame = av_frame_alloc();
+    if (!vb->rendering_frame) {
        goto error_2;
    }

+    bool ok = sc_mutex_init(&vb->mutex);
+    if (!ok) {
+        goto error_3;
+    }
+
    vb->render_expired_frames = render_expired_frames;
    if (render_expired_frames) {
-        if (!(vb->rendering_frame_consumed_cond = SDL_CreateCond())) {
-            SDL_DestroyMutex(vb->mutex);
+        ok = sc_cond_init(&vb->pending_frame_consumed_cond);
+        if (!ok) {
+            sc_mutex_destroy(&vb->mutex);
            goto error_2;
        }
        // interrupted is not used if expired frames are not rendered
@ -39,12 +45,14 @@ video_buffer_init(struct video_buffer *vb, struct fps_counter *fps_counter,

    // there is initially no rendering frame, so consider it has already been
    // consumed
-    vb->rendering_frame_consumed = true;
+    vb->pending_frame_consumed = true;

    return true;

-error_2:
+error_3:
    av_frame_free(&vb->rendering_frame);
+error_2:
+    av_frame_free(&vb->pending_frame);
 error_1:
    av_frame_free(&vb->decoding_frame);
 error_0:
@ -54,60 +62,78 @@ error_0:
 void
 video_buffer_destroy(struct video_buffer *vb) {
    if (vb->render_expired_frames) {
-        SDL_DestroyCond(vb->rendering_frame_consumed_cond);
+        sc_cond_destroy(&vb->pending_frame_consumed_cond);
    }
-    SDL_DestroyMutex(vb->mutex);
+    sc_mutex_destroy(&vb->mutex);
    av_frame_free(&vb->rendering_frame);
+    av_frame_free(&vb->pending_frame);
    av_frame_free(&vb->decoding_frame);
 }

 static void
-video_buffer_swap_frames(struct video_buffer *vb) {
+video_buffer_swap_decoding_frame(struct video_buffer *vb) {
+    sc_mutex_assert(&vb->mutex);
    AVFrame *tmp = vb->decoding_frame;
-    vb->decoding_frame = vb->rendering_frame;
-    vb->rendering_frame = tmp;
+    vb->decoding_frame = vb->pending_frame;
+    vb->pending_frame = tmp;
+}
+
+static void
+video_buffer_swap_rendering_frame(struct video_buffer *vb) {
+    sc_mutex_assert(&vb->mutex);
+    AVFrame *tmp = vb->rendering_frame;
+    vb->rendering_frame = vb->pending_frame;
+    vb->pending_frame = tmp;
 }

 void
 video_buffer_offer_decoded_frame(struct video_buffer *vb,
                                 bool *previous_frame_skipped) {
-    mutex_lock(vb->mutex);
+    sc_mutex_lock(&vb->mutex);
    if (vb->render_expired_frames) {
        // wait for the current (expired) frame to be consumed
-        while (!vb->rendering_frame_consumed && !vb->interrupted) {
-            cond_wait(vb->rendering_frame_consumed_cond, vb->mutex);
+        while (!vb->pending_frame_consumed && !vb->interrupted) {
+            sc_cond_wait(&vb->pending_frame_consumed_cond, &vb->mutex);
        }
-    } else if (!vb->rendering_frame_consumed) {
+    } else if (!vb->pending_frame_consumed) {
        fps_counter_add_skipped_frame(vb->fps_counter);
    }

-    video_buffer_swap_frames(vb);
+    video_buffer_swap_decoding_frame(vb);

-    *previous_frame_skipped = !vb->rendering_frame_consumed;
-    vb->rendering_frame_consumed = false;
+    *previous_frame_skipped = !vb->pending_frame_consumed;
+    vb->pending_frame_consumed = false;

-    mutex_unlock(vb->mutex);
+    sc_mutex_unlock(&vb->mutex);
 }

 const AVFrame *
-video_buffer_consume_rendered_frame(struct video_buffer *vb) {
-    assert(!vb->rendering_frame_consumed);
-    vb->rendering_frame_consumed = true;
+video_buffer_take_rendering_frame(struct video_buffer *vb) {
+    sc_mutex_lock(&vb->mutex);
+    assert(!vb->pending_frame_consumed);
+    vb->pending_frame_consumed = true;
+
    fps_counter_add_rendered_frame(vb->fps_counter);
+
+    video_buffer_swap_rendering_frame(vb);
+
    if (vb->render_expired_frames) {
        // unblock video_buffer_offer_decoded_frame()
-        cond_signal(vb->rendering_frame_consumed_cond);
+        sc_cond_signal(&vb->pending_frame_consumed_cond);
    }
+    sc_mutex_unlock(&vb->mutex);
+
+    // rendering_frame is only written from this thread, no need to lock
    return vb->rendering_frame;
 }

 void
 video_buffer_interrupt(struct video_buffer *vb) {
    if (vb->render_expired_frames) {
-        mutex_lock(vb->mutex);
+        sc_mutex_lock(&vb->mutex);
        vb->interrupted = true;
-        mutex_unlock(vb->mutex);
+        sc_mutex_unlock(&vb->mutex);
        // wake up blocking wait
-        cond_signal(vb->rendering_frame_consumed_cond);
+        sc_cond_signal(&vb->pending_frame_consumed_cond);
    }
 }
--- a/app/src/video_buffer.h
+++ b/app/src/video_buffer.h
@ -1,23 +1,45 @@
 #ifndef VIDEO_BUFFER_H
 #define VIDEO_BUFFER_H

-#include <stdbool.h>
-#include <SDL2/SDL_mutex.h>
+#include "common.h"
+
+#include <stdbool.h>

-#include "config.h"
 #include "fps_counter.h"
+#include "util/thread.h"

 // forward declarations
 typedef struct AVFrame AVFrame;

+/**
+ * There are 3 frames in memory:
+ *  - one frame is held by the decoder (decoding_frame)
+ *  - one frame is held by the renderer (rendering_frame)
+ *  - one frame is shared between the decoder and the renderer (pending_frame)
+ *
+ * The decoder decodes a packet into the decoding_frame (it may takes time).
+ *
+ * Once the frame is decoded, it calls video_buffer_offer_decoded_frame(),
+ * which swaps the decoding and pending frames.
+ *
+ * When the renderer is notified that a new frame is available, it calls
+ * video_buffer_take_rendering_frame() to retrieve it, which swaps the pending
+ * and rendering frames. The frame is valid until the next call, without
+ * blocking the decoder.
+ */
+
 struct video_buffer {
    AVFrame *decoding_frame;
+    AVFrame *pending_frame;
    AVFrame *rendering_frame;
-    SDL_mutex *mutex;
+
+    sc_mutex mutex;
    bool render_expired_frames;
    bool interrupted;
-    SDL_cond *rendering_frame_consumed_cond;
-    bool rendering_frame_consumed;
+
+    sc_cond pending_frame_consumed_cond;
+    bool pending_frame_consumed;
+
    struct fps_counter *fps_counter;
 };

@ -29,18 +51,15 @@ void
 video_buffer_destroy(struct video_buffer *vb);

 // set the decoded frame as ready for rendering
-// this function locks frames->mutex during its execution
 // the output flag is set to report whether the previous frame has been skipped
 void
 video_buffer_offer_decoded_frame(struct video_buffer *vb,
                                 bool *previous_frame_skipped);

 // mark the rendering frame as consumed and return it
-// MUST be called with frames->mutex locked!!!
-// the caller is expected to render the returned frame to some texture before
-// unlocking frames->mutex
+// the frame is valid until the next call to this function
 const AVFrame *
-video_buffer_consume_rendered_frame(struct video_buffer *vb);
+video_buffer_take_rendering_frame(struct video_buffer *vb);

 // wake up and avoid any blocking call
 void
--- a/app/tests/test_buffer_util.c
+++ b/app/tests/test_buffer_util.c
@ -1,3 +1,5 @@
+#include "common.h"
+
 #include <assert.h>

 #include "util/buffer_util.h"
--- a/app/tests/test_cbuf.c
+++ b/app/tests/test_cbuf.c
@ -1,3 +1,5 @@
+#include "common.h"
+
 #include <assert.h>
 #include <string.h>

--- a/app/tests/test_cli.c
+++ b/app/tests/test_cli.c
@ -1,8 +1,9 @@
+#include "common.h"
+
 #include <assert.h>
 #include <string.h>

 #include "cli.h"
-#include "common.h"
 #include "scrcpy.h"

 static void test_flag_version(void) {
--- a/app/tests/test_control_msg_serialize.c
+++ b/app/tests/test_control_msg_serialize.c
@ -1,3 +1,5 @@
+#include "common.h"
+
 #include <assert.h>
 #include <string.h>

@ -15,7 +17,7 @@ static void test_serialize_inject_keycode(void) {
    };

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

    const unsigned char expected[] = {
@ -37,7 +39,7 @@ static void test_serialize_inject_text(void) {
    };

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

    const unsigned char expected[] = {
@ -57,7 +59,7 @@ static void test_serialize_inject_text_long(void) {
    msg.inject_text.text = text;

    unsigned char buf[CONTROL_MSG_MAX_SIZE];
-    int size = control_msg_serialize(&msg, buf);
+    size_t size = control_msg_serialize(&msg, buf);
    assert(size == 5 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH);

    unsigned char expected[5 + CONTROL_MSG_INJECT_TEXT_MAX_LENGTH];
@ -93,7 +95,7 @@ static void test_serialize_inject_touch_event(void) {
    };

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

    const unsigned char expected[] = {
@ -128,7 +130,7 @@ static void test_serialize_inject_scroll_event(void) {
    };

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

    const unsigned char expected[] = {
@ -147,7 +149,7 @@ static void test_serialize_back_or_screen_on(void) {
    };

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

    const unsigned char expected[] = {
@ -162,7 +164,7 @@ static void test_serialize_expand_notification_panel(void) {
    };

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

    const unsigned char expected[] = {
@ -177,7 +179,7 @@ static void test_serialize_collapse_notification_panel(void) {
    };

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

    const unsigned char expected[] = {
@ -192,7 +194,7 @@ static void test_serialize_get_clipboard(void) {
    };

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

    const unsigned char expected[] = {
@ -211,7 +213,7 @@ static void test_serialize_set_clipboard(void) {
    };

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

    const unsigned char expected[] = {
@ -232,7 +234,7 @@ static void test_serialize_set_screen_power_mode(void) {
    };

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

    const unsigned char expected[] = {
@ -248,7 +250,7 @@ static void test_serialize_rotate_device(void) {
    };

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

    const unsigned char expected[] = {
--- a/app/tests/test_device_msg_deserialize.c
+++ b/app/tests/test_device_msg_deserialize.c
@ -1,3 +1,5 @@
+#include "common.h"
+
 #include <assert.h>
 #include <string.h>

--- a/app/tests/test_queue.c
+++ b/app/tests/test_queue.c
@ -1,3 +1,5 @@
+#include "common.h"
+
 #include <assert.h>

 #include "util/queue.h"
--- a/app/tests/test_strutil.c
+++ b/app/tests/test_strutil.c
@ -1,8 +1,9 @@
+#include "common.h"
+
 #include <assert.h>
 #include <limits.h>
 #include <stdio.h>
 #include <string.h>
-#include <SDL2/SDL.h>

 #include "util/str_util.h"

@ -136,7 +137,7 @@ static void test_strquote(void) {
    // add '"' at the beginning and the end
    assert(!strcmp("\"abcde\"", out));

-    SDL_free(out);
+    free(out);
 }

 static void test_utf8_truncate(void) {
--- a/build.gradle
+++ b/build.gradle
@ -7,7 +7,7 @@ buildscript {
        jcenter()
    }
    dependencies {
-        classpath 'com.android.tools.build:gradle:3.6.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/cross_win32.txt
+++ b/cross_win32.txt
@ -17,4 +17,4 @@ endian = 'little'
 [properties]
 prebuilt_ffmpeg_shared = 'ffmpeg-4.3.1-win32-shared'
 prebuilt_ffmpeg_dev = 'ffmpeg-4.3.1-win32-dev'
-prebuilt_sdl2 = 'SDL2-2.0.12/i686-w64-mingw32'
+prebuilt_sdl2 = 'SDL2-2.0.14/i686-w64-mingw32'
--- a/cross_win64.txt
+++ b/cross_win64.txt
@ -17,4 +17,4 @@ endian = 'little'
 [properties]
 prebuilt_ffmpeg_shared = 'ffmpeg-4.3.1-win64-shared'
 prebuilt_ffmpeg_dev = 'ffmpeg-4.3.1-win64-dev'
-prebuilt_sdl2 = 'SDL2-2.0.12/x86_64-w64-mingw32'
+prebuilt_sdl2 = 'SDL2-2.0.14/x86_64-w64-mingw32'
--- a/data/scrcpy-console.bat
+++ b/data/scrcpy-console.bat
@ -0,0 +1,4 @@
+@echo off
+scrcpy.exe %*
+:: if the exit code is >= 1, then pause
+if errorlevel 1 pause
--- a/data/scrcpy-noconsole.vbs
+++ b/data/scrcpy-noconsole.vbs
@ -0,0 +1 @@
+CreateObject("Wscript.Shell").Run "cmd /c scrcpy.exe", 0, false
--- a/meson.build
+++ b/meson.build
@ -1,5 +1,5 @@
 project('scrcpy', 'c',
-        version: '1.16',
+        version: '1.17',
        meson_version: '>= 0.48',
        default_options: [
            'c_std=c11',
--- a/meson_options.txt
+++ b/meson_options.txt
@ -1,7 +1,6 @@
 option('compile_app', type: 'boolean', value: true, description: 'Build the client')
 option('compile_server', type: 'boolean', value: true, description: 'Build the server')
 option('crossbuild_windows', type: 'boolean', value: false, description: 'Build for Windows from Linux')
-option('windows_noconsole', type: 'boolean', value: false, description: 'Disable console on Windows (pass -mwindows flag)')
 option('prebuilt_server', type: 'string', description: 'Path of the prebuilt server')
 option('portable', type: 'boolean', value: false, description: 'Use scrcpy-server from the same directory as the scrcpy executable')
 option('hidpi_support', type: 'boolean', value: true, description: 'Enable High DPI support')
--- a/prebuilt-deps/Makefile
+++ b/prebuilt-deps/Makefile
@ -10,31 +10,31 @@ prepare-win32: prepare-sdl2 prepare-ffmpeg-shared-win32 prepare-ffmpeg-dev-win32
 prepare-win64: prepare-sdl2 prepare-ffmpeg-shared-win64 prepare-ffmpeg-dev-win64 prepare-adb

 prepare-ffmpeg-shared-win32:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/shared/ffmpeg-4.3.1-win32-shared.zip \
+	@./prepare-dep https://github.com/Genymobile/scrcpy/releases/download/v1.16/ffmpeg-4.3.1-win32-shared.zip \
 		357af9901a456f4dcbacd107e83a934d344c9cb07ddad8aaf80612eeab7d26d2 \
 		ffmpeg-4.3.1-win32-shared

 prepare-ffmpeg-dev-win32:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win32/dev/ffmpeg-4.3.1-win32-dev.zip \
+	@./prepare-dep https://github.com/Genymobile/scrcpy/releases/download/v1.16/ffmpeg-4.3.1-win32-dev.zip \
 		230efb08e9bcf225bd474da29676c70e591fc94d8790a740ca801408fddcb78b \
 		ffmpeg-4.3.1-win32-dev

 prepare-ffmpeg-shared-win64:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/shared/ffmpeg-4.3.1-win64-shared.zip \
+	@./prepare-dep https://github.com/Genymobile/scrcpy/releases/download/v1.16/ffmpeg-4.3.1-win64-shared.zip \
 		dd29b7f92f48dead4dd940492c7509138c0f99db445076d0a597007298a79940 \
 		ffmpeg-4.3.1-win64-shared

 prepare-ffmpeg-dev-win64:
-	@./prepare-dep https://ffmpeg.zeranoe.com/builds/win64/dev/ffmpeg-4.3.1-win64-dev.zip \
+	@./prepare-dep https://github.com/Genymobile/scrcpy/releases/download/v1.16/ffmpeg-4.3.1-win64-dev.zip \
 		2e8038242cf8e1bd095c2978f196ff0462b122cc6ef7e74626a6af15459d8b81 \
 		ffmpeg-4.3.1-win64-dev

 prepare-sdl2:
-	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.12-mingw.tar.gz \
-		e614a60f797e35ef9f3f96aef3dc6a1d786de3cc7ca6216f97e435c0b6aafc46 \
-		SDL2-2.0.12
+	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.14-mingw.tar.gz \
+		405eaff3eb18f2e08fe669ef9e63bc9a8710b7d343756f238619761e9b60407d \
+		SDL2-2.0.14

 prepare-adb:
-	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r30.0.4-windows.zip \
-		413182fff6c5957911e231b9e97e6be4fc6a539035e3dfb580b5c54bd5950fee \
+	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r30.0.5-windows.zip \
+		549ba2bdc31f335eb8a504f005f77606a479cc216d6b64a3e8b64c780003661f \
 		platform-tools
--- a/Makefile.CrossWindows
+++ b/Makefile.CrossWindows
@ -9,21 +9,20 @@
 # the server to the device.

 .PHONY: default clean \
+	test \
 	build-server \
 	prepare-deps-win32 prepare-deps-win64 \
-	build-win32 build-win32-noconsole \
-	build-win64 build-win64-noconsole \
+	build-win32 build-win64 \
 	dist-win32 dist-win64 \
 	zip-win32 zip-win64 \
-	sums release
+	release

 GRADLE ?= ./gradlew

+TEST_BUILD_DIR := build-test
 SERVER_BUILD_DIR := build-server
 WIN32_BUILD_DIR := build-win32
-WIN32_NOCONSOLE_BUILD_DIR := build-win32-noconsole
 WIN64_BUILD_DIR := build-win64
-WIN64_NOCONSOLE_BUILD_DIR := build-win64-noconsole

 DIST := dist
 WIN32_TARGET_DIR := scrcpy-win32
@ -33,19 +32,35 @@ VERSION := $(shell git describe --tags --always)
 WIN32_TARGET := $(WIN32_TARGET_DIR)-$(VERSION).zip
 WIN64_TARGET := $(WIN64_TARGET_DIR)-$(VERSION).zip

-release: clean zip-win32 zip-win64 sums
-	@echo "Windows archives generated in $(DIST)/"
+RELEASE_DIR := release-$(VERSION)
+
+release: clean test build-server zip-win32 zip-win64
+	mkdir -p "$(RELEASE_DIR)"
+	cp "$(SERVER_BUILD_DIR)/server/scrcpy-server" \
+		"$(RELEASE_DIR)/scrcpy-server-$(VERSION)"
+	cp "$(DIST)/$(WIN32_TARGET)" "$(RELEASE_DIR)"
+	cp "$(DIST)/$(WIN64_TARGET)" "$(RELEASE_DIR)"
+	cd "$(RELEASE_DIR)" && \
+		sha256sum "scrcpy-server-$(VERSION)" \
+			"scrcpy-win32-$(VERSION).zip" \
+			"scrcpy-win64-$(VERSION).zip" > SHA256SUMS.txt
+	@echo "Release generated in $(RELEASE_DIR)/"

 clean:
 	$(GRADLE) clean
-	rm -rf "$(SERVER_BUILD_DIR)" "$(WIN32_BUILD_DIR)" "$(WIN64_BUILD_DIR)" \
-		   "$(WIN32_NOCONSOLE_BUILD_DIR)" "$(WIN64_NOCONSOLE_BUILD_DIR)" "$(DIST)"
+	rm -rf "$(DIST)" "$(TEST_BUILD_DIR)" "$(SERVER_BUILD_DIR)" \
+		"$(WIN32_BUILD_DIR)" "$(WIN64_BUILD_DIR)"
+
+test:
+	[ -d "$(TEST_BUILD_DIR)" ] || ( mkdir "$(TEST_BUILD_DIR)" && \
+		meson "$(TEST_BUILD_DIR)" -Db_sanitize=address )
+	ninja -C "$(TEST_BUILD_DIR)"
+	$(GRADLE) -p server check

 build-server:
 	[ -d "$(SERVER_BUILD_DIR)" ] || ( mkdir "$(SERVER_BUILD_DIR)" && \
-		meson "$(SERVER_BUILD_DIR)" \
-			--buildtype release -Dcompile_app=false )
-		ninja -C "$(SERVER_BUILD_DIR)"
+		meson "$(SERVER_BUILD_DIR)" --buildtype release -Dcompile_app=false )
+	ninja -C "$(SERVER_BUILD_DIR)"

 prepare-deps-win32:
 	-$(MAKE) -C prebuilt-deps prepare-win32
@ -60,17 +75,6 @@ build-win32: prepare-deps-win32
 			-Dportable=true )
 	ninja -C "$(WIN32_BUILD_DIR)"

-build-win32-noconsole: prepare-deps-win32
-	[ -d "$(WIN32_NOCONSOLE_BUILD_DIR)" ] || ( mkdir "$(WIN32_NOCONSOLE_BUILD_DIR)" && \
-		meson "$(WIN32_NOCONSOLE_BUILD_DIR)" \
-			--cross-file cross_win32.txt \
-			--buildtype release --strip -Db_lto=true \
-			-Dcrossbuild_windows=true \
-			-Dcompile_server=false \
-			-Dwindows_noconsole=true \
-			-Dportable=true )
-	ninja -C "$(WIN32_NOCONSOLE_BUILD_DIR)"
-
 prepare-deps-win64:
 	-$(MAKE) -C prebuilt-deps prepare-win64

@ -84,22 +88,12 @@ build-win64: prepare-deps-win64
 			-Dportable=true )
 	ninja -C "$(WIN64_BUILD_DIR)"

-build-win64-noconsole: prepare-deps-win64
-	[ -d "$(WIN64_NOCONSOLE_BUILD_DIR)" ] || ( mkdir "$(WIN64_NOCONSOLE_BUILD_DIR)" && \
-		meson "$(WIN64_NOCONSOLE_BUILD_DIR)" \
-			--cross-file cross_win64.txt \
-			--buildtype release --strip -Db_lto=true \
-			-Dcrossbuild_windows=true \
-			-Dcompile_server=false \
-			-Dwindows_noconsole=true \
-			-Dportable=true )
-	ninja -C "$(WIN64_NOCONSOLE_BUILD_DIR)"
-
-dist-win32: build-server build-win32 build-win32-noconsole
+dist-win32: build-server build-win32
 	mkdir -p "$(DIST)/$(WIN32_TARGET_DIR)"
 	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp "$(WIN32_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp "$(WIN32_NOCONSOLE_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN32_TARGET_DIR)/scrcpy-noconsole.exe"
+	cp data/scrcpy-console.bat "$(DIST)/$(WIN32_TARGET_DIR)"
+	cp data/scrcpy-noconsole.vbs "$(DIST)/$(WIN32_TARGET_DIR)"
 	cp prebuilt-deps/ffmpeg-4.3.1-win32-shared/bin/avutil-56.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.3.1-win32-shared/bin/avcodec-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.3.1-win32-shared/bin/avformat-58.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
@ -108,13 +102,14 @@ dist-win32: build-server build-win32 build-win32-noconsole
 	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
-	cp prebuilt-deps/SDL2-2.0.12/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"
+	cp prebuilt-deps/SDL2-2.0.14/i686-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN32_TARGET_DIR)/"

-dist-win64: build-server build-win64 build-win64-noconsole
+dist-win64: build-server build-win64
 	mkdir -p "$(DIST)/$(WIN64_TARGET_DIR)"
 	cp "$(SERVER_BUILD_DIR)"/server/scrcpy-server "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp "$(WIN64_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp "$(WIN64_NOCONSOLE_BUILD_DIR)"/app/scrcpy.exe "$(DIST)/$(WIN64_TARGET_DIR)/scrcpy-noconsole.exe"
+	cp data/scrcpy-console.bat "$(DIST)/$(WIN64_TARGET_DIR)"
+	cp data/scrcpy-noconsole.vbs "$(DIST)/$(WIN64_TARGET_DIR)"
 	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/avutil-56.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/avcodec-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/ffmpeg-4.3.1-win64-shared/bin/avformat-58.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
@ -123,7 +118,7 @@ dist-win64: build-server build-win64 build-win64-noconsole
 	cp prebuilt-deps/platform-tools/adb.exe "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
 	cp prebuilt-deps/platform-tools/AdbWinUsbApi.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
-	cp prebuilt-deps/SDL2-2.0.12/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"
+	cp prebuilt-deps/SDL2-2.0.14/x86_64-w64-mingw32/bin/SDL2.dll "$(DIST)/$(WIN64_TARGET_DIR)/"

 zip-win32: dist-win32
 	cd "$(DIST)/$(WIN32_TARGET_DIR)"; \
@ -132,7 +127,3 @@ zip-win32: dist-win32
 zip-win64: dist-win64
 	cd "$(DIST)/$(WIN64_TARGET_DIR)"; \
 		zip -r "../$(WIN64_TARGET)" .
-
-sums:
-	cd "$(DIST)"; \
-		sha256sum *.zip > SHA256SUMS.txt
--- a/release.sh
+++ b/release.sh
@ -1,44 +1,2 @@
 #!/bin/bash
-set -e
-
-# test locally
-TESTDIR=build_test
-rm -rf "$TESTDIR"
-# run client tests with ASAN enabled
-meson "$TESTDIR" -Db_sanitize=address
-ninja -C"$TESTDIR" test
-
-# test server
-GRADLE=${GRADLE:-./gradlew}
-$GRADLE -p server check
-
-BUILDDIR=build_release
-rm -rf "$BUILDDIR"
-meson "$BUILDDIR" --buildtype release --strip -Db_lto=true
-cd "$BUILDDIR"
-ninja
-cd -
-
-# build Windows releases
-make -f Makefile.CrossWindows
-
-# the generated server must be the same everywhere
-cmp "$BUILDDIR/server/scrcpy-server" dist/scrcpy-win32/scrcpy-server
-cmp "$BUILDDIR/server/scrcpy-server" dist/scrcpy-win64/scrcpy-server
-
-# get version name
-TAG=$(git describe --tags --always)
-
-# create release directory
-mkdir -p "release-$TAG"
-cp "$BUILDDIR/server/scrcpy-server" "release-$TAG/scrcpy-server-$TAG"
-cp "dist/scrcpy-win32-$TAG.zip" "release-$TAG/"
-cp "dist/scrcpy-win64-$TAG.zip" "release-$TAG/"
-
-# generate checksums
-cd "release-$TAG"
-sha256sum "scrcpy-server-$TAG" \
-          "scrcpy-win32-$TAG.zip" \
-          "scrcpy-win64-$TAG.zip" > SHA256SUMS.txt
-
-echo "Release generated in release-$TAG/"
+make -f release.mk
--- a/server/build.gradle
+++ b/server/build.gradle
@ -6,8 +6,8 @@ android {
        applicationId "com.genymobile.scrcpy"
        minSdkVersion 21
        targetSdkVersion 30
-        versionCode 19
-        versionName "1.16"
+        versionCode 20
+        versionName "1.17"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
@ -20,7 +20,7 @@ android {

 dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
-    testImplementation 'junit:junit:4.12'
+    testImplementation 'junit:junit:4.13'
 }

 apply from: "$project.rootDir/config/android-checkstyle.gradle"
--- a/server/build_without_gradle.sh
+++ b/server/build_without_gradle.sh
@ -12,7 +12,7 @@
 set -e

 SCRCPY_DEBUG=false
-SCRCPY_VERSION_NAME=1.16
+SCRCPY_VERSION_NAME=1.17

 PLATFORM=${ANDROID_PLATFORM:-30}
 BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-30.0.0}
--- a/server/src/main/java/com/genymobile/scrcpy/Server.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Server.java
@ -58,12 +58,14 @@ public final class Server {
            ScreenEncoder screenEncoder = new ScreenEncoder(options.getSendFrameMeta(), options.getBitRate(), options.getMaxFps(), codecOptions,
                    options.getEncoderName());

+            Thread controllerThread = null;
+            Thread deviceMessageSenderThread = null;
            if (options.getControl()) {
                final Controller controller = new Controller(device, connection);

                // asynchronous
-                startController(controller);
-                startDeviceMessageSender(controller.getSender());
+                controllerThread = startController(controller);
+                deviceMessageSenderThread = startDeviceMessageSender(controller.getSender());

                device.setClipboardListener(new Device.ClipboardListener() {
                    @Override
@ -79,12 +81,19 @@ public final class Server {
            } catch (IOException e) {
                // this is expected on close
                Ln.d("Screen streaming stopped");
+            } finally {
+                if (controllerThread != null) {
+                    controllerThread.interrupt();
+                }
+                if (deviceMessageSenderThread != null) {
+                    deviceMessageSenderThread.interrupt();
+                }
            }
        }
    }

-    private static void startController(final Controller controller) {
-        new Thread(new Runnable() {
+    private static Thread startController(final Controller controller) {
+        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
@ -94,11 +103,13 @@ public final class Server {
                    Ln.d("Controller stopped");
                }
            }
-        }).start();
+        });
+        thread.start();
+        return thread;
    }

-    private static void startDeviceMessageSender(final DeviceMessageSender sender) {
-        new Thread(new Runnable() {
+    private static Thread startDeviceMessageSender(final DeviceMessageSender sender) {
+        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
@ -108,7 +119,9 @@ public final class Server {
                    Ln.d("Device message sender stopped");
                }
            }
-        }).start();
+        });
+        thread.start();
+        return thread;
    }

    private static Options createOptions(String... args) {
Author	SHA1	Message	Date
Romain Vimont	ba09254b38	refilter_on_resize	2021-02-12 23:26:39 +01:00
Romain Vimont	03cc0cf543	swscalewip	2021-02-12 23:26:39 +01:00
Romain Vimont	f6570a7a41	scale_filter	2021-02-12 23:20:26 +01:00
Romain Vimont	87e3ad7756	Handle window events only once visible This will avoid corner cases where we need to resize while no frame has been received yet.	2021-02-12 23:20:26 +01:00
Romain Vimont	c6de5b0a15	Log mipmaps error only if mipmaps were requested	2021-02-12 22:04:50 +01:00
Romain Vimont	0b4b4609dc	Extract texture management to a separate file Move texture management out of screen.c, which already handles the window and the rendering. This paves the way to implement optional software filtering (swscale) properly, as an alternative to mipmaps (which are not available everywhere).	2021-02-12 21:58:38 +01:00
Romain Vimont	edf710af3c	Make use_opengl local The flag is used only locally, there is no need to store it in the screen structure.	2021-02-07 19:12:14 +01:00
Romain Vimont	46bf4d55a7	Add intermediate frame in video buffer There were only two frames simultaneously: - one used by the decoder; - one used by the renderer. When the decoder finished decoding a frame, it swapped it with the rendering frame. Adding a third frame provides several benefits: - the decoder do not have to wait for the renderer to release the mutex; - it simplifies the video_buffer API; - it makes the rendering frame valid until the next call to video_buffer_take_rendering_frame(), which will be useful for swscaling on window resize.	2021-02-05 17:28:26 +01:00
Romain Vimont	017036ddab	Assert non-recursive usage of mutexes	2021-02-05 17:27:26 +01:00
Romain Vimont	a9582b1d43	Add mutex assertions	2021-02-04 08:12:22 +01:00
Romain Vimont	fa3e84b700	Expose mutex assertions Add a function to assert that the mutex is held (or not).	2021-02-04 08:12:22 +01:00
Romain Vimont	1521de9051	Expose thread id	2021-02-04 08:12:22 +01:00
Romain Vimont	eabaabdb78	Wrap SDL thread functions into scrcpy-specific API The goal is to expose a consistent API for system tools, and paves the way to make the "core" independant of SDL in the future.	2021-02-04 08:12:22 +01:00
Romain Vimont	8b48003074	Replace SDL_strdup() by strdup() The functions SDL_malloc(), SDL_free() and SDL_strdup() were used only because strdup() was not available everywhere. Now that it is available, use the native version of these functions.	2021-02-04 08:12:22 +01:00
Romain Vimont	74bd25a0ed	Provide strdup() compat Make strdup() available on all platforms.	2021-02-04 08:12:22 +01:00
Romain Vimont	97b001e7c0	Fix undefined left shift Small unsigned integers promote to signed int. As a consequence, if v is a uint8_t, then (v << 24) yields an int, so the left shift is undefined if the MSB is 1. Cast to uint32_t to yield an unsigned value. Reported by USAN (meson x -Db_sanitize=undefined): runtime error: left shift of 255 by 24 places cannot be represented in type 'int'	2021-01-24 15:31:21 +01:00
Romain Vimont	d8e9ad20b0	Improve file handler error message Terminating the file handler current process may be either a "push" or "install" command.	2021-01-24 14:24:24 +01:00
Romain Vimont	b566700bfd	Kill process with SIGKILL signal An "adb push" command is not terminated by SIGTERM.	2021-01-24 14:24:24 +01:00
Romain Vimont	7afd149f4b	Fix file_handler process race condition The current process could be waited both by run_file_handler() and file_handler_stop(). To avoid the race condition, wait the process without closing, then close with mutex locked.	2021-01-24 14:24:24 +01:00
Romain Vimont	6a50231698	Expose a single process_wait() There were two versions: process_wait() and process_wait_noclose(). Expose a single version with a flag (it was already implemented that way internally).	2021-01-24 14:24:18 +01:00
Romain Vimont	b8edcf52b0	Simplify process_wait() The function process_wait() returned a bool (true if the process terminated successfully) and provided the exit code via an output parameter exit_code. But the returned value was always equivalent to exit_code == 0, so just return the exit code instead.	2021-01-22 18:29:21 +01:00
Romain Vimont	94eff0a4bb	Fix size_t incorrectly assigned to int The function control_msg_serialize() returns a size_t.	2021-01-17 19:44:23 +01:00
Romain Vimont	8dbb1676b7	Factorize meson compiler variable initialization	2021-01-17 19:44:23 +01:00
Romain Vimont	ab912c23e7	Define feature test macros in common.h This enables necessary functions once for all. As a consequence, define common.h before any other header.	2021-01-17 14:08:48 +01:00
Romain Vimont	59feb2a15c	Group common includes into common.h Include config.h and compat.h in common.h, and include common.h from all source files.	2021-01-08 19:22:10 +01:00
Romain Vimont	6385b8c162	Move common structs to coords.h The size, point and position structs were defined in common.h. Move them to coords.h so that common.h could be used for generic code to be included in all source files.	2021-01-08 19:22:10 +01:00
Romain Vimont	037be4af21	Fix compat missing include The header libavformat/version.h was included, but not libavcodec/version.h. As a consequence, the LIBAVCODEC_VERSION_INT definition depended on the caller includes.	2021-01-08 19:21:54 +01:00
Romain Vimont	1e215199dc	Remove unused struct port_range It had been replaced by struct sc_port_range in scrcpy.h.	2021-01-08 19:13:53 +01:00
Romain Vimont	d580ee30f1	Separate process wait and close On Linux, waitpid() both waits for the process to terminate and reaps it (closes its handle). On Windows, these actions are separated into WaitForSingleObject() and CloseHandle(). Expose these actions separately, so that it is possible to send a signal to a process while waiting for its termination without race condition. This allows to wait for server termination normally, but kill the process without race condition if it is not terminated after some delay.	2021-01-08 16:44:21 +01:00
Romain Vimont	821c175730	Rename process_simple_wait to process_wait Adding "simple" in the function name brings no benefit.	2021-01-08 16:44:21 +01:00
Romain Vimont	cc6f5020d8	Move conditional src files in meson.build Declare all the source files (including the platform-specific ones) at the beginning.	2021-01-08 16:44:21 +01:00
Romain Vimont	4bd9da4c93	Split command into process and adb The process API provides the system-specific implementation, the adb API uses it to expose adb commands.	2021-01-08 16:44:21 +01:00
Romain Vimont	aa8b571389	Increase display id range Some devices use big display id values. Refs #2009 <https://github.com/Genymobile/scrcpy/issues/2009>	2021-01-04 08:16:32 +01:00
Romain Vimont	ed130e05d5	Fix possibly uninitialized value Due to gotos, "ret" may be returned uninitialized.	2021-01-03 22:41:51 +01:00
clesiemo3	192fbd8450	Use --cask for latest versions of brew PR #2004 <https://github.com/Genymobile/scrcpy/pull/2004> Signed-off-by: Romain Vimont <rom@rom1v.com>	2021-01-02 18:27:38 +01:00
Romain Vimont	c5c5fc18ae	Update links to v1.17 in README and BUILD	2021-01-02 01:26:23 +01:00
Romain Vimont	f682b87ba5	Bump version to 1.17	2021-01-02 00:53:32 +01:00
Romain Vimont	10b749e27d	Kill the server only after a small delay Let the server terminate properly once all the sockets are closed. If it does not terminate (this can happen if the device is asleep), then kill it. Note: since the server process termination is detected by a flag set after waitpid() returns, there is a small chance that the process terminates (and the PID assigned to a new process) before the flag is set but before the kill() call. This race condition already existed before this commit. Fixes #1992 <https://github.com/Genymobile/scrcpy/issues/1992>	2021-01-01 23:57:01 +01:00
Romain Vimont	05e8c1a3c5	Call CloseHandle() after wait on Windows TerminateProcess() is "equivalent" to kill(), while WaitForSingleObject() is "equivalent" to waitpid(), so the handle must be closed after WaitForSingleObject().	2021-01-01 23:57:01 +01:00
Romain Vimont	83910d3b9c	Initialize server struct dynamically This will allow to add mutex/cond fields.	2021-01-01 17:40:52 +01:00
Romain Vimont	90f8356630	Interrupt device threads on stop The (non-daemon) threads were not interrupted on video stream stopped, leaving the server process alive. Interrupt them to wake up their blocking call so that they terminate properly. Refs #1992 <https://github.com/Genymobile/scrcpy/issues/1992>	2021-01-01 17:32:34 +01:00
Romain Vimont	3ba51211d6	Mention how to add default arguments on Windows Mention that it is possible to add default arguments by editing the wrapper scripts.	2021-01-01 17:31:07 +01:00
Romain Vimont	ea3582d2c3	Merge branch 'master' into dev	2021-01-01 17:18:13 +01:00
Romain Vimont	112adbba87	Happy new year 2021!	2021-01-01 17:16:44 +01:00
Romain Vimont	d039a7a39a	Upgrade SDL (2.0.14) for Windows Include the latest version of SDL in Windows releases.	2021-01-01 16:08:58 +01:00
Romain Vimont	6ab80e4ce8	Rename release.make to release.mk It's more standard, and benefits from syntax coloration in vi.	2021-01-01 15:51:10 +01:00
Romain Vimont	230afd8966	Unify release makefile Before this change, release.sh built some native stuff, and Makefile.CrossWindows built the Windows releases. Instead, use a single release.make to build the whole release. It also avoids to build the server one more time.	2020-12-22 18:52:05 +01:00
Romain Vimont	a46733906a	Replace noconsole binary by a wrapper script This simplifies the build system. Refs <https://github.com/Genymobile/scrcpy/issues/1975#issuecomment-745314161>	2020-12-22 18:51:59 +01:00
Romain Vimont	431c9ee33b	Improve rotation documentation	2020-12-22 01:48:01 +01:00
Romain Vimont	43d3dcbd97	Document Windows command line usage PR #1973 <https://github.com/Genymobile/scrcpy/pull/1973> Reviewed-by: Yu-Chen Lin <npes87184@gmail.com>	2020-12-22 01:44:55 +01:00
Romain Vimont	a5f4f58295	Remove duplicate include	2020-12-22 01:14:30 +01:00
Romain Vimont	ea12783bbc	Upgrade JUnit to 4.13	2020-12-17 10:53:35 +01:00
Romain Vimont	904d470579	Pause on error from a wrapper script On Windows, scrcpy paused on error before exiting to give the user a chance to see the user message. This was a hack and causes issues when using scrcpy from batch scripts. Disable this pause from the scrcpy binary, and provide a batch wrapper (scrcpy-console.bat) to pause on error. Fixes #1875 <https://github.com/Genymobile/scrcpy/issues/1875>	2020-12-14 09:44:17 +01:00
Romain Vimont	6d151eaef9	Reference encoder section from FAQ	2020-12-14 09:04:14 +01:00
Romain Vimont	5dc3285dbf	Reference FFmpeg Windows builds from GitHub Refs #1753 <https://github.com/Genymobile/scrcpy/issues/1753>	2020-12-12 16:26:08 +01:00
Romain Vimont	c9a4bdb890	Upgrade platform-tools (30.0.5) for Windows Include the latest version of adb in Windows releases.	2020-12-12 15:56:32 +01:00
Romain Vimont	d60ac65b32	Merge branch 'master' into dev	2020-12-12 15:55:29 +01:00
jianzhang4	d6078cf202	Fix build errors for macOS PR #1960 <https://github.com/Genymobile/scrcpy/pull/1960> Signed-off-by: Romain Vimont <rom@rom1v.com>	2020-12-12 15:50:33 +01:00
SamBe.ng	47c8971267	Document shell command to get the device IP PR #1944 <https://github.com/Genymobile/scrcpy/pull/1944> Signed-off-by: Romain Vimont <rom@rom1v.com>	2020-12-10 21:37:23 +01:00
Romain Vimont	30434afc0a	Upgrade gradle build tools to 4.0.1	2020-11-24 09:45:18 +01:00
Romain Vimont	868e762d71	Fix size_t format specifier for Windows Use "%Iu" on Windows. This fixes the following warning: ../app/src/sys/win/command.c:17:14: warning: unknown conversion type character ‘l’ in format [-Wformat=] 17 \| LOGE("Command too long (%" PRIsizet " chars)", len - 1);	2020-11-14 22:10:11 +01:00
Romain Vimont	25aff00935	Mention version of Indonesian translation	2020-10-05 21:24:59 +02:00
yanuarakhid	aade92fd10	Add Indonesian translation for README.md PR #1802 <https://github.com/Genymobile/scrcpy/pull/1802> Signed-off-by: Romain Vimont <rom@rom1v.com>	2020-10-05 21:17:43 +02:00
redev	15b81367c9	Fix FAQ.ko.md PR #1767 <https://github.com/Genymobile/scrcpy/pull/1767> Signed-off-by: Romain Vimont <rom@rom1v.com>	2020-10-01 14:57:09 +02:00
Win7GM	c136edf09d	Add simplified Chinese translation for README.md PR #1723 <https://github.com/Genymobile/scrcpy/pull/1723> Co-authored-by: Shaw Yu <shawyu.nz@gmail.com> Signed-off-by: Romain Vimont <rom@rom1v.com>	2020-09-17 13:09:43 +02:00
Romain Vimont	52560faa34	Fix README indentation	2020-09-17 13:03:40 +02:00
				`@ -0,0 +1 @@`
				`CreateObject("Wscript.Shell").Run "cmd /c scrcpy.exe", 0, false`