Mention adb wireless option for Android 11+

Add a paragraph about toggling an option to bypass having to physically connect the device to the user's computer. Signed-off-by: Romain Vimont <rom@rom1v.com>
Make step more explicit in wireless section
2021-08-12 19:05:25 +02:00 · 2021-08-12 19:05:18 +02:00 · 2021-08-12 18:53:53 +02:00 · 2021-08-12 18:46:07 +02:00 · 2021-08-12 18:45:07 +02:00 · 2021-08-12 18:43:07 +02:00
38 changed files with 1078 additions and 1048 deletions
--- a/DEVELOP.md
+++ b/DEVELOP.md
@@ -76,7 +76,7 @@ The server uses 3 threads:
 - the **main** thread, encoding and streaming the video to the client;
 - the **controller** thread, listening for _control messages_ (typically,
   keyboard and mouse events) from the client;
- - the **receiver** thread (managed by the controller), sending _device messges_
+ - the **receiver** thread (managed by the controller), sending _device messages_
   to the clients (currently, it is only used to send the device clipboard
   content).

--- a/README.md
+++ b/README.md
@@ -318,25 +318,7 @@ vlc v4l2:///dev/videoN   # VLC might add some buffering delay

 For example, you could capture the video within [OBS].

-[OBS]: https://obsproject.com/fr
-
-
-#### Buffering
-
-It is possible to add buffering. This increases latency but reduces jitter (see
-#2464).
-
-The option is available for display buffering:
-
-```bash
-scrcpy --display-buffer=50  # add 50 ms buffering for display
-```
-
-and V4L2 sink:
-
-```bash
-scrcpy --v4l2-buffer=500    # add 500 ms buffering for v4l2 sink
-```
+[OBS]: https://obsproject.com/


 ### Connection
@@ -346,18 +328,30 @@ scrcpy --v4l2-buffer=500    # add 500 ms buffering for v4l2 sink
 _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, or by
+1. Plug the device into a USB port on your computer.
+2. Connect the device to the same Wi-Fi network as your computer.
+3. 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`)_.
-6. Run `scrcpy` as usual.
+4. Enable adb over TCP/IP on your device: `adb tcpip 5555`.
+5. Unplug your device.
+6. Connect to your device: `adb connect DEVICE_IP:5555` _(replace `DEVICE_IP`
+with the device IP address you found)_.
+7. Run `scrcpy` as usual.
+
+Since Android 11, a [Wireless debugging option][adb-wireless] allows to bypass
+having to physically connect your device directly to your computer.
+
+[adb-wireless]: https://developer.android.com/studio/command-line/adb#connect-to-a-device-over-wi-fi-android-11+
+
+If the connection randomly drops, run your `scrcpy` command to reconnect. If it
+says there are no devices/emulators found, try running `adb connect
+DEVICE_IP:5555` again, and then `scrcpy` as usual. If it still says there are
+none found, try running `adb disconnect` and then run those two commands again.

 It may be useful to decrease the bit-rate and the definition:

@@ -893,5 +887,6 @@ This README is available in other languages:
 - [Español (Spanish, `sp`) - v1.17](README.sp.md)
 - [简体中文 (Simplified Chinese, `zh-Hans`) - v1.17](README.zh-Hans.md)
 - [繁體中文 (Traditional Chinese, `zh-Hant`) - v1.15](README.zh-Hant.md)
+- [Turkish (Turkish, `tr`) - v1.18](README.tr.md)

 Only this README file is guaranteed to be up-to-date.
--- a/README.tr.md
+++ b/README.tr.md
@@ -0,0 +1,824 @@
+# scrcpy (v1.18)
+
+Bu uygulama Android cihazların USB (ya da [TCP/IP][article-tcpip]) üzerinden
+görüntülenmesini ve kontrol edilmesini sağlar. _root_ erişimine ihtiyaç duymaz.
+_GNU/Linux_, _Windows_ ve _macOS_ sistemlerinde çalışabilir.
+
+![screenshot](assets/screenshot-debian-600.jpg)
+
+Öne çıkan özellikler:
+
+- **hafiflik** (doğal, sadece cihazın ekranını gösterir)
+- **performans** (30~60fps)
+- **kalite** (1920×1080 ya da üzeri)
+- **düşük gecikme süresi** ([35~70ms][lowlatency])
+- **düşük başlangıç süresi** (~1 saniye ilk kareyi gösterme süresi)
+- **müdaheleci olmama** (cihazda kurulu yazılım kalmaz)
+
+[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
+
+## Gereksinimler
+
+Android cihaz en düşük API 21 (Android 5.0) olmalıdır.
+
+[Adb hata ayıklamasının][enable-adb] cihazınızda aktif olduğundan emin olun.
+
+[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
+
+Bazı cihazlarda klavye ve fare ile kontrol için [ilave bir seçenek][control] daha
+etkinleştirmeniz gerekebilir.
+
+[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
+
+## Uygulamayı indirin
+
+<a href="https://repology.org/project/scrcpy/versions"><img src="https://repology.org/badge/vertical-allrepos/scrcpy.svg" alt="Packaging status" align="right"></a>
+
+### Özet
+
+- Linux: `apt install scrcpy`
+- Windows: [indir][direct-win64]
+- macOS: `brew install scrcpy`
+
+Kaynak kodu derle: [BUILD] ([basitleştirilmiş süreç][build_simple])
+
+[build]: BUILD.md
+[build_simple]: BUILD.md#simple
+
+### Linux
+
+Debian (şimdilik _testing_ ve _sid_) ve Ubuntu (20.04) için:
+
+```
+apt install scrcpy
+```
+
+[Snap] paketi: [`scrcpy`][snap-link].
+
+[snap-link]: https://snapstats.org/snaps/scrcpy
+[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
+
+Fedora için, [COPR] paketi: [`scrcpy`][copr-link].
+
+[copr]: https://fedoraproject.org/wiki/Category:Copr
+[copr-link]: https://copr.fedorainfracloud.org/coprs/zeno/scrcpy/
+
+Arch Linux için, [AUR] paketi: [`scrcpy`][aur-link].
+
+[aur]: https://wiki.archlinux.org/index.php/Arch_User_Repository
+[aur-link]: https://aur.archlinux.org/packages/scrcpy/
+
+Gentoo için, [Ebuild] mevcut: [`scrcpy/`][ebuild-link].
+
+[ebuild]: https://wiki.gentoo.org/wiki/Ebuild
+[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
+
+Ayrıca [uygulamayı el ile de derleyebilirsiniz][build] ([basitleştirilmiş süreç][build_simple]).
+
+### Windows
+
+Windows için (`adb` dahil) tüm gereksinimleri ile derlenmiş bir arşiv mevcut:
+
+ - [README](README.md#windows)
+
+[Chocolatey] ile kurulum:
+
+[chocolatey]: https://chocolatey.org/
+
+```bash
+choco install scrcpy
+choco install adb    # if you don't have it yet
+```
+
+[Scoop] ile kurulum:
+
+```bash
+scoop install scrcpy
+scoop install adb    # if you don't have it yet
+```
+
+[scoop]: https://scoop.sh
+
+Ayrıca [uygulamayı el ile de derleyebilirsiniz][build].
+
+### macOS
+
+Uygulama [Homebrew] içerisinde mevcut. Sadece kurun:
+
+[homebrew]: https://brew.sh/
+
+```bash
+brew install scrcpy
+```
+
+`adb`, `PATH` içerisinden erişilebilir olmalıdır. Eğer değilse:
+
+```bash
+brew install android-platform-tools
+```
+
+[MacPorts] kullanılarak adb ve uygulamanın birlikte kurulumu yapılabilir:
+
+```bash
+sudo port install scrcpy
+```
+
+[macports]: https://www.macports.org/
+
+Ayrıca [uygulamayı el ile de derleyebilirsiniz][build].
+
+## Çalıştırma
+
+Android cihazınızı bağlayın ve aşağıdaki komutu çalıştırın:
+
+```bash
+scrcpy
+```
+
+Komut satırı argümanları aşağıdaki komut ile listelenebilir:
+
+```bash
+scrcpy --help
+```
+
+## Özellikler
+
+### Ekran yakalama ayarları
+
+#### Boyut azaltma
+
+Bazen, Android cihaz ekranını daha düşük seviyede göstermek performansı artırabilir.
+
+Hem genişliği hem de yüksekliği bir değere sabitlemek için (ör. 1024):
+
+```bash
+scrcpy --max-size 1024
+scrcpy -m 1024  # kısa versiyon
+```
+
+Diğer boyut en-boy oranı korunacak şekilde hesaplanır.
+Bu şekilde ekran boyutu 1920x1080 olan bir cihaz 1024x576 olarak görünür.
+
+#### Bit-oranı değiştirme
+
+Varsayılan bit-oranı 8 Mbps'dir. Değiştirmek için (ör. 2 Mbps):
+
+```bash
+scrcpy --bit-rate 2M
+scrcpy -b 2M  # kısa versiyon
+```
+
+#### Çerçeve oranı sınırlama
+
+Ekran yakalama için maksimum çerçeve oranı için sınır koyulabilir:
+
+```bash
+scrcpy --max-fps 15
+```
+
+Bu özellik Android 10 ve sonrası sürümlerde resmi olarak desteklenmektedir,
+ancak daha önceki sürümlerde çalışmayabilir.
+
+#### Kesme
+
+Cihaz ekranının sadece bir kısmı görünecek şekilde kesilebilir.
+
+Bu özellik Oculus Go'nun bir gözünü yakalamak gibi durumlarda kullanışlı olur:
+
+```bash
+scrcpy --crop 1224:1440:0:0   # (0,0) noktasından 1224x1440
+```
+
+Eğer `--max-size` belirtilmişse yeniden boyutlandırma kesme işleminden sonra yapılır.
+
+#### Video yönünü kilitleme
+
+Videonun yönünü kilitlemek için:
+
+```bash
+scrcpy --lock-video-orientation     # başlangıç yönü
+scrcpy --lock-video-orientation=0   # doğal yön
+scrcpy --lock-video-orientation=1   # 90° saatin tersi yönü
+scrcpy --lock-video-orientation=2   # 180°
+scrcpy --lock-video-orientation=3   # 90° saat yönü
+```
+
+Bu özellik kaydetme yönünü de etkiler.
+
+[Pencere ayrı olarak döndürülmüş](#rotation) olabilir.
+
+#### Kodlayıcı
+
+Bazı cihazlar birden fazla kodlayıcıya sahiptir, ve bunların bazıları programın
+kapanmasına sebep olabilir. Bu durumda farklı bir kodlayıcı seçilebilir:
+
+```bash
+scrcpy --encoder OMX.qcom.video.encoder.avc
+```
+
+Mevcut kodlayıcıları listelemek için geçerli olmayan bir kodlayıcı ismi girebilirsiniz,
+hata mesajı mevcut kodlayıcıları listeleyecektir:
+
+```bash
+scrcpy --encoder _
+```
+
+### Yakalama
+
+#### Kaydetme
+
+Ekran yakalama sırasında kaydedilebilir:
+
+```bash
+scrcpy --record file.mp4
+scrcpy -r file.mkv
+```
+
+Yakalama olmadan kayıt için:
+
+```bash
+scrcpy --no-display --record file.mp4
+scrcpy -Nr file.mkv
+# Ctrl+C ile kayıt kesilebilir
+```
+
+"Atlanan kareler" gerçek zamanlı olarak gösterilmese (performans sebeplerinden ötürü) dahi kaydedilir.
+Kareler cihazda _zamandamgası_ ile saklanır, bu sayede [paket gecikme varyasyonu]
+kayıt edilen dosyayı etkilemez.
+
+[paket gecikme varyasyonu]: https://en.wikipedia.org/wiki/Packet_delay_variation
+
+#### v4l2loopback
+
+Linux'ta video akışı bir v4l2 loopback cihazına gönderilebilir. Bu sayede Android
+cihaz bir web kamerası gibi davranabilir.
+
+Bu işlem için `v4l2loopback` modülü kurulu olmalıdır:
+
+```bash
+sudo apt install v4l2loopback-dkms
+```
+
+v4l2 cihazı oluşturmak için:
+
+```bash
+sudo modprobe v4l2loopback
+```
+
+Bu komut `/dev/videoN` adresinde `N` yerine bir tamsayı koyarak yeni bir video
+cihazı oluşturacaktır.
+(birden fazla cihaz oluşturmak veya spesifik ID'ye sahip cihazlar için
+diğer [seçenekleri](https://github.com/umlaeute/v4l2loopback#options) inceleyebilirsiniz.)
+
+Aktif cihazları listelemek için:
+
+```bash
+# v4l-utils paketi ile
+v4l2-ctl --list-devices
+
+# daha basit ama yeterli olabilecek şekilde
+ls /dev/video*
+```
+
+v4l2 kullanarak scrpy kullanmaya başlamak için:
+
+```bash
+scrcpy --v4l2-sink=/dev/videoN
+scrcpy --v4l2-sink=/dev/videoN --no-display  # ayna penceresini kapatarak
+scrcpy --v4l2-sink=/dev/videoN -N            # kısa versiyon
+```
+
+(`N` harfini oluşturulan cihaz ID numarası ile değiştirin. `ls /dev/video*` cihaz ID'lerini görebilirsiniz.)
+
+Aktifleştirildikten sonra video akışını herhangi bir v4l2 özellikli araçla açabilirsiniz:
+
+```bash
+ffplay -i /dev/videoN
+vlc v4l2:///dev/videoN   # VLC kullanırken yükleme gecikmesi olabilir
+```
+
+Örneğin, [OBS] ile video akışını kullanabilirsiniz.
+
+[obs]: https://obsproject.com/
+
+### Bağlantı
+
+#### Kablosuz
+
+_Scrcpy_ cihazla iletişim kurmak için `adb`'yi kullanır, Ve `adb`
+bir cihaza TCP/IP kullanarak [bağlanabilir].
+
+1. Cihazınızı bilgisayarınızla aynı Wi-Fi ağına bağlayın.
+2. Cihazınızın IP adresini bulun. Ayarlar → Telefon Hakkında → Durum sekmesinden veya
+   aşağıdaki komutu çalıştırarak öğrenebilirsiniz:
+
+   ```bash
+   adb shell ip route | awk '{print $9}'
+   ```
+
+3. Cihazınızda TCP/IP üzerinden adb kullanımını etkinleştirin: `adb tcpip 5555`.
+4. Cihazınızı bilgisayarınızdan sökün.
+5. Cihazınıza bağlanın: `adb connect DEVICE_IP:5555` _(`DEVICE_IP` değerini değiştirin)_.
+6. `scrcpy` komutunu normal olarak çalıştırın.
+
+Bit-oranını ve büyüklüğü azaltmak yararlı olabilir:
+
+```bash
+scrcpy --bit-rate 2M --max-size 800
+scrcpy -b2M -m800  # kısa version
+```
+
+[bağlanabilir]: https://developer.android.com/studio/command-line/adb.html#wireless
+
+#### Birden fazla cihaz
+
+Eğer `adb devices` komutu birden fazla cihaz listeliyorsa _serial_ değerini belirtmeniz gerekir:
+
+```bash
+scrcpy --serial 0123456789abcdef
+scrcpy -s 0123456789abcdef  # kısa versiyon
+```
+
+Eğer cihaz TCP/IP üzerinden bağlanmışsa:
+
+```bash
+scrcpy --serial 192.168.0.1:5555
+scrcpy -s 192.168.0.1:5555  # kısa version
+```
+
+Birden fazla cihaz için birden fazla _scrcpy_ uygulaması çalıştırabilirsiniz.
+
+#### Cihaz bağlantısı ile otomatik başlatma
+
+[AutoAdb] ile yapılabilir:
+
+```bash
+autoadb scrcpy -s '{}'
+```
+
+[autoadb]: https://github.com/rom1v/autoadb
+
+#### SSH Tünel
+
+Uzaktaki bir cihaza erişmek için lokal `adb` istemcisi, uzaktaki bir `adb` sunucusuna
+(aynı _adb_ sürümünü kullanmak şartı ile) bağlanabilir :
+
+```bash
+adb kill-server    # 5037 portunda çalışan lokal adb sunucusunu kapat
+ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
+# bunu açık tutun
+```
+
+Başka bir terminalde:
+
+```bash
+scrcpy
+```
+
+Uzaktan port yönlendirme ileri yönlü bağlantı kullanabilirsiniz
+(`-R` yerine `-L` olduğuna dikkat edin):
+
+```bash
+adb kill-server    # 5037 portunda çalışan lokal adb sunucusunu kapat
+ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
+# bunu açık tutun
+```
+
+Başka bir terminalde:
+
+```bash
+scrcpy --force-adb-forward
+```
+
+Kablosuz bağlantı gibi burada da kalite düşürmek faydalı olabilir:
+
+```
+scrcpy -b2M -m800 --max-fps 15
+```
+
+### Pencere ayarları
+
+#### İsim
+
+Cihaz modeli varsayılan pencere ismidir. Değiştirmek için:
+
+```bash
+scrcpy --window-title 'Benim cihazım'
+```
+
+#### Konum ve
+
+Pencerenin başlangıç konumu ve boyutu belirtilebilir:
+
+```bash
+scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
+```
+
+#### Kenarlıklar
+
+Pencere dekorasyonunu kapatmak için:
+
+```bash
+scrcpy --window-borderless
+```
+
+#### Her zaman üstte
+
+Scrcpy penceresini her zaman üstte tutmak için:
+
+```bash
+scrcpy --always-on-top
+```
+
+#### Tam ekran
+
+Uygulamayı tam ekran başlatmak için:
+
+```bash
+scrcpy --fullscreen
+scrcpy -f  # kısa versiyon
+```
+
+Tam ekran <kbd>MOD</kbd>+<kbd>f</kbd> ile dinamik olarak değiştirilebilir.
+
+#### Döndürme
+
+Pencere döndürülebilir:
+
+```bash
+scrcpy --rotation 1
+```
+
+Seçilebilecek değerler:
+
+- `0`: döndürme yok
+- `1`: 90 derece saat yönünün tersi
+- `2`: 180 derece
+- `3`: 90 derece saat yönü
+
+Döndürme <kbd>MOD</kbd>+<kbd>←</kbd>_(sol)_ ve
+<kbd>MOD</kbd>+<kbd>→</kbd> _(sağ)_ ile dinamik olarak değiştirilebilir.
+
+_scrcpy_'de 3 farklı döndürme olduğuna dikkat edin:
+
+- <kbd>MOD</kbd>+<kbd>r</kbd> cihazın yatay veya dikey modda çalışmasını sağlar.
+  (çalışan uygulama istenilen oryantasyonda çalışmayı desteklemiyorsa döndürme
+  işlemini reddedebilir.)
+- [`--lock-video-orientation`](#lock-video-orientation) görüntü yakalama oryantasyonunu
+  (cihazdan bilgisayara gelen video akışının oryantasyonu) değiştirir. Bu kayıt işlemini
+  etkiler.
+- `--rotation` (or <kbd>MOD</kbd>+<kbd>←</kbd>/<kbd>MOD</kbd>+<kbd>→</kbd>)
+  pencere içeriğini dönderir. Bu sadece canlı görüntüyü etkiler, kayıt işlemini etkilemez.
+
+### Diğer ekran yakalama seçenekleri
+
+#### Yazma korumalı
+
+Kontrolleri devre dışı bırakmak için (cihazla etkileşime geçebilecek her şey: klavye ve
+fare girdileri, dosya sürükleyip bırakma):
+
+```bash
+scrcpy --no-control
+scrcpy -n
+```
+
+#### Ekran
+
+Eğer cihazın birden fazla ekranı varsa hangi ekranın kullanılacağını seçebilirsiniz:
+
+```bash
+scrcpy --display 1
+```
+
+Kullanılabilecek ekranları listelemek için:
+
+```bash
+adb shell dumpsys display   # çıktı içerisinde "mDisplayId=" terimini arayın
+```
+
+İkinci ekran ancak cihaz Android sürümü 10 veya üzeri olmalıdır (değilse yazma korumalı
+olarak görüntülenir).
+
+#### Uyanık kalma
+
+Cihazın uyku moduna girmesini engellemek için:
+
+```bash
+scrcpy --stay-awake
+scrcpy -w
+```
+
+scrcpy kapandığında cihaz başlangıç durumuna geri döner.
+
+#### Ekranı kapatma
+
+Ekran yakalama sırasında cihazın ekranı kapatılabilir:
+
+```bash
+scrcpy --turn-screen-off
+scrcpy -S
+```
+
+Ya da <kbd>MOD</kbd>+<kbd>o</kbd> kısayolunu kullanabilirsiniz.
+
+Tekrar açmak için ise <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd> tuşlarına basın.
+
+Android'de, `GÜÇ` tuşu her zaman ekranı açar. Eğer `GÜÇ` sinyali scrcpy ile
+gönderilsiyse (sağ tık veya <kbd>MOD</kbd>+<kbd>p</kbd>), ekran kısa bir gecikme
+ile kapanacaktır. Fiziksel `GÜÇ` tuşuna basmak hala ekranın açılmasına sebep olacaktır.
+
+Bu cihazın uykuya geçmesini engellemek için kullanılabilir:
+
+```bash
+scrcpy --turn-screen-off --stay-awake
+scrcpy -Sw
+```
+
+#### Dokunuşları gösterme
+
+Sunumlar sırasında fiziksel dokunuşları (fiziksel cihazdaki) göstermek
+faydalı olabilir.
+
+Android'de bu özellik _Geliştici seçenekleri_ içerisinde bulunur.
+
+_Scrcpy_ bu özelliği çalışırken etkinleştirebilir ve kapanırken eski
+haline geri getirebilir:
+
+```bash
+scrcpy --show-touches
+scrcpy -t
+```
+
+Bu opsiyon sadece _fiziksel_ dokunuşları (cihaz ekranındaki) gösterir.
+
+#### Ekran koruyucuyu devre dışı bırakma
+
+Scrcpy varsayılan ayarlarında ekran koruyucuyu devre dışı bırakmaz.
+
+Bırakmak için:
+
+```bash
+scrcpy --disable-screensaver
+```
+
+### Girdi kontrolü
+
+#### Cihaz ekranını dönderme
+
+<kbd>MOD</kbd>+<kbd>r</kbd> tuşları ile yatay ve dikey modlar arasında
+geçiş yapabilirsiniz.
+
+Bu kısayol ancak çalışan uygulama desteklediği takdirde ekranı döndürecektir.
+
+#### Kopyala yapıştır
+
+Ne zaman Android cihazdaki pano değişse bilgisayardaki pano otomatik olarak
+senkronize edilir.
+
+Tüm <kbd>Ctrl</kbd> kısayolları cihaza iletilir:
+
+- <kbd>Ctrl</kbd>+<kbd>c</kbd> genelde kopyalar
+- <kbd>Ctrl</kbd>+<kbd>x</kbd> genelde keser
+- <kbd>Ctrl</kbd>+<kbd>v</kbd> genelde yapıştırır (bilgisayar ve cihaz arasındaki
+  pano senkronizasyonundan sonra)
+
+Bu kısayollar genelde beklediğiniz gibi çalışır.
+
+Ancak kısayolun gerçekten yaptığı eylemi açık olan uygulama belirler.
+Örneğin, _Termux_ <kbd>Ctrl</kbd>+<kbd>c</kbd> ile kopyalama yerine
+SIGINT sinyali gönderir, _K-9 Mail_ ise yeni mesaj oluşturur.
+
+Bu tip durumlarda kopyalama, kesme ve yapıştırma için (Android versiyon 7 ve
+üstü):
+
+- <kbd>MOD</kbd>+<kbd>c</kbd> `KOPYALA`
+- <kbd>MOD</kbd>+<kbd>x</kbd> `KES`
+- <kbd>MOD</kbd>+<kbd>v</kbd> `YAPIŞTIR` (bilgisayar ve cihaz arasındaki
+  pano senkronizasyonundan sonra)
+
+Bunlara ek olarak, <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> tuşları
+bilgisayar pano içeriğini tuş basma eylemleri şeklinde gönderir. Bu metin
+yapıştırmayı desteklemeyen (_Termux_ gibi) uygulamar için kullanışlıdır,
+ancak ASCII olmayan içerikleri bozabilir.
+
+**UYARI:** Bilgisayar pano içeriğini cihaza yapıştırmak
+(<kbd>Ctrl</kbd>+<kbd>v</kbd> ya da <kbd>MOD</kbd>+<kbd>v</kbd> tuşları ile)
+içeriği cihaz panosuna kopyalar. Sonuç olarak, herhangi bir Android uygulaması
+içeriğe erişebilir. Hassas içerikler (parolalar gibi) için bu özelliği kullanmaktan
+kaçının.
+
+Bazı cihazlar pano değişikleri konusunda beklenilen şekilde çalışmayabilir.
+Bu durumlarda `--legacy-paste` argümanı kullanılabilir. Bu sayede
+<kbd>Ctrl</kbd>+<kbd>v</kbd> ve <kbd>MOD</kbd>+<kbd>v</kbd> tuşları da
+pano içeriğini tuş basma eylemleri şeklinde gönderir
+(<kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd> ile aynı şekilde).
+
+#### İki parmak ile yakınlaştırma
+
+"İki parmak ile yakınlaştırma" için: <kbd>Ctrl</kbd>+_tıkla-ve-sürükle_.
+
+Daha açıklayıcı şekilde, <kbd>Ctrl</kbd> tuşuna sol-tık ile birlikte basılı
+tutun. Sol-tık serbest bırakılıncaya kadar yapılan tüm fare hareketleri
+ekran içeriğini ekranın merkezini baz alarak dönderir, büyütür veya küçültür
+(eğer uygulama destekliyorsa).
+
+Scrcpy ekranın merkezinde bir "sanal parmak" varmış gibi davranır.
+
+#### Metin gönderme tercihi
+
+Metin girilirken ili çeşit [eylem][textevents] gerçekleştirilir:
+
+- _tuş eylemleri_, bir tuşa basıldığı sinyalini verir;
+- _metin eylemleri_, bir metin girildiği sinyalini verir.
+
+Varsayılan olarak, harfler tuş eylemleri kullanılarak gönderilir. Bu sayede
+klavye oyunlarda beklenilene uygun olarak çalışır (Genelde WASD tuşları).
+
+Ancak bu [bazı problemlere][prefertext] yol açabilir. Eğer bu problemler ile
+karşılaşırsanız metin eylemlerini tercih edebilirsiniz:
+
+```bash
+scrcpy --prefer-text
+```
+
+(Ama bu oyunlardaki klavye davranışlarını bozacaktır)
+
+[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
+[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
+
+#### Tuş tekrarı
+
+Varsayılan olarak, bir tuşa basılı tutmak tuş eylemini tekrarlar. Bu durum
+bazı oyunlarda problemlere yol açabilir.
+
+Tuş eylemlerinin tekrarını kapatmak için:
+
+```bash
+scrcpy --no-key-repeat
+```
+
+#### Sağ-tık ve Orta-tık
+
+Varsayılan olarak, sağ-tık GERİ (ya da GÜÇ açma) eylemlerini, orta-tık ise
+ANA EKRAN eylemini tetikler. Bu kısayolları devre dışı bırakmak için:
+
+```bash
+scrcpy --forward-all-clicks
+```
+
+### Dosya bırakma
+
+#### APK kurulumu
+
+APK kurmak için, bilgisayarınızdaki APK dosyasını (`.apk` ile biten) _scrcpy_
+penceresine sürükleyip bırakın.
+
+Bu eylem görsel bir geri dönüt oluşturmaz, konsola log yazılır.
+
+#### Dosyayı cihaza gönderme
+
+Bir dosyayı cihazdaki `/sdcard/Download/` dizinine atmak için, (APK olmayan)
+bir dosyayı _scrcpy_ penceresine sürükleyip bırakın.
+
+Bu eylem görsel bir geri dönüt oluşturmaz, konsola log yazılır.
+
+Hedef dizin uygulama başlatılırken değiştirilebilir:
+
+```bash
+scrcpy --push-target=/sdcard/Movies/
+```
+
+### Ses iletimi
+
+_Scrcpy_ ses iletimi yapmaz. Yerine [sndcpy] kullanabilirsiniz.
+
+Ayrıca bakınız [issue #14].
+
+[sndcpy]: https://github.com/rom1v/sndcpy
+[issue #14]: https://github.com/Genymobile/scrcpy/issues/14
+
+## Kısayollar
+
+Aşağıdaki listede, <kbd>MOD</kbd> kısayol tamamlayıcısıdır. Varsayılan olarak
+(sol) <kbd>Alt</kbd> veya (sol) <kbd>Super</kbd> tuşudur.
+
+Bu tuş `--shortcut-mod` argümanı kullanılarak `lctrl`, `rctrl`,
+`lalt`, `ralt`, `lsuper` ve `rsuper` tuşlarından biri ile değiştirilebilir.
+Örneğin:
+
+```bash
+# Sağ Ctrl kullanmak için
+scrcpy --shortcut-mod=rctrl
+
+# Sol Ctrl, Sol Alt veya Sol Super tuşlarından birini kullanmak için
+scrcpy --shortcut-mod=lctrl+lalt,lsuper
+```
+
+_<kbd>[Super]</kbd> tuşu genelde <kbd>Windows</kbd> veya <kbd>Cmd</kbd> tuşudur._
+
+[super]: https://en.wikipedia.org/wiki/Super_key_(keyboard_button)
+
+| Action                                           | Shortcut                                                  |
+| ------------------------------------------------ | :-------------------------------------------------------- |
+| Tam ekran modunu değiştirme                      | <kbd>MOD</kbd>+<kbd>f</kbd>                               |
+| Ekranı sola çevirme                              | <kbd>MOD</kbd>+<kbd>←</kbd> _(sol)_                       |
+| Ekranı sağa çevirme                              | <kbd>MOD</kbd>+<kbd>→</kbd> _(sağ)_                       |
+| Pencereyi 1:1 oranına çevirme (pixel-perfect)    | <kbd>MOD</kbd>+<kbd>g</kbd>                               |
+| Penceredeki siyah kenarlıkları kaldırma          | <kbd>MOD</kbd>+<kbd>w</kbd> \| _Çift-sol-tık¹_            |
+| `ANA EKRAN` tuşu                                 | <kbd>MOD</kbd>+<kbd>h</kbd> \| _Orta-tık_                 |
+| `GERİ` tuşu                                      | <kbd>MOD</kbd>+<kbd>b</kbd> \| _Sağ-tık²_                 |
+| `UYGULAMA_DEĞİŞTİR` tuşu                         | <kbd>MOD</kbd>+<kbd>s</kbd> \| _4.tık³_                   |
+| `MENÜ` tuşu (ekran kilidini açma)                | <kbd>MOD</kbd>+<kbd>m</kbd>                               |
+| `SES_AÇ` tuşu                                    | <kbd>MOD</kbd>+<kbd>↑</kbd> _(yukarı)_                    |
+| `SES_KIS` tuşu                                   | <kbd>MOD</kbd>+<kbd>↓</kbd> _(aşağı)_                     |
+| `GÜÇ` tuşu                                       | <kbd>MOD</kbd>+<kbd>p</kbd>                               |
+| Gücü açma                                        | _Sağ-tık²_                                                |
+| Cihaz ekranını kapatma (ekran yakalama durmadan) | <kbd>MOD</kbd>+<kbd>o</kbd>                               |
+| Cihaz ekranını açma                              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>o</kbd>              |
+| Cihaz ekranını dönderme                          | <kbd>MOD</kbd>+<kbd>r</kbd>                               |
+| Bildirim panelini genişletme                     | <kbd>MOD</kbd>+<kbd>n</kbd> \| _5.tık³_                   |
+| Ayarlar panelini genişletme                      | <kbd>MOD</kbd>+<kbd>n</kbd>+<kbd>n</kbd> \| _Çift-5.tık³_ |
+| Panelleri kapatma                                | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>n</kbd>              |
+| Panoya kopyalama⁴                                | <kbd>MOD</kbd>+<kbd>c</kbd>                               |
+| Panoya kesme⁴                                    | <kbd>MOD</kbd>+<kbd>x</kbd>                               |
+| Panoları senkronize ederek yapıştırma⁴           | <kbd>MOD</kbd>+<kbd>v</kbd>                               |
+| Bilgisayar panosundaki metini girme              | <kbd>MOD</kbd>+<kbd>Shift</kbd>+<kbd>v</kbd>              |
+| FPS sayacını açma/kapatma (terminalde)           | <kbd>MOD</kbd>+<kbd>i</kbd>                               |
+| İki parmakla yakınlaştırma                       | <kbd>Ctrl</kbd>+_tıkla-ve-sürükle_                        |
+
+_¹Siyah kenarlıkları silmek için üzerine çift tıklayın._  
+_²Sağ-tık ekran kapalıysa açar, değilse GERİ sinyali gönderir._  
+_³4. ve 5. fare tuşları (eğer varsa)._  
+_⁴Sadece Android 7 ve üzeri versiyonlarda._
+
+Tekrarlı tuşu olan kısayollar tuş bırakılıp tekrar basılarak tekrar çalıştırılır.
+Örneğin, "Ayarlar panelini genişletmek" için:
+
+1.  <kbd>MOD</kbd> tuşuna basın ve basılı tutun.
+2.  <kbd>n</kbd> tuşuna iki defa basın.
+3.  <kbd>MOD</kbd> tuşuna basmayı bırakın.
+
+Tüm <kbd>Ctrl</kbd>+_tuş_ kısayolları cihaza gönderilir. Bu sayede istenilen komut
+uygulama tarafından çalıştırılır.
+
+## Özel dizinler
+
+Varsayılandan farklı bir _adb_ programı çalıştırmak için `ADB` ortam değişkenini
+ayarlayın:
+
+```bash
+ADB=/path/to/adb scrcpy
+```
+
+`scrcpy-server` programının dizinini değiştirmek için `SCRCPY_SERVER_PATH`
+değişkenini ayarlayın.
+
+[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
+
+## Neden _scrcpy_?
+
+Bir meslektaşım [gnirehtet] gibi söylenmesi zor bir isim bulmam için bana meydan okudu.
+
+[`strcpy`] **str**ing kopyalıyor; `scrcpy` **scr**een kopyalıyor.
+
+[gnirehtet]: https://github.com/Genymobile/gnirehtet
+[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
+
+## Nasıl derlenir?
+
+Bakınız [BUILD].
+
+## Yaygın problemler
+
+Bakınız [FAQ](FAQ.md).
+
+## Geliştiriciler
+
+[Geliştiriciler sayfası]nı okuyun.
+
+[geliştiriciler sayfası]: DEVELOP.md
+
+## Lisans
+
+    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.
+
+## Makaleler
+
+- [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/app/meson.build
+++ b/app/meson.build
@@ -2,7 +2,6 @@ src = [
    'src/main.c',
    'src/adb.c',
    'src/cli.c',
-    'src/clock.c',
    'src/compat.c',
    'src/control_msg.c',
    'src/controller.c',
@@ -11,7 +10,6 @@ src = [
    'src/event_converter.c',
    'src/file_handler.c',
    'src/fps_counter.c',
-    'src/frame_buffer.c',
    'src/input_manager.c',
    'src/opengl.c',
    'src/receiver.c',
@@ -27,7 +25,6 @@ src = [
    'src/util/process.c',
    'src/util/str_util.c',
    'src/util/thread.c',
-    'src/util/tick.c',
 ]

 if host_machine.system() == 'windows'
@@ -168,10 +165,6 @@ if get_option('buildtype') == 'debug'
            'src/cli.c',
            'src/util/str_util.c',
        ]],
-        ['test_clock', [
-            'tests/test_clock.c',
-            'src/clock.c',
-        ]],
        ['test_control_msg_serialize', [
            'tests/test_control_msg_serialize.c',
            'src/control_msg.c',
--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@@ -56,12 +56,6 @@ The list of possible display ids can be listed by "adb shell dumpsys display"

 Default is 0.

-.TP
-.BI "\-\-display\-buffer ms
-Add a buffering delay (in milliseconds) before displaying. This increases latency to compensate for jitter.
-
-Default is 0 (no buffering).
-
 .TP
 .BI "\-\-encoder " name
 Use a specific MediaCodec encoder (must be a H.264 encoder).
@@ -89,8 +83,8 @@ Inject computer clipboard text as a sequence of key events on Ctrl+v (like MOD+S
 This is a workaround for some devices not behaving as expected when setting the device clipboard programmatically.

 .TP
-.BI "\-\-lock\-video\-orientation[=value]
-Lock video orientation to \fIvalue\fR. Possible values are "unlocked", "initial" (locked to the initial orientation), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees rotation counterclockwise.
+.BI "\-\-lock\-video\-orientation " [value]
+Lock video orientation to \fIvalue\fR. Possible values are "unlocked", "initial" (locked to the initial orientation), 0, 1, 2 and 3. Natural device orientation is 0, and each increment adds a 90 degrees otation counterclockwise.

 Default is "unlocked".

@@ -195,15 +189,7 @@ It only shows physical touches (not clicks from scrcpy).
 .BI "\-\-v4l2-sink " /dev/videoN
 Output to v4l2loopback device.

-It requires to lock the video orientation (see \fB\-\-lock\-video\-orientation\fR).
-
-.TP
-.BI "\-\-v4l2-buffer " ms
-Add a buffering delay (in milliseconds) before pushing frames. This increases latency to compensate for jitter.
-
-This option is similar to \fB\-\-display\-buffer\fR, but specific to V4L2 sink.
-
-Default is 0 (no buffering).
+It requires to lock the video orientation (see --lock-video-orientation).

 .TP
 .BI "\-V, \-\-verbosity " value
@@ -254,7 +240,7 @@ Default is 0 (automatic).
 .SH SHORTCUTS

 In the following list, MOD is the shortcut modifier. By default, it's (left)
-Alt or (left) Super, but it can be configured by \fB\-\-shortcut\-mod\fR (see above).
+Alt or (left) Super, but it can be configured by \-\-shortcut-mod (see above).

 .TP
 .B MOD+f
--- a/app/src/cli.c
+++ b/app/src/cli.c
@@ -55,12 +55,6 @@ scrcpy_print_usage(const char *arg0) {
        "\n"
        "        Default is 0.\n"
        "\n"
-        "    --display-buffer ms\n"
-        "        Add a buffering delay (in milliseconds) before displaying.\n"
-        "        This increases latency to compensate for jitter.\n"
-        "\n"
-        "        Default is 0 (no buffering).\n"
-        "\n"
        "    --encoder name\n"
        "        Use a specific MediaCodec encoder (must be a H.264 encoder).\n"
        "\n"
@@ -85,7 +79,7 @@ scrcpy_print_usage(const char *arg0) {
        "        This is a workaround for some devices not behaving as\n"
        "        expected when setting the device clipboard programmatically.\n"
        "\n"
-        "    --lock-video-orientation[=value]\n"
+        "    --lock-video-orientation [value]\n"
        "        Lock video orientation to value.\n"
        "        Possible values are \"unlocked\", \"initial\" (locked to the\n"
        "        initial orientation), 0, 1, 2 and 3.\n"
@@ -188,15 +182,6 @@ scrcpy_print_usage(const char *arg0) {
        "        It requires to lock the video orientation (see\n"
        "        --lock-video-orientation).\n"
        "\n"
-        "    --v4l2-buffer ms\n"
-        "        Add a buffering delay (in milliseconds) before pushing\n"
-        "        frames. This increases latency to compensate for jitter.\n"
-        "\n"
-        "        This option is similar to --display-buffer, but specific to\n"
-        "        V4L2 sink.\n"
-        "\n"
-        "        Default is 0 (no buffering).\n"
-        "\n"
 #endif
        "    -V, --verbosity value\n"
        "        Set the log level (verbose, debug, info, warn or error).\n"
@@ -407,19 +392,6 @@ parse_max_fps(const char *s, uint16_t *max_fps) {
    return true;
 }

-static bool
-parse_buffering_time(const char *s, sc_tick *tick) {
-    long value;
-    bool ok = parse_integer_arg(s, &value, false, 0, 0x7FFFFFFF,
-                                "buffering time");
-    if (!ok) {
-        return false;
-    }
-
-    *tick = SC_TICK_FROM_MS(value);
-    return true;
-}
-
 static bool
 parse_lock_video_orientation(const char *s,
                             enum sc_lock_video_orientation *lock_mode) {
@@ -717,8 +689,6 @@ guess_record_format(const char *filename) {
 #define OPT_ENCODER_NAME           1025
 #define OPT_POWER_OFF_ON_CLOSE     1026
 #define OPT_V4L2_SINK              1027
-#define OPT_DISPLAY_BUFFER         1028
-#define OPT_V4L2_BUFFER            1029

 bool
 scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
@@ -730,7 +700,6 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
        {"disable-screensaver",    no_argument,       NULL,
                                                  OPT_DISABLE_SCREENSAVER},
        {"display",                required_argument, NULL, OPT_DISPLAY_ID},
-        {"display-buffer",         required_argument, NULL, OPT_DISPLAY_BUFFER},
        {"encoder",                required_argument, NULL, OPT_ENCODER_NAME},
        {"force-adb-forward",      no_argument,       NULL,
                                                  OPT_FORCE_ADB_FORWARD},
@@ -763,7 +732,6 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
        {"turn-screen-off",        no_argument,       NULL, 'S'},
 #ifdef HAVE_V4L2
        {"v4l2-sink",              required_argument, NULL, OPT_V4L2_SINK},
-        {"v4l2-buffer",            required_argument, NULL, OPT_V4L2_BUFFER},
 #endif
        {"verbosity",              required_argument, NULL, 'V'},
        {"version",                no_argument,       NULL, 'v'},
@@ -949,20 +917,10 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
            case OPT_POWER_OFF_ON_CLOSE:
                opts->power_off_on_close = true;
                break;
-            case OPT_DISPLAY_BUFFER:
-                if (!parse_buffering_time(optarg, &opts->display_buffer)) {
-                    return false;
-                }
-                break;
 #ifdef HAVE_V4L2
            case OPT_V4L2_SINK:
                opts->v4l2_device = optarg;
                break;
-            case OPT_V4L2_BUFFER:
-                if (!parse_buffering_time(optarg, &opts->v4l2_buffer)) {
-                    return false;
-                }
-                break;
 #endif
            default:
                // getopt prints the error message on stderr
@@ -983,11 +941,6 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
             "See --lock-video-orientation.");
        opts->lock_video_orientation = SC_LOCK_VIDEO_ORIENTATION_INITIAL;
    }
-
-    if (opts->v4l2_buffer && !opts->v4l2_device) {
-        LOGE("V4L2 buffer value without V4L2 sink\n");
-        return false;
-    }
 #else
    if (!opts->display && !opts->record_filename) {
        LOGE("-N/--no-display requires screen recording (-r/--record)");
--- a/app/src/clock.c
+++ b/app/src/clock.c
@@ -1,111 +0,0 @@
-#include "clock.h"
-
-#include "util/log.h"
-
-#define SC_CLOCK_NDEBUG // comment to debug
-
-void
-sc_clock_init(struct sc_clock *clock) {
-    clock->count = 0;
-    clock->head = 0;
-    clock->left_sum.system = 0;
-    clock->left_sum.stream = 0;
-    clock->right_sum.system = 0;
-    clock->right_sum.stream = 0;
-}
-
-// Estimate the affine function f(stream) = slope * stream + offset
-static void
-sc_clock_estimate(struct sc_clock *clock,
-                  double *out_slope, sc_tick *out_offset) {
-    assert(clock->count > 1); // two points are necessary
-
-    struct sc_clock_point left_avg = {
-        .system = clock->left_sum.system / (clock->count / 2),
-        .stream = clock->left_sum.stream / (clock->count / 2),
-    };
-    struct sc_clock_point right_avg = {
-        .system = clock->right_sum.system / ((clock->count + 1) / 2),
-        .stream = clock->right_sum.stream / ((clock->count + 1) / 2),
-    };
-
-    double slope = (double) (right_avg.system - left_avg.system)
-                 / (right_avg.stream - left_avg.stream);
-
-    if (clock->count < SC_CLOCK_RANGE) {
-        /* The first frames are typically received and decoded with more delay
-         * than the others, causing a wrong slope estimation on start. To
-         * compensate, assume an initial slope of 1, then progressively use the
-         * estimated slope. */
-        slope = (clock->count * slope + (SC_CLOCK_RANGE - clock->count))
-              / SC_CLOCK_RANGE;
-    }
-
-    struct sc_clock_point global_avg = {
-        .system = (clock->left_sum.system + clock->right_sum.system)
-                 / clock->count,
-        .stream = (clock->left_sum.stream + clock->right_sum.stream)
-                 / clock->count,
-    };
-
-    sc_tick offset = global_avg.system - (sc_tick) (global_avg.stream * slope);
-
-    *out_slope = slope;
-    *out_offset = offset;
-}
-
-void
-sc_clock_update(struct sc_clock *clock, sc_tick system, sc_tick stream) {
-    struct sc_clock_point *point = &clock->points[clock->head];
-
-    if (clock->count == SC_CLOCK_RANGE || clock->count & 1) {
-        // One point passes from the right sum to the left sum
-
-        unsigned mid;
-        if (clock->count == SC_CLOCK_RANGE) {
-            mid = (clock->head + SC_CLOCK_RANGE / 2) % SC_CLOCK_RANGE;
-        } else {
-            // Only for the first frames
-            mid = clock->count / 2;
-        }
-
-        struct sc_clock_point *mid_point = &clock->points[mid];
-        clock->left_sum.system += mid_point->system;
-        clock->left_sum.stream += mid_point->stream;
-        clock->right_sum.system -= mid_point->system;
-        clock->right_sum.stream -= mid_point->stream;
-    }
-
-    if (clock->count == SC_CLOCK_RANGE) {
-        // The current point overwrites the previous value in the circular
-        // array, update the left sum accordingly
-        clock->left_sum.system -= point->system;
-        clock->left_sum.stream -= point->stream;
-    } else {
-        ++clock->count;
-    }
-
-    point->system = system;
-    point->stream = stream;
-
-    clock->right_sum.system += system;
-    clock->right_sum.stream += stream;
-
-    clock->head = (clock->head + 1) % SC_CLOCK_RANGE;
-
-    if (clock->count > 1) {
-        // Update estimation
-        sc_clock_estimate(clock, &clock->slope, &clock->offset);
-
-#ifndef SC_CLOCK_NDEBUG
-        LOGD("Clock estimation: %g * pts + %" PRItick,
-             clock->slope, clock->offset);
-#endif
-    }
-}
-
-sc_tick
-sc_clock_to_system_time(struct sc_clock *clock, sc_tick stream) {
-    assert(clock->count > 1); // sc_clock_update() must have been called
-    return (sc_tick) (stream * clock->slope) + clock->offset;
-}
--- a/app/src/clock.h
+++ b/app/src/clock.h
@@ -1,70 +0,0 @@
-#ifndef SC_CLOCK_H
-#define SC_CLOCK_H
-
-#include "common.h"
-
-#include <assert.h>
-
-#include "util/tick.h"
-
-#define SC_CLOCK_RANGE 32
-static_assert(!(SC_CLOCK_RANGE & 1), "SC_CLOCK_RANGE must be even");
-
-struct sc_clock_point {
-    sc_tick system;
-    sc_tick stream;
-};
-
-/**
- * The clock aims to estimate the affine relation between the stream (device)
- * time and the system time:
- *
- *     f(stream) = slope * stream + offset
- *
- * To that end, it stores the SC_CLOCK_RANGE last clock points (the timestamps
- * of a frame expressed both in stream time and system time) in a circular
- * array.
- *
- * To estimate the slope, it splits the last SC_CLOCK_RANGE points into two
- * sets of SC_CLOCK_RANGE/2 points, and compute their centroid ("average
- * point"). The slope of the estimated affine function is that of the line
- * passing through these two points.
- *
- * To estimate the offset, it computes the centroid of all the SC_CLOCK_RANGE
- * points. The resulting affine function passes by this centroid.
- *
- * With a circular array, the rolling sums (and average) are quick to compute.
- * In practice, the estimation is stable and the evolution is smooth.
- */
-struct sc_clock {
-    // Circular array
-    struct sc_clock_point points[SC_CLOCK_RANGE];
-
-    // Number of points in the array (count <= SC_CLOCK_RANGE)
-    unsigned count;
-
-    // Index of the next point to write
-    unsigned head;
-
-    // Sum of the first count/2 points
-    struct sc_clock_point left_sum;
-
-    // Sum of the last (count+1)/2 points
-    struct sc_clock_point right_sum;
-
-    // Estimated slope and offset
-    // (computed on sc_clock_update(), used by sc_clock_to_system_time())
-    double slope;
-    sc_tick offset;
-};
-
-void
-sc_clock_init(struct sc_clock *clock);
-
-void
-sc_clock_update(struct sc_clock *clock, sc_tick system, sc_tick stream);
-
-sc_tick
-sc_clock_to_system_time(struct sc_clock *clock, sc_tick stream);
-
-#endif
--- a/app/src/controller.c
+++ b/app/src/controller.c
@@ -70,7 +70,7 @@ process_msg(struct controller *controller,
    if (!length) {
        return false;
    }
-    ssize_t w = net_send_all(controller->control_socket, serialized_msg, length);
+    int w = net_send_all(controller->control_socket, serialized_msg, length);
    return (size_t) w == length;
 }

--- a/app/src/fps_counter.c
+++ b/app/src/fps_counter.c
@@ -1,10 +1,11 @@
 #include "fps_counter.h"

 #include <assert.h>
+#include <SDL2/SDL_timer.h>

 #include "util/log.h"

-#define FPS_COUNTER_INTERVAL SC_TICK_FROM_SEC(1)
+#define FPS_COUNTER_INTERVAL_MS 1000

 bool
 fps_counter_init(struct fps_counter *counter) {
@@ -46,7 +47,7 @@ set_started(struct fps_counter *counter, bool started) {
 static void
 display_fps(struct fps_counter *counter) {
    unsigned rendered_per_second =
-        counter->nr_rendered * SC_TICK_FREQ / FPS_COUNTER_INTERVAL;
+        counter->nr_rendered * 1000 / FPS_COUNTER_INTERVAL_MS;
    if (counter->nr_skipped) {
        LOGI("%u fps (+%u frames skipped)", rendered_per_second,
                                            counter->nr_skipped);
@@ -67,8 +68,8 @@ check_interval_expired(struct fps_counter *counter, uint32_t now) {
    counter->nr_skipped = 0;
    // add a multiple of the interval
    uint32_t elapsed_slices =
-        (now - counter->next_timestamp) / FPS_COUNTER_INTERVAL + 1;
-    counter->next_timestamp += FPS_COUNTER_INTERVAL * elapsed_slices;
+        (now - counter->next_timestamp) / FPS_COUNTER_INTERVAL_MS + 1;
+    counter->next_timestamp += FPS_COUNTER_INTERVAL_MS * elapsed_slices;
 }

 static int
@@ -81,12 +82,14 @@ run_fps_counter(void *data) {
            sc_cond_wait(&counter->state_cond, &counter->mutex);
        }
        while (!counter->interrupted && is_started(counter)) {
-            sc_tick now = sc_tick_now();
+            uint32_t now = SDL_GetTicks();
            check_interval_expired(counter, now);

+            assert(counter->next_timestamp > now);
+            uint32_t remaining = counter->next_timestamp - now;
+
            // ignore the reason (timeout or signaled), we just loop anyway
-            sc_cond_timedwait(&counter->state_cond, &counter->mutex,
-                              counter->next_timestamp);
+            sc_cond_timedwait(&counter->state_cond, &counter->mutex, remaining);
        }
    }
    sc_mutex_unlock(&counter->mutex);
@@ -96,7 +99,7 @@ run_fps_counter(void *data) {
 bool
 fps_counter_start(struct fps_counter *counter) {
    sc_mutex_lock(&counter->mutex);
-    counter->next_timestamp = sc_tick_now() + FPS_COUNTER_INTERVAL;
+    counter->next_timestamp = SDL_GetTicks() + FPS_COUNTER_INTERVAL_MS;
    counter->nr_rendered = 0;
    counter->nr_skipped = 0;
    sc_mutex_unlock(&counter->mutex);
@@ -162,7 +165,7 @@ fps_counter_add_rendered_frame(struct fps_counter *counter) {
    }

    sc_mutex_lock(&counter->mutex);
-    sc_tick now = sc_tick_now();
+    uint32_t now = SDL_GetTicks();
    check_interval_expired(counter, now);
    ++counter->nr_rendered;
    sc_mutex_unlock(&counter->mutex);
@@ -175,7 +178,7 @@ fps_counter_add_skipped_frame(struct fps_counter *counter) {
    }

    sc_mutex_lock(&counter->mutex);
-    sc_tick now = sc_tick_now();
+    uint32_t now = SDL_GetTicks();
    check_interval_expired(counter, now);
    ++counter->nr_skipped;
    sc_mutex_unlock(&counter->mutex);
--- a/app/src/fps_counter.h
+++ b/app/src/fps_counter.h
@@ -24,7 +24,7 @@ struct fps_counter {
    bool interrupted;
    unsigned nr_rendered;
    unsigned nr_skipped;
-    sc_tick next_timestamp;
+    uint32_t next_timestamp;
 };

 bool
--- a/app/src/frame_buffer.c
+++ b/app/src/frame_buffer.c
@@ -1,88 +0,0 @@
-#include "frame_buffer.h"
-
-#include <assert.h>
-#include <libavutil/avutil.h>
-#include <libavformat/avformat.h>
-
-#include "util/log.h"
-
-bool
-sc_frame_buffer_init(struct sc_frame_buffer *fb) {
-    fb->pending_frame = av_frame_alloc();
-    if (!fb->pending_frame) {
-        return false;
-    }
-
-    fb->tmp_frame = av_frame_alloc();
-    if (!fb->tmp_frame) {
-        av_frame_free(&fb->pending_frame);
-        return false;
-    }
-
-    bool ok = sc_mutex_init(&fb->mutex);
-    if (!ok) {
-        av_frame_free(&fb->pending_frame);
-        av_frame_free(&fb->tmp_frame);
-        return false;
-    }
-
-    // there is initially no frame, so consider it has already been consumed
-    fb->pending_frame_consumed = true;
-
-    return true;
-}
-
-void
-sc_frame_buffer_destroy(struct sc_frame_buffer *fb) {
-    sc_mutex_destroy(&fb->mutex);
-    av_frame_free(&fb->pending_frame);
-    av_frame_free(&fb->tmp_frame);
-}
-
-static inline void
-swap_frames(AVFrame **lhs, AVFrame **rhs) {
-    AVFrame *tmp = *lhs;
-    *lhs = *rhs;
-    *rhs = tmp;
-}
-
-bool
-sc_frame_buffer_push(struct sc_frame_buffer *fb, const AVFrame *frame,
-                  bool *previous_frame_skipped) {
-    sc_mutex_lock(&fb->mutex);
-
-    // Use a temporary frame to preserve pending_frame in case of error.
-    // tmp_frame is an empty frame, no need to call av_frame_unref() beforehand.
-    int r = av_frame_ref(fb->tmp_frame, frame);
-    if (r) {
-        LOGE("Could not ref frame: %d", r);
-        return false;
-    }
-
-    // Now that av_frame_ref() succeeded, we can replace the previous
-    // pending_frame
-    swap_frames(&fb->pending_frame, &fb->tmp_frame);
-    av_frame_unref(fb->tmp_frame);
-
-    if (previous_frame_skipped) {
-        *previous_frame_skipped = !fb->pending_frame_consumed;
-    }
-    fb->pending_frame_consumed = false;
-
-    sc_mutex_unlock(&fb->mutex);
-
-    return true;
-}
-
-void
-sc_frame_buffer_consume(struct sc_frame_buffer *fb, AVFrame *dst) {
-    sc_mutex_lock(&fb->mutex);
-    assert(!fb->pending_frame_consumed);
-    fb->pending_frame_consumed = true;
-
-    av_frame_move_ref(dst, fb->pending_frame);
-    // av_frame_move_ref() resets its source frame, so no need to call
-    // av_frame_unref()
-
-    sc_mutex_unlock(&fb->mutex);
-}
--- a/app/src/frame_buffer.h
+++ b/app/src/frame_buffer.h
@@ -1,44 +0,0 @@
-#ifndef SC_FRAME_BUFFER_H
-#define SC_FRAME_BUFFER_H
-
-#include "common.h"
-
-#include <stdbool.h>
-
-#include "util/thread.h"
-
-// forward declarations
-typedef struct AVFrame AVFrame;
-
-/**
- * A frame buffer holds 1 pending frame, which is the last frame received from
- * the producer (typically, the decoder).
- *
- * If a pending frame has not been consumed when the producer pushes a new
- * frame, then it is lost. The intent is to always provide access to the very
- * last frame to minimize latency.
- */
-
-struct sc_frame_buffer {
-    AVFrame *pending_frame;
-    AVFrame *tmp_frame; // To preserve the pending frame on error
-
-    sc_mutex mutex;
-
-    bool pending_frame_consumed;
-};
-
-bool
-sc_frame_buffer_init(struct sc_frame_buffer *fb);
-
-void
-sc_frame_buffer_destroy(struct sc_frame_buffer *fb);
-
-bool
-sc_frame_buffer_push(struct sc_frame_buffer *fb, const AVFrame *frame,
-                     bool *skipped);
-
-void
-sc_frame_buffer_consume(struct sc_frame_buffer *fb, AVFrame *dst);
-
-#endif
--- a/app/src/recorder.c
+++ b/app/src/recorder.c
@@ -51,15 +51,16 @@ record_packet_new(const AVPacket *packet) {

 static void
 record_packet_delete(struct record_packet *rec) {
+    av_packet_unref(rec->packet);
    av_packet_free(&rec->packet);
    free(rec);
 }

 static void
 recorder_queue_clear(struct recorder_queue *queue) {
-    while (!sc_queue_is_empty(queue)) {
+    while (!queue_is_empty(queue)) {
        struct record_packet *rec;
-        sc_queue_take(queue, next, &rec);
+        queue_take(queue, next, &rec);
        record_packet_delete(rec);
    }
 }
@@ -135,14 +136,14 @@ run_recorder(void *data) {
    for (;;) {
        sc_mutex_lock(&recorder->mutex);

-        while (!recorder->stopped && sc_queue_is_empty(&recorder->queue)) {
+        while (!recorder->stopped && queue_is_empty(&recorder->queue)) {
            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 && sc_queue_is_empty(&recorder->queue)) {
+        if (recorder->stopped && queue_is_empty(&recorder->queue)) {
            sc_mutex_unlock(&recorder->mutex);
            struct record_packet *last = recorder->previous;
            if (last) {
@@ -161,7 +162,7 @@ run_recorder(void *data) {
        }

        struct record_packet *rec;
-        sc_queue_take(&recorder->queue, next, &rec);
+        queue_take(&recorder->queue, next, &rec);

        sc_mutex_unlock(&recorder->mutex);

@@ -213,8 +214,7 @@ run_recorder(void *data) {
        LOGE("Recording failed to %s", recorder->filename);
    } else {
        const char *format_name = recorder_get_format_name(recorder->format);
-        LOGI("Recording complete to %s file: %s", format_name,
-                                                  recorder->filename);
+        LOGI("Recording complete to %s file: %s", format_name, recorder->filename);
    }

    LOGD("Recorder thread ended");
@@ -236,7 +236,7 @@ recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
        goto error_mutex_destroy;
    }

-    sc_queue_init(&recorder->queue);
+    queue_init(&recorder->queue);
    recorder->stopped = false;
    recorder->failed = false;
    recorder->header_written = false;
@@ -341,7 +341,7 @@ recorder_push(struct recorder *recorder, const AVPacket *packet) {
        return false;
    }

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

    sc_mutex_unlock(&recorder->mutex);
--- a/app/src/recorder.h
+++ b/app/src/recorder.h
@@ -17,7 +17,7 @@ struct record_packet {
    struct record_packet *next;
 };

-struct recorder_queue SC_QUEUE(struct record_packet);
+struct recorder_queue QUEUE(struct record_packet);

 struct recorder {
    struct sc_packet_sink packet_sink; // packet sink trait
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@@ -330,7 +330,7 @@ scrcpy(const struct scrcpy_options *options) {

    av_log_set_callback(av_log_callback);

-    static const struct stream_callbacks stream_cbs = {
+    const struct stream_callbacks stream_cbs = {
        .on_eos = stream_on_eos,
    };
    stream_init(&s->stream, s->server.video_socket, &stream_cbs, NULL);
@@ -343,29 +343,19 @@ scrcpy(const struct scrcpy_options *options) {
        stream_add_sink(&s->stream, &rec->packet_sink);
    }

-    if (options->control) {
-        if (!controller_init(&s->controller, s->server.control_socket)) {
-            goto end;
-        }
-        controller_initialized = true;
-
-        if (!controller_start(&s->controller)) {
-            goto end;
-        }
-        controller_started = true;
-
-        if (options->turn_screen_off) {
-            struct control_msg msg;
-            msg.type = CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
-            msg.set_screen_power_mode.mode = SCREEN_POWER_MODE_OFF;
-
-            if (!controller_push_msg(&s->controller, &msg)) {
-                LOGW("Could not request 'set screen power mode'");
-            }
-        }
-    }
-
    if (options->display) {
+        if (options->control) {
+            if (!controller_init(&s->controller, s->server.control_socket)) {
+                goto end;
+            }
+            controller_initialized = true;
+
+            if (!controller_start(&s->controller)) {
+                goto end;
+            }
+            controller_started = true;
+        }
+
        const char *window_title =
            options->window_title ? options->window_title : device_name;

@@ -381,7 +371,6 @@ scrcpy(const struct scrcpy_options *options) {
            .rotation = options->rotation,
            .mipmaps = options->mipmaps,
            .fullscreen = options->fullscreen,
-            .buffering_time = options->display_buffer,
        };

        if (!screen_init(&s->screen, &screen_params)) {
@@ -390,12 +379,21 @@ scrcpy(const struct scrcpy_options *options) {
        screen_initialized = true;

        decoder_add_sink(&s->decoder, &s->screen.frame_sink);
+
+        if (options->turn_screen_off) {
+            struct control_msg msg;
+            msg.type = CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE;
+            msg.set_screen_power_mode.mode = SCREEN_POWER_MODE_OFF;
+
+            if (!controller_push_msg(&s->controller, &msg)) {
+                LOGW("Could not request 'set screen power mode'");
+            }
+        }
    }

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

--- a/app/src/scrcpy.h
+++ b/app/src/scrcpy.h
@@ -7,8 +7,6 @@
 #include <stddef.h>
 #include <stdint.h>

-#include "util/tick.h"
-
 enum sc_log_level {
    SC_LOG_LEVEL_VERBOSE,
    SC_LOG_LEVEL_DEBUG,
@@ -80,8 +78,6 @@ struct scrcpy_options {
    uint16_t window_width;
    uint16_t window_height;
    uint32_t display_id;
-    sc_tick display_buffer;
-    sc_tick v4l2_buffer;
    bool show_touches;
    bool fullscreen;
    bool always_on_top;
@@ -130,8 +126,6 @@ struct scrcpy_options {
    .window_width = 0, \
    .window_height = 0, \
    .display_id = 0, \
-    .display_buffer = 0, \
-    .v4l2_buffer = 0, \
    .show_touches = false, \
    .fullscreen = false, \
    .always_on_top = false, \
--- a/app/src/screen.c
+++ b/app/src/screen.c
@@ -274,16 +274,14 @@ screen_frame_sink_close(struct sc_frame_sink *sink) {
 static bool
 screen_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
    struct screen *screen = DOWNCAST(sink);
-    return sc_video_buffer_push(&screen->vb, frame);
-}

-static void
-sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
-                             void *userdata) {
-    (void) vb;
-    struct screen *screen = userdata;
+    bool previous_frame_skipped;
+    bool ok = video_buffer_push(&screen->vb, frame, &previous_frame_skipped);
+    if (!ok) {
+        return false;
+    }

-    if (previous_skipped) {
+    if (previous_frame_skipped) {
        fps_counter_add_skipped_frame(&screen->fps_counter);
        // The EVENT_NEW_FRAME triggered for the previous frame will consume
        // this new frame instead
@@ -295,6 +293,8 @@ sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
        // Post the event on the UI thread
        SDL_PushEvent(&new_frame_event);
    }
+
+    return true;
 }

 bool
@@ -304,26 +304,15 @@ screen_init(struct screen *screen, const struct screen_params *params) {
    screen->fullscreen = false;
    screen->maximized = false;

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

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

    screen->frame_size = params->frame_size;
@@ -464,11 +453,8 @@ error_destroy_window:
    SDL_DestroyWindow(screen->window);
 error_destroy_fps_counter:
    fps_counter_destroy(&screen->fps_counter);
-error_stop_and_join_video_buffer:
-    sc_video_buffer_stop(&screen->vb);
-    sc_video_buffer_join(&screen->vb);
 error_destroy_video_buffer:
-    sc_video_buffer_destroy(&screen->vb);
+    video_buffer_destroy(&screen->vb);

    return false;
 }
@@ -485,13 +471,11 @@ screen_hide_window(struct screen *screen) {

 void
 screen_interrupt(struct screen *screen) {
-    sc_video_buffer_stop(&screen->vb);
    fps_counter_interrupt(&screen->fps_counter);
 }

 void
 screen_join(struct screen *screen) {
-    sc_video_buffer_join(&screen->vb);
    fps_counter_join(&screen->fps_counter);
 }

@@ -505,7 +489,7 @@ screen_destroy(struct screen *screen) {
    SDL_DestroyRenderer(screen->renderer);
    SDL_DestroyWindow(screen->window);
    fps_counter_destroy(&screen->fps_counter);
-    sc_video_buffer_destroy(&screen->vb);
+    video_buffer_destroy(&screen->vb);
 }

 static void
@@ -611,7 +595,7 @@ update_texture(struct screen *screen, const AVFrame *frame) {
 static bool
 screen_update_frame(struct screen *screen) {
    av_frame_unref(screen->frame);
-    sc_video_buffer_consume(&screen->vb, screen->frame);
+    video_buffer_consume(&screen->vb, screen->frame);
    AVFrame *frame = screen->frame;

    fps_counter_add_rendered_frame(&screen->fps_counter);
--- a/app/src/screen.h
+++ b/app/src/screen.h
@@ -8,7 +8,6 @@
 #include <libavformat/avformat.h>

 #include "coords.h"
-#include "fps_counter.h"
 #include "opengl.h"
 #include "trait/frame_sink.h"
 #include "video_buffer.h"
@@ -20,7 +19,7 @@ struct screen {
    bool open; // track the open/close state to assert correct behavior
 #endif

-    struct sc_video_buffer vb;
+    struct video_buffer vb;
    struct fps_counter fps_counter;

    SDL_Window *window;
@@ -63,8 +62,6 @@ struct screen_params {
    bool mipmaps;

    bool fullscreen;
-
-    sc_tick buffering_time;
 };

 // initialize screen, create window, renderer and texture (window is hidden)
--- a/app/src/server.c
+++ b/app/src/server.c
@@ -60,20 +60,7 @@ get_server_path(void) {
        // not found, use current directory
        return strdup(SERVER_FILENAME);
    }
-
-    // dirname() does not work correctly everywhere, so get the parent
-    // directory manually.
-    // See <https://github.com/Genymobile/scrcpy/issues/2619>
-    char *p = strrchr(executable_path, PATH_SEPARATOR);
-    if (!p) {
-        LOGE("Unexpected executable path: \"%s\" (it should contain a '%c')",
-             executable_path, PATH_SEPARATOR);
-        free(executable_path);
-        return strdup(SERVER_FILENAME);
-    }
-
-    *p = '\0'; // modify executable_path in place
-    char *dir = executable_path;
+    char *dir = dirname(executable_path);
    size_t dirlen = strlen(dir);

    // sizeof(SERVER_FILENAME) gives statically the size including the null byte
@@ -274,8 +261,7 @@ execute_server(struct server *server, const struct server_params *params) {
    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(lock_video_orientation_string, "%"PRIi8, params->lock_video_orientation);
    sprintf(display_id_string, "%"PRIu32, params->display_id);
    const char *const cmd[] = {
        "shell",
@@ -285,8 +271,7 @@ execute_server(struct server *server, const struct server_params *params) {
 # define SERVER_DEBUGGER_PORT "5005"
 # ifdef SERVER_DEBUGGER_METHOD_NEW
        /* Android 9 and above */
-        "-XjdwpProvider:internal -XjdwpOptions:transport=dt_socket,suspend=y,"
-        "server=y,address="
+        "-XjdwpProvider:internal -XjdwpOptions:transport=dt_socket,suspend=y,server=y,address="
 # else
        /* Android 8 and below */
        "-agentlib:jdwp=transport=dt_socket,suspend=y,server=y,address="
@@ -483,7 +468,7 @@ error:
 static bool
 device_read_info(socket_t device_socket, char *device_name, struct size *size) {
    unsigned char buf[DEVICE_NAME_FIELD_LENGTH + 4];
-    ssize_t r = net_recv_all(device_socket, buf, sizeof(buf));
+    int r = net_recv_all(device_socket, buf, sizeof(buf));
    if (r < DEVICE_NAME_FIELD_LENGTH + 4) {
        LOGE("Could not retrieve device information");
        return false;
@@ -569,10 +554,10 @@ server_stop(struct server *server) {
    sc_mutex_lock(&server->mutex);
    bool signaled = false;
    if (!server->process_terminated) {
-#define WATCHDOG_DELAY SC_TICK_FROM_SEC(1)
+#define WATCHDOG_DELAY_MS 1000
        signaled = sc_cond_timedwait(&server->process_terminated_cond,
                                     &server->mutex,
-                                     sc_tick_now() + WATCHDOG_DELAY);
+                                     WATCHDOG_DELAY_MS);
    }
    sc_mutex_unlock(&server->mutex);

--- a/app/src/stream.c
+++ b/app/src/stream.c
@@ -151,6 +151,7 @@ stream_push_packet(struct stream *stream, AVPacket *packet) {

        if (stream->pending) {
            // the pending packet must be discarded (consumed or error)
+            av_packet_unref(stream->pending);
            av_packet_free(&stream->pending);
        }

@@ -243,6 +244,7 @@ run_stream(void *data) {
    LOGD("End of frames");

    if (stream->pending) {
+        av_packet_unref(stream->pending);
        av_packet_free(&stream->pending);
    }

--- a/app/src/util/net.c
+++ b/app/src/util/net.c
@@ -19,27 +19,11 @@
  typedef struct in_addr IN_ADDR;
 #endif

-static void
-net_perror(const char *s) {
-#ifdef _WIN32
-    int error = WSAGetLastError();
-    char *wsa_message;
-    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
-            NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-            (char *) &wsa_message, 0, NULL);
-    // no explicit '\n', wsa_message already contains a trailing '\n'
-    fprintf(stderr, "%s: [%d] %s", s, error, wsa_message);
-    LocalFree(wsa_message);
-#else
-    perror(s);
-#endif
-}
-
 socket_t
 net_connect(uint32_t addr, uint16_t port) {
    socket_t sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock == INVALID_SOCKET) {
-        net_perror("socket");
+        perror("socket");
        return INVALID_SOCKET;
    }

@@ -49,7 +33,7 @@ net_connect(uint32_t addr, uint16_t port) {
    sin.sin_port = htons(port);

    if (connect(sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
-        net_perror("connect");
+        perror("connect");
        net_close(sock);
        return INVALID_SOCKET;
    }
@@ -61,14 +45,14 @@ socket_t
 net_listen(uint32_t addr, uint16_t port, int backlog) {
    socket_t sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock == INVALID_SOCKET) {
-        net_perror("socket");
+        perror("socket");
        return INVALID_SOCKET;
    }

    int reuse = 1;
    if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuse,
                   sizeof(reuse)) == -1) {
-        net_perror("setsockopt(SO_REUSEADDR)");
+        perror("setsockopt(SO_REUSEADDR)");
    }

    SOCKADDR_IN sin;
@@ -77,13 +61,13 @@ net_listen(uint32_t addr, uint16_t port, int backlog) {
    sin.sin_port = htons(port);

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

    if (listen(sock, backlog) == SOCKET_ERROR) {
-        net_perror("listen");
+        perror("listen");
        net_close(sock);
        return INVALID_SOCKET;
    }
@@ -115,18 +99,16 @@ net_send(socket_t socket, const void *buf, size_t len) {

 ssize_t
 net_send_all(socket_t socket, const void *buf, size_t len) {
-    size_t copied = 0;
    ssize_t w = 0;
    while (len > 0) {
        w = send(socket, buf, len, 0);
        if (w == -1) {
-            return copied ? (ssize_t) copied : -1;
+            return -1;
        }
        len -= w;
        buf = (char *) buf + w;
-        copied += w;
    }
-    return copied;
+    return w;
 }

 bool
--- a/app/src/util/queue.h
+++ b/app/src/util/queue.h
@@ -1,6 +1,6 @@
 // generic intrusive FIFO queue
-#ifndef SC_QUEUE_H
-#define SC_QUEUE_H
+#ifndef QUEUE_H
+#define QUEUE_H

 #include "common.h"

@@ -10,15 +10,15 @@

 // To define a queue type of "struct foo":
 //    struct queue_foo QUEUE(struct foo);
-#define SC_QUEUE(TYPE) { \
+#define QUEUE(TYPE) { \
    TYPE *first; \
    TYPE *last; \
 }

-#define sc_queue_init(PQ) \
+#define queue_init(PQ) \
    (void) ((PQ)->first = (PQ)->last = NULL)

-#define sc_queue_is_empty(PQ) \
+#define queue_is_empty(PQ) \
    !(PQ)->first

 // NEXTFIELD is the field in the ITEM type used for intrusive linked-list
@@ -30,30 +30,30 @@
 //    };
 //
 //    // define the type "struct my_queue"
-//    struct my_queue SC_QUEUE(struct foo);
+//    struct my_queue QUEUE(struct foo);
 //
 //    struct my_queue queue;
-//    sc_queue_init(&queue);
+//    queue_init(&queue);
 //
 //    struct foo v1 = { .value = 42 };
 //    struct foo v2 = { .value = 27 };
 //
-//    sc_queue_push(&queue, next, v1);
-//    sc_queue_push(&queue, next, v2);
+//    queue_push(&queue, next, v1);
+//    queue_push(&queue, next, v2);
 //
 //    struct foo *foo;
-//    sc_queue_take(&queue, next, &foo);
+//    queue_take(&queue, next, &foo);
 //    assert(foo->value == 42);
-//    sc_queue_take(&queue, next, &foo);
+//    queue_take(&queue, next, &foo);
 //    assert(foo->value == 27);
-//    assert(sc_queue_is_empty(&queue));
+//    assert(queue_is_empty(&queue));
 //

 // push a new item into the queue
-#define sc_queue_push(PQ, NEXTFIELD, ITEM) \
+#define queue_push(PQ, NEXTFIELD, ITEM) \
    (void) ({ \
        (ITEM)->NEXTFIELD = NULL; \
-        if (sc_queue_is_empty(PQ)) { \
+        if (queue_is_empty(PQ)) { \
            (PQ)->first = (PQ)->last = (ITEM); \
        } else { \
            (PQ)->last->NEXTFIELD = (ITEM); \
@@ -65,9 +65,9 @@
 // the result is stored in *(PITEM)
 // (without typeof(), we could not store a local variable having the correct
 // type so that we can "return" it)
-#define sc_queue_take(PQ, NEXTFIELD, PITEM) \
+#define queue_take(PQ, NEXTFIELD, PITEM) \
    (void) ({ \
-        assert(!sc_queue_is_empty(PQ)); \
+        assert(!queue_is_empty(PQ)); \
        *(PITEM) = (PQ)->first; \
        (PQ)->first = (PQ)->first->NEXTFIELD; \
    })
--- a/app/src/util/thread.c
+++ b/app/src/util/thread.c
@@ -31,7 +31,7 @@ sc_mutex_init(sc_mutex *mutex) {

    mutex->mutex = sdl_mutex;
 #ifndef NDEBUG
-    atomic_init(&mutex->locker, 0);
+    mutex->locker = 0;
 #endif
    return true;
 }
@@ -52,8 +52,7 @@ sc_mutex_lock(sc_mutex *mutex) {
        abort();
    }

-    atomic_store_explicit(&mutex->locker, sc_thread_get_id(),
-                          memory_order_relaxed);
+    mutex->locker = sc_thread_get_id();
 #else
    (void) r;
 #endif
@@ -63,7 +62,7 @@ void
 sc_mutex_unlock(sc_mutex *mutex) {
 #ifndef NDEBUG
    assert(sc_mutex_held(mutex));
-    atomic_store_explicit(&mutex->locker, 0, memory_order_relaxed);
+    mutex->locker = 0;
 #endif
    int r = SDL_UnlockMutex(mutex->mutex);
 #ifndef NDEBUG
@@ -84,9 +83,7 @@ sc_thread_get_id(void) {
 #ifndef NDEBUG
 bool
 sc_mutex_held(struct sc_mutex *mutex) {
-    sc_thread_id locker_id =
-        atomic_load_explicit(&mutex->locker, memory_order_relaxed);
-    return locker_id == sc_thread_get_id();
+    return mutex->locker == sc_thread_get_id();
 }
 #endif

@@ -115,21 +112,14 @@ sc_cond_wait(sc_cond *cond, sc_mutex *mutex) {
        abort();
    }

-    atomic_store_explicit(&mutex->locker, sc_thread_get_id(),
-                          memory_order_relaxed);
+    mutex->locker = sc_thread_get_id();
 #else
    (void) r;
 #endif
 }

 bool
-sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, sc_tick deadline) {
-    sc_tick now = sc_tick_now();
-    if (deadline <= now) {
-        return false; // timeout
-    }
-
-    uint32_t ms = SC_TICK_TO_MS(deadline - now);
+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) {
@@ -137,8 +127,7 @@ sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, sc_tick deadline) {
        abort();
    }

-    atomic_store_explicit(&mutex->locker, sc_thread_get_id(),
-                          memory_order_relaxed);
+    mutex->locker = sc_thread_get_id();
 #endif
    assert(r == 0 || r == SDL_MUTEX_TIMEDOUT);
    return r == 0;
--- a/app/src/util/thread.h
+++ b/app/src/util/thread.h
@@ -3,10 +3,8 @@

 #include "common.h"

-#include <stdatomic.h>
 #include <stdbool.h>
-
-#include "tick.h"
+#include <stdint.h>

 /* Forward declarations */
 typedef struct SDL_Thread SDL_Thread;
@@ -14,8 +12,7 @@ typedef struct SDL_mutex SDL_mutex;
 typedef struct SDL_cond SDL_cond;

 typedef int sc_thread_fn(void *);
-typedef unsigned sc_thread_id;
-typedef atomic_uint sc_atomic_thread_id;
+typedef unsigned int sc_thread_id;

 typedef struct sc_thread {
    SDL_Thread *thread;
@@ -24,7 +21,7 @@ typedef struct sc_thread {
 typedef struct sc_mutex {
    SDL_mutex *mutex;
 #ifndef NDEBUG
-    sc_atomic_thread_id locker;
+    sc_thread_id locker;
 #endif
 } sc_mutex;

@@ -73,7 +70,7 @@ 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, sc_tick deadline);
+sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, uint32_t ms);

 void
 sc_cond_signal(sc_cond *cond);
--- a/app/src/util/tick.c
+++ b/app/src/util/tick.c
@@ -1,16 +0,0 @@
-#include "tick.h"
-
-#include <SDL2/SDL_timer.h>
-
-sc_tick
-sc_tick_now(void) {
-    // SDL_GetTicks() resolution is in milliseconds, but sc_tick are expressed
-    // in microseconds to store PTS without precision loss.
-    //
-    // As an alternative, SDL_GetPerformanceCounter() and
-    // SDL_GetPerformanceFrequency() could be used, but:
-    //  - the conversions (avoiding overflow) are expansive, since the
-    //    frequency is not known at compile time;
-    //  - in practice, we don't need more precision for now.
-    return (sc_tick) SDL_GetTicks() * 1000;
-}
--- a/app/src/util/tick.h
+++ b/app/src/util/tick.h
@@ -1,21 +0,0 @@
-#ifndef SC_TICK_H
-#define SC_TICK_H
-
-#include <stdint.h>
-
-typedef int64_t sc_tick;
-#define PRItick PRIi64
-#define SC_TICK_FREQ 1000000 // microsecond
-
-// To be adapted if SC_TICK_FREQ changes
-#define SC_TICK_TO_US(tick) (tick)
-#define SC_TICK_TO_MS(tick) ((tick) / 1000)
-#define SC_TICK_TO_SEC(tick) ((tick) / 1000000)
-#define SC_TICK_FROM_US(us) (us)
-#define SC_TICK_FROM_MS(ms) ((ms) * 1000)
-#define SC_TICK_FROM_SEC(sec) ((sec) * 1000000)
-
-sc_tick
-sc_tick_now(void);
-
-#endif
--- a/app/src/v4l2_sink.c
+++ b/app/src/v4l2_sink.c
@@ -112,7 +112,7 @@ run_v4l2_sink(void *data) {
    for (;;) {
        sc_mutex_lock(&vs->mutex);

-        while (!vs->stopped && !vs->has_frame) {
+        while (!vs->stopped && vs->vb.pending_frame_consumed) {
            sc_cond_wait(&vs->cond, &vs->mutex);
        }

@@ -121,11 +121,9 @@ run_v4l2_sink(void *data) {
            break;
        }

-        vs->has_frame = false;
        sc_mutex_unlock(&vs->mutex);

-        sc_video_buffer_consume(&vs->vb, vs->frame);
-
+        video_buffer_consume(&vs->vb, vs->frame);
        bool ok = encode_and_write_frame(vs, vs->frame);
        av_frame_unref(vs->frame);
        if (!ok) {
@@ -139,42 +137,17 @@ run_v4l2_sink(void *data) {
    return 0;
 }

-static void
-sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
-                             void *userdata) {
-    (void) vb;
-    struct sc_v4l2_sink *vs = userdata;
-
-    if (!previous_skipped) {
-        sc_mutex_lock(&vs->mutex);
-        vs->has_frame = true;
-        sc_cond_signal(&vs->cond);
-        sc_mutex_unlock(&vs->mutex);
-    }
-}
-
 static bool
 sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
-    static const struct sc_video_buffer_callbacks cbs = {
-        .on_new_frame = sc_video_buffer_on_new_frame,
-    };
-
-    bool ok = sc_video_buffer_init(&vs->vb, vs->buffering_time, &cbs, vs);
+    bool ok = video_buffer_init(&vs->vb);
    if (!ok) {
-        LOGE("Could not initialize video buffer");
        return false;
    }

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

    ok = sc_cond_init(&vs->cond);
@@ -268,10 +241,6 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
        goto error_av_frame_free;
    }

-    vs->has_frame = false;
-    vs->header_written = false;
-    vs->stopped = false;
-
    LOGD("Starting v4l2 thread");
    ok = sc_thread_create(&vs->thread, run_v4l2_sink, "v4l2", vs);
    if (!ok) {
@@ -279,6 +248,9 @@ sc_v4l2_sink_open(struct sc_v4l2_sink *vs) {
        goto error_av_packet_free;
    }

+    vs->header_written = false;
+    vs->stopped = false;
+
    LOGI("v4l2 sink started to device: %s", vs->device_name);

    return true;
@@ -299,11 +271,8 @@ error_cond_destroy:
    sc_cond_destroy(&vs->cond);
 error_mutex_destroy:
    sc_mutex_destroy(&vs->mutex);
-error_video_buffer_stop_and_join:
-    sc_video_buffer_stop(&vs->vb);
-    sc_video_buffer_join(&vs->vb);
 error_video_buffer_destroy:
-    sc_video_buffer_destroy(&vs->vb);
+    video_buffer_destroy(&vs->vb);

    return false;
 }
@@ -315,10 +284,7 @@ sc_v4l2_sink_close(struct sc_v4l2_sink *vs) {
    sc_cond_signal(&vs->cond);
    sc_mutex_unlock(&vs->mutex);

-    sc_video_buffer_stop(&vs->vb);
-
    sc_thread_join(&vs->thread, NULL);
-    sc_video_buffer_join(&vs->vb);

    av_packet_free(&vs->packet);
    av_frame_free(&vs->frame);
@@ -328,12 +294,20 @@ sc_v4l2_sink_close(struct sc_v4l2_sink *vs) {
    avformat_free_context(vs->format_ctx);
    sc_cond_destroy(&vs->cond);
    sc_mutex_destroy(&vs->mutex);
-    sc_video_buffer_destroy(&vs->vb);
+    video_buffer_destroy(&vs->vb);
 }

 static bool
 sc_v4l2_sink_push(struct sc_v4l2_sink *vs, const AVFrame *frame) {
-    return sc_video_buffer_push(&vs->vb, frame);
+    bool ok = video_buffer_push(&vs->vb, frame, NULL);
+    if (!ok) {
+        return false;
+    }
+
+    // signal possible change of vs->vb.pending_frame_consumed
+    sc_cond_signal(&vs->cond);
+
+    return true;
 }

 static bool
@@ -356,7 +330,7 @@ sc_v4l2_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {

 bool
 sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
-                  struct size frame_size, sc_tick buffering_time) {
+                  struct size frame_size) {
    vs->device_name = strdup(device_name);
    if (!vs->device_name) {
        LOGE("Could not strdup v4l2 device name");
@@ -364,7 +338,6 @@ sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
    }

    vs->frame_size = frame_size;
-    vs->buffering_time = buffering_time;

    static const struct sc_frame_sink_ops ops = {
        .open = sc_v4l2_frame_sink_open,
--- a/app/src/v4l2_sink.h
+++ b/app/src/v4l2_sink.h
@@ -6,25 +6,22 @@
 #include "coords.h"
 #include "trait/frame_sink.h"
 #include "video_buffer.h"
-#include "util/tick.h"

 #include <libavformat/avformat.h>

 struct sc_v4l2_sink {
    struct sc_frame_sink frame_sink; // frame sink trait

-    struct sc_video_buffer vb;
+    struct video_buffer vb;
    AVFormatContext *format_ctx;
    AVCodecContext *encoder_ctx;

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

    sc_thread thread;
    sc_mutex mutex;
    sc_cond cond;
-    bool has_frame;
    bool stopped;
    bool header_written;

@@ -34,7 +31,7 @@ struct sc_v4l2_sink {

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

 void
 sc_v4l2_sink_destroy(struct sc_v4l2_sink *vs);
--- a/app/src/video_buffer.c
+++ b/app/src/video_buffer.c
@@ -1,255 +1,88 @@
 #include "video_buffer.h"

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

 #include "util/log.h"

-#define SC_BUFFERING_NDEBUG // comment to debug
-
-static struct sc_video_buffer_frame *
-sc_video_buffer_frame_new(const AVFrame *frame) {
-    struct sc_video_buffer_frame *vb_frame = malloc(sizeof(*vb_frame));
-    if (!vb_frame) {
-        return NULL;
+bool
+video_buffer_init(struct video_buffer *vb) {
+    vb->pending_frame = av_frame_alloc();
+    if (!vb->pending_frame) {
+        return false;
    }

-    vb_frame->frame = av_frame_alloc();
-    if (!vb_frame->frame) {
-        free(vb_frame);
-        return NULL;
+    vb->tmp_frame = av_frame_alloc();
+    if (!vb->tmp_frame) {
+        av_frame_free(&vb->pending_frame);
+        return false;
    }

-    if (av_frame_ref(vb_frame->frame, frame)) {
-        av_frame_free(&vb_frame->frame);
-        free(vb_frame);
-        return NULL;
-    }
-
-    return vb_frame;
-}
-
-static void
-sc_video_buffer_frame_delete(struct sc_video_buffer_frame *vb_frame) {
-    av_frame_unref(vb_frame->frame);
-    av_frame_free(&vb_frame->frame);
-    free(vb_frame);
-}
-
-static bool
-sc_video_buffer_offer(struct sc_video_buffer *vb, const AVFrame *frame) {
-    bool previous_skipped;
-    bool ok = sc_frame_buffer_push(&vb->fb, frame, &previous_skipped);
+    bool ok = sc_mutex_init(&vb->mutex);
    if (!ok) {
+        av_frame_free(&vb->pending_frame);
+        av_frame_free(&vb->tmp_frame);
        return false;
    }

-    vb->cbs->on_new_frame(vb, previous_skipped, vb->cbs_userdata);
+    // there is initially no frame, so consider it has already been consumed
+    vb->pending_frame_consumed = true;
+
    return true;
 }

-static int
-run_buffering(void *data) {
-    struct sc_video_buffer *vb = data;
+void
+video_buffer_destroy(struct video_buffer *vb) {
+    sc_mutex_destroy(&vb->mutex);
+    av_frame_free(&vb->pending_frame);
+    av_frame_free(&vb->tmp_frame);
+}

-    assert(vb->buffering_time > 0);
-
-    for (;;) {
-        sc_mutex_lock(&vb->b.mutex);
-
-        while (!vb->b.stopped && sc_queue_is_empty(&vb->b.queue)) {
-            sc_cond_wait(&vb->b.queue_cond, &vb->b.mutex);
-        }
-
-        if (vb->b.stopped) {
-            sc_mutex_unlock(&vb->b.mutex);
-            goto stopped;
-        }
-
-        struct sc_video_buffer_frame *vb_frame;
-        sc_queue_take(&vb->b.queue, next, &vb_frame);
-
-        sc_tick max_deadline = sc_tick_now() + vb->buffering_time;
-        // PTS (written by the server) are expressed in microseconds
-        sc_tick pts = SC_TICK_TO_US(vb_frame->frame->pts);
-
-        bool timed_out = false;
-        while (!vb->b.stopped && !timed_out) {
-            sc_tick deadline = sc_clock_to_system_time(&vb->b.clock, pts)
-                             + vb->buffering_time;
-            if (deadline > max_deadline) {
-                deadline = max_deadline;
-            }
-
-            timed_out =
-                !sc_cond_timedwait(&vb->b.wait_cond, &vb->b.mutex, deadline);
-        }
-
-        if (vb->b.stopped) {
-            sc_video_buffer_frame_delete(vb_frame);
-            sc_mutex_unlock(&vb->b.mutex);
-            goto stopped;
-        }
-
-        sc_mutex_unlock(&vb->b.mutex);
-
-#ifndef SC_BUFFERING_NDEBUG
-        LOGD("Buffering: %" PRItick ";%" PRItick ";%" PRItick,
-             pts, vb_frame->push_date, sc_tick_now());
-#endif
-
-        sc_video_buffer_offer(vb, vb_frame->frame);
-
-        sc_video_buffer_frame_delete(vb_frame);
-    }
-
-stopped:
-    // Flush queue
-    while (!sc_queue_is_empty(&vb->b.queue)) {
-        struct sc_video_buffer_frame *vb_frame;
-        sc_queue_take(&vb->b.queue, next, &vb_frame);
-        sc_video_buffer_frame_delete(vb_frame);
-    }
-
-    LOGD("Buffering thread ended");
-
-    return 0;
+static inline void
+swap_frames(AVFrame **lhs, AVFrame **rhs) {
+    AVFrame *tmp = *lhs;
+    *lhs = *rhs;
+    *rhs = tmp;
 }

 bool
-sc_video_buffer_init(struct sc_video_buffer *vb, sc_tick buffering_time,
-                     const struct sc_video_buffer_callbacks *cbs,
-                     void *cbs_userdata) {
-    bool ok = sc_frame_buffer_init(&vb->fb);
-    if (!ok) {
+video_buffer_push(struct video_buffer *vb, const AVFrame *frame,
+                  bool *previous_frame_skipped) {
+    sc_mutex_lock(&vb->mutex);
+
+    // Use a temporary frame to preserve pending_frame in case of error.
+    // tmp_frame is an empty frame, no need to call av_frame_unref() beforehand.
+    int r = av_frame_ref(vb->tmp_frame, frame);
+    if (r) {
+        LOGE("Could not ref frame: %d", r);
        return false;
    }

-    assert(buffering_time >= 0);
-    if (buffering_time) {
-        ok = sc_mutex_init(&vb->b.mutex);
-        if (!ok) {
-            LOGC("Could not create mutex");
-            sc_frame_buffer_destroy(&vb->fb);
-            return false;
-        }
+    // Now that av_frame_ref() succeeded, we can replace the previous
+    // pending_frame
+    swap_frames(&vb->pending_frame, &vb->tmp_frame);
+    av_frame_unref(vb->tmp_frame);

-        ok = sc_cond_init(&vb->b.queue_cond);
-        if (!ok) {
-            LOGC("Could not create cond");
-            sc_mutex_destroy(&vb->b.mutex);
-            sc_frame_buffer_destroy(&vb->fb);
-            return false;
-        }
-
-        ok = sc_cond_init(&vb->b.wait_cond);
-        if (!ok) {
-            LOGC("Could not create wait cond");
-            sc_cond_destroy(&vb->b.queue_cond);
-            sc_mutex_destroy(&vb->b.mutex);
-            sc_frame_buffer_destroy(&vb->fb);
-            return false;
-        }
-
-        sc_clock_init(&vb->b.clock);
-        sc_queue_init(&vb->b.queue);
+    if (previous_frame_skipped) {
+        *previous_frame_skipped = !vb->pending_frame_consumed;
    }
+    vb->pending_frame_consumed = false;

-    assert(cbs);
-    assert(cbs->on_new_frame);
-
-    vb->buffering_time = buffering_time;
-    vb->cbs = cbs;
-    vb->cbs_userdata = cbs_userdata;
-    return true;
-}
-
-bool
-sc_video_buffer_start(struct sc_video_buffer *vb) {
-    if (vb->buffering_time) {
-        bool ok =
-            sc_thread_create(&vb->b.thread, run_buffering, "buffering", vb);
-        if (!ok) {
-            LOGE("Could not start buffering thread");
-            return false;
-        }
-    }
+    sc_mutex_unlock(&vb->mutex);

    return true;
 }

 void
-sc_video_buffer_stop(struct sc_video_buffer *vb) {
-    if (vb->buffering_time) {
-        sc_mutex_lock(&vb->b.mutex);
-        vb->b.stopped = true;
-        sc_cond_signal(&vb->b.queue_cond);
-        sc_cond_signal(&vb->b.wait_cond);
-        sc_mutex_unlock(&vb->b.mutex);
-    }
-}
-
-void
-sc_video_buffer_join(struct sc_video_buffer *vb) {
-    if (vb->buffering_time) {
-        sc_thread_join(&vb->b.thread, NULL);
-    }
-}
-
-void
-sc_video_buffer_destroy(struct sc_video_buffer *vb) {
-    sc_frame_buffer_destroy(&vb->fb);
-    if (vb->buffering_time) {
-        sc_cond_destroy(&vb->b.wait_cond);
-        sc_cond_destroy(&vb->b.queue_cond);
-        sc_mutex_destroy(&vb->b.mutex);
-    }
-}
-
-bool
-sc_video_buffer_push(struct sc_video_buffer *vb, const AVFrame *frame) {
-    if (!vb->buffering_time) {
-        // No buffering
-        return sc_video_buffer_offer(vb, frame);
-    }
-
-    sc_mutex_lock(&vb->b.mutex);
-
-    sc_tick pts = SC_TICK_FROM_US(frame->pts);
-    sc_clock_update(&vb->b.clock, sc_tick_now(), pts);
-    sc_cond_signal(&vb->b.wait_cond);
-
-    if (vb->b.clock.count == 1) {
-        sc_mutex_unlock(&vb->b.mutex);
-        // First frame, offer it immediately, for two reasons:
-        //  - not to delay the opening of the scrcpy window
-        //  - the buffering estimation needs at least two clock points, so it
-        //  could not handle the first frame
-        return sc_video_buffer_offer(vb, frame);
-    }
-
-    struct sc_video_buffer_frame *vb_frame = sc_video_buffer_frame_new(frame);
-    if (!vb_frame) {
-        sc_mutex_unlock(&vb->b.mutex);
-        LOGE("Could not allocate frame");
-        return false;
-    }
-
-#ifndef SC_BUFFERING_NDEBUG
-    vb_frame->push_date = sc_tick_now();
-#endif
-    sc_queue_push(&vb->b.queue, next, vb_frame);
-    sc_cond_signal(&vb->b.queue_cond);
-
-    sc_mutex_unlock(&vb->b.mutex);
-
-    return true;
-}
-
-void
-sc_video_buffer_consume(struct sc_video_buffer *vb, AVFrame *dst) {
-    sc_frame_buffer_consume(&vb->fb, dst);
+video_buffer_consume(struct video_buffer *vb, AVFrame *dst) {
+    sc_mutex_lock(&vb->mutex);
+    assert(!vb->pending_frame_consumed);
+    vb->pending_frame_consumed = true;
+
+    av_frame_move_ref(dst, vb->pending_frame);
+    // av_frame_move_ref() resets its source frame, so no need to call
+    // av_frame_unref()
+
+    sc_mutex_unlock(&vb->mutex);
 }
--- a/app/src/video_buffer.h
+++ b/app/src/video_buffer.h
@@ -1,76 +1,50 @@
-#ifndef SC_VIDEO_BUFFER_H
-#define SC_VIDEO_BUFFER_H
+#ifndef VIDEO_BUFFER_H
+#define VIDEO_BUFFER_H

 #include "common.h"

 #include <stdbool.h>

-#include "clock.h"
-#include "frame_buffer.h"
-#include "util/queue.h"
+#include "fps_counter.h"
 #include "util/thread.h"
-#include "util/tick.h"

 // forward declarations
 typedef struct AVFrame AVFrame;

-struct sc_video_buffer_frame {
-    AVFrame *frame;
-    struct sc_video_buffer_frame *next;
-#ifndef NDEBUG
-    sc_tick push_date;
-#endif
-};
+/**
+ * A video buffer holds 1 pending frame, which is the last frame received from
+ * the producer (typically, the decoder).
+ *
+ * If a pending frame has not been consumed when the producer pushes a new
+ * frame, then it is lost. The intent is to always provide access to the very
+ * last frame to minimize latency.
+ *
+ * The producer and the consumer typically do not live in the same thread.
+ * That's the reason why the callback on_frame_available() does not provide the
+ * frame as parameter: the consumer might post an event to its own thread to
+ * retrieve the pending frame from there, and that frame may have changed since
+ * the callback if producer pushed a new one in between.
+ */

-struct sc_video_buffer_frame_queue SC_QUEUE(struct sc_video_buffer_frame);
+struct video_buffer {
+    AVFrame *pending_frame;
+    AVFrame *tmp_frame; // To preserve the pending frame on error

-struct sc_video_buffer {
-    struct sc_frame_buffer fb;
+    sc_mutex mutex;

-    sc_tick buffering_time;
-
-    // only if buffering_time > 0
-    struct {
-        sc_thread thread;
-        sc_mutex mutex;
-        sc_cond queue_cond;
-        sc_cond wait_cond;
-
-        struct sc_clock clock;
-        struct sc_video_buffer_frame_queue queue;
-        bool stopped;
-    } b; // buffering
-
-    const struct sc_video_buffer_callbacks *cbs;
-    void *cbs_userdata;
-};
-
-struct sc_video_buffer_callbacks {
-    void (*on_new_frame)(struct sc_video_buffer *vb, bool previous_skipped,
-                         void *userdata);
+    bool pending_frame_consumed;
 };

 bool
-sc_video_buffer_init(struct sc_video_buffer *vb, sc_tick buffering_time,
-                     const struct sc_video_buffer_callbacks *cbs,
-                     void *cbs_userdata);
+video_buffer_init(struct video_buffer *vb);
+
+void
+video_buffer_destroy(struct video_buffer *vb);

 bool
-sc_video_buffer_start(struct sc_video_buffer *vb);
+video_buffer_push(struct video_buffer *vb, const AVFrame *frame, bool *skipped);

 void
-sc_video_buffer_stop(struct sc_video_buffer *vb);
-
-void
-sc_video_buffer_join(struct sc_video_buffer *vb);
-
-void
-sc_video_buffer_destroy(struct sc_video_buffer *vb);
-
-bool
-sc_video_buffer_push(struct sc_video_buffer *vb, const AVFrame *frame);
-
-void
-sc_video_buffer_consume(struct sc_video_buffer *vb, AVFrame *dst);
+video_buffer_consume(struct video_buffer *vb, AVFrame *dst);

 #endif
--- a/app/tests/test_clock.c
+++ b/app/tests/test_clock.c
@@ -1,79 +0,0 @@
-#include "common.h"
-
-#include <assert.h>
-
-#include "clock.h"
-
-void test_small_rolling_sum(void) {
-    struct sc_clock clock;
-    sc_clock_init(&clock);
-
-    assert(clock.count == 0);
-    assert(clock.left_sum.system == 0);
-    assert(clock.left_sum.stream == 0);
-    assert(clock.right_sum.system == 0);
-    assert(clock.right_sum.stream == 0);
-
-    sc_clock_update(&clock, 2, 3);
-    assert(clock.count == 1);
-    assert(clock.left_sum.system == 0);
-    assert(clock.left_sum.stream == 0);
-    assert(clock.right_sum.system == 2);
-    assert(clock.right_sum.stream == 3);
-
-    sc_clock_update(&clock, 10, 20);
-    assert(clock.count == 2);
-    assert(clock.left_sum.system == 2);
-    assert(clock.left_sum.stream == 3);
-    assert(clock.right_sum.system == 10);
-    assert(clock.right_sum.stream == 20);
-
-    sc_clock_update(&clock, 40, 80);
-    assert(clock.count == 3);
-    assert(clock.left_sum.system == 2);
-    assert(clock.left_sum.stream == 3);
-    assert(clock.right_sum.system == 50);
-    assert(clock.right_sum.stream == 100);
-
-    sc_clock_update(&clock, 400, 800);
-    assert(clock.count == 4);
-    assert(clock.left_sum.system == 12);
-    assert(clock.left_sum.stream == 23);
-    assert(clock.right_sum.system == 440);
-    assert(clock.right_sum.stream == 880);
-}
-
-void test_large_rolling_sum(void) {
-    const unsigned half_range = SC_CLOCK_RANGE / 2;
-
-    struct sc_clock clock1;
-    sc_clock_init(&clock1);
-    for (unsigned i = 0; i < 5 * half_range; ++i) {
-        sc_clock_update(&clock1, i, 2 * i + 1);
-    }
-
-    struct sc_clock clock2;
-    sc_clock_init(&clock2);
-    for (unsigned i = 3 * half_range; i < 5 * half_range; ++i) {
-        sc_clock_update(&clock2, i, 2 * i + 1);
-    }
-
-    assert(clock1.count == SC_CLOCK_RANGE);
-    assert(clock2.count == SC_CLOCK_RANGE);
-
-    // The values before the last SC_CLOCK_RANGE points in clock1 should have
-    // no impact
-    assert(clock1.left_sum.system == clock2.left_sum.system);
-    assert(clock1.left_sum.stream == clock2.left_sum.stream);
-    assert(clock1.right_sum.system == clock2.right_sum.system);
-    assert(clock1.right_sum.stream == clock2.right_sum.stream);
-}
-
-int main(int argc, char *argv[]) {
-    (void) argc;
-    (void) argv;
-
-    test_small_rolling_sum();
-    test_large_rolling_sum();
-    return 0;
-};
--- a/app/tests/test_queue.c
+++ b/app/tests/test_queue.c
@@ -10,28 +10,28 @@ struct foo {
 };

 static void test_queue(void) {
-    struct my_queue SC_QUEUE(struct foo) queue;
-    sc_queue_init(&queue);
+    struct my_queue QUEUE(struct foo) queue;
+    queue_init(&queue);

-    assert(sc_queue_is_empty(&queue));
+    assert(queue_is_empty(&queue));

    struct foo v1 = { .value = 42 };
    struct foo v2 = { .value = 27 };

-    sc_queue_push(&queue, next, &v1);
-    sc_queue_push(&queue, next, &v2);
+    queue_push(&queue, next, &v1);
+    queue_push(&queue, next, &v2);

    struct foo *foo;

-    assert(!sc_queue_is_empty(&queue));
-    sc_queue_take(&queue, next, &foo);
+    assert(!queue_is_empty(&queue));
+    queue_take(&queue, next, &foo);
    assert(foo->value == 42);

-    assert(!sc_queue_is_empty(&queue));
-    sc_queue_take(&queue, next, &foo);
+    assert(!queue_is_empty(&queue));
+    queue_take(&queue, next, &foo);
    assert(foo->value == 27);

-    assert(sc_queue_is_empty(&queue));
+    assert(queue_is_empty(&queue));
 }

 int main(int argc, char *argv[]) {
--- 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.16/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.16/x86_64-w64-mingw32'
+prebuilt_sdl2 = 'SDL2-2.0.14/x86_64-w64-mingw32'
--- a/prebuilt-deps/Makefile
+++ b/prebuilt-deps/Makefile
@@ -30,11 +30,11 @@ prepare-ffmpeg-dev-win64:
 		ffmpeg-4.3.1-win64-dev

 prepare-sdl2:
-	@./prepare-dep https://libsdl.org/release/SDL2-devel-2.0.16-mingw.tar.gz \
-		2bfe48628aa9635c12eac7d421907e291525de1d0b04b3bca4a5bd6e6c881a6f \
-		SDL2-2.0.16
+	@./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_r31.0.3-windows.zip \
-		0f4b8fdd26af2c3733539d6eebb3c2ed499ea1d4bb1f4e0ecc2d6016961a6e24 \
+	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r31.0.2-windows.zip \
+		d560cb8ded83ae04763b94632673481f14843a5969256569623cfeac82db4ba5 \
 		platform-tools
--- a/release.mk
+++ b/release.mk
@@ -102,7 +102,7 @@ dist-win32: build-server build-win32
 	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.16/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
 	mkdir -p "$(DIST)/$(WIN64_TARGET_DIR)"
@@ -118,7 +118,7 @@ dist-win64: build-server build-win64
 	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.16/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)"; \
--- a/server/src/main/java/com/genymobile/scrcpy/Controller.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Controller.java
@@ -241,7 +241,7 @@ public class Controller {

        MotionEvent event = MotionEvent
                .obtain(lastTouchDown, now, MotionEvent.ACTION_SCROLL, 1, pointerProperties, pointerCoords, 0, 0, 1f, 1f, DEFAULT_DEVICE_ID, 0,
-                        InputDevice.SOURCE_MOUSE, 0);
+                        InputDevice.SOURCE_TOUCHSCREEN, 0);
        return device.injectEvent(event);
    }
Author	SHA1	Message	Date
Flying Press	b75873ce45	Mention adb wireless option for Android 11+ Add a paragraph about toggling an option to bypass having to physically connect the device to the user's computer. Signed-off-by: Romain Vimont <rom@rom1v.com>	2021-08-12 19:05:25 +02:00
Flying Press	bcc6354e99	Make step more explicit in wireless section Signed-off-by: Romain Vimont <rom@rom1v.com>	2021-08-12 19:05:18 +02:00
Flying Press	d8a72c7134	Add troubleshooting in wireless section Add a small troubleshooting section since wireless might add some complexity, and to lessen incoming relevant issue posts. Signed-off-by: Romain Vimont <rom@rom1v.com>	2021-08-12 18:53:53 +02:00
Flying Press	cbc72e417c	Improve phrasing in wireless section Signed-off-by: Romain Vimont <rom@rom1v.com>	2021-08-12 18:46:07 +02:00
Flying Press	bafa535425	Renumber steps in wireless section The actual numbers are ignored by markdown, but start at 1 for consistency. Signed-off-by: Romain Vimont <rom@rom1v.com>	2021-08-12 18:45:07 +02:00
Flying Press	cc3b6f4d58	Add an explicit first step in wireless section Mention that the device must be plugged via USB before configuring TCP/IP connections. It wasn't obvious that the device should be first plugged before scrcpy wirelessly, especially to those who aren't very familiar with adb. Note from committer: add this new step with index 0 to make the diff readable, the next commit will renumber all the steps. Signed-off-by: Romain Vimont <rom@rom1v.com>	2021-08-12 18:43:07 +02:00
kosantosbik	4ab3e89c29	Add README file in Turkish PR #2514 <https://github.com/Genymobile/scrcpy/pull/2514> Signed-off-by: Romain Vimont <rom@rom1v.com>	2021-08-11 15:42:31 +02:00
Hyperterminal Byte	4bc78244b9	Fix OBS project ref URL PR #2545 <https://github.com/Genymobile/scrcpy/pull/2545> Signed-off-by: Romain Vimont <rom@rom1v.com>	2021-08-11 15:29:17 +02:00
Stefan Huber	ea233d811d	Fix typo in DEVELOP.md PR #2540 <https://github.com/Genymobile/scrcpy/pull/2540> Signed-off-by: Romain Vimont <rom@rom1v.com>	2021-08-11 15:26:32 +02:00