Compensate slope on start

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.

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 messages_
+ - the **receiver** thread (managed by the controller), sending _device messges_
    to the clients (currently, it is only used to send the device clipboard
    content).
 

FAQ.md

@@ -153,26 +153,6 @@ You may also need to configure the [scaling behavior]:
 [scaling behavior]: https://github.com/Genymobile/scrcpy/issues/40#issuecomment-424466723
 
 
-### Issue with Wayland
-
-By default, SDL uses x11 on Linux. The [video driver] can be changed via the
-`SDL_VIDEODRIVER` environment variable:
-
-[video driver]: https://wiki.libsdl.org/FAQUsingSDL#how_do_i_choose_a_specific_video_driver
-
-```bash
-export SDL_VIDEODRIVER=wayland
-scrcpy
-```
-
-On some distributions (at least Fedora), the package `libdecor` must be
-installed manually.
-
-See issues [#2554] and [#2559].
-
-[#2554]: https://github.com/Genymobile/scrcpy/issues/2554
-[#2559]: https://github.com/Genymobile/scrcpy/issues/2559
-
 
 ### KWin compositor crashes
 

README.md

@@ -318,7 +318,25 @@ vlc v4l2:///dev/videoN   # VLC might add some buffering delay
 
 For example, you could capture the video within [OBS].
 
-[OBS]: https://obsproject.com/
+[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
+```
 
 
 ### Connection
@@ -875,6 +893,5 @@ 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.

README.tr.md

@@ -1,824 +0,0 @@
-# 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/

app/meson.build

@@ -2,6 +2,7 @@ src = [
     'src/main.c',
     'src/adb.c',
     'src/cli.c',
+    'src/clock.c',
     'src/compat.c',
     'src/control_msg.c',
     'src/controller.c',
@@ -10,6 +11,7 @@ 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',
@@ -25,6 +27,7 @@ src = [
     'src/util/process.c',
     'src/util/str_util.c',
     'src/util/thread.c',
+    'src/util/tick.c',
 ]
 
 if host_machine.system() == 'windows'
@@ -165,6 +168,10 @@ 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',

app/scrcpy.1

@@ -56,6 +56,12 @@ 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).
@@ -83,7 +89,7 @@ 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]
+.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".
@@ -189,7 +195,13 @@ 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 --lock-video-orientation).
+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.
 
 .TP
 .BI "\-V, \-\-verbosity " value
@@ -240,7 +252,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 \-\-shortcut-mod (see above).
+Alt or (left) Super, but it can be configured by \fB\-\-shortcut\-mod\fR (see above).
 
 .TP
 .B MOD+f

app/src/cli.c

@@ -55,6 +55,12 @@ 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"
@@ -79,7 +85,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"
@@ -182,6 +188,15 @@ 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"
@@ -392,6 +407,19 @@ 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, 0xFFFFFFFF,
+                                "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) {
@@ -689,6 +717,8 @@ 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[]) {
@@ -700,6 +730,7 @@ 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},
@@ -732,6 +763,7 @@ 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'},
@@ -917,10 +949,20 @@ 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

app/src/clock.c

@@ -0,0 +1,111 @@
+#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;
+}

app/src/clock.h

@@ -0,0 +1,70 @@
+#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

app/src/fps_counter.c

@@ -1,11 +1,10 @@
 #include "fps_counter.h"
 
 #include <assert.h>
-#include <SDL2/SDL_timer.h>
 
 #include "util/log.h"
 
-#define FPS_COUNTER_INTERVAL_MS 1000
+#define FPS_COUNTER_INTERVAL SC_TICK_FROM_SEC(1)
 
 bool
 fps_counter_init(struct fps_counter *counter) {
@@ -47,7 +46,7 @@ set_started(struct fps_counter *counter, bool started) {
 static void
 display_fps(struct fps_counter *counter) {
     unsigned rendered_per_second =
-        counter->nr_rendered * 1000 / FPS_COUNTER_INTERVAL_MS;
+        counter->nr_rendered * SC_TICK_FREQ / FPS_COUNTER_INTERVAL;
     if (counter->nr_skipped) {
         LOGI("%u fps (+%u frames skipped)", rendered_per_second,
                                             counter->nr_skipped);
@@ -68,8 +67,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_MS + 1;
+        (now - counter->next_timestamp) / FPS_COUNTER_INTERVAL + 1;
-    counter->next_timestamp += FPS_COUNTER_INTERVAL_MS * elapsed_slices;
+    counter->next_timestamp += FPS_COUNTER_INTERVAL * elapsed_slices;
 }
 
 static int
@@ -82,14 +81,12 @@ run_fps_counter(void *data) {
             sc_cond_wait(&counter->state_cond, &counter->mutex);
         }
         while (!counter->interrupted && is_started(counter)) {
-            uint32_t now = SDL_GetTicks();
+            sc_tick now = sc_tick_now();
             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, remaining);
+            sc_cond_timedwait(&counter->state_cond, &counter->mutex,
+                              counter->next_timestamp);
         }
     }
     sc_mutex_unlock(&counter->mutex);
@@ -99,7 +96,7 @@ run_fps_counter(void *data) {
 bool
 fps_counter_start(struct fps_counter *counter) {
     sc_mutex_lock(&counter->mutex);
-    counter->next_timestamp = SDL_GetTicks() + FPS_COUNTER_INTERVAL_MS;
+    counter->next_timestamp = sc_tick_now() + FPS_COUNTER_INTERVAL;
     counter->nr_rendered = 0;
     counter->nr_skipped = 0;
     sc_mutex_unlock(&counter->mutex);
@@ -165,7 +162,7 @@ fps_counter_add_rendered_frame(struct fps_counter *counter) {
     }
 
     sc_mutex_lock(&counter->mutex);
-    uint32_t now = SDL_GetTicks();
+    sc_tick now = sc_tick_now();
     check_interval_expired(counter, now);
     ++counter->nr_rendered;
     sc_mutex_unlock(&counter->mutex);
@@ -178,7 +175,7 @@ fps_counter_add_skipped_frame(struct fps_counter *counter) {
     }
 
     sc_mutex_lock(&counter->mutex);
-    uint32_t now = SDL_GetTicks();
+    sc_tick now = sc_tick_now();
     check_interval_expired(counter, now);
     ++counter->nr_skipped;
     sc_mutex_unlock(&counter->mutex);

app/src/fps_counter.h

@@ -24,7 +24,7 @@ struct fps_counter {
     bool interrupted;
     unsigned nr_rendered;
     unsigned nr_skipped;
-    uint32_t next_timestamp;
+    sc_tick next_timestamp;
 };
 
 bool

app/src/frame_buffer.c

@@ -0,0 +1,88 @@
+#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);
+}

app/src/frame_buffer.h

@@ -0,0 +1,44 @@
+#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

app/src/recorder.c

@@ -51,16 +51,15 @@ 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 (!queue_is_empty(queue)) {
+    while (!sc_queue_is_empty(queue)) {
         struct record_packet *rec;
-        queue_take(queue, next, &rec);
+        sc_queue_take(queue, next, &rec);
         record_packet_delete(rec);
     }
 }
@@ -136,14 +135,14 @@ run_recorder(void *data) {
     for (;;) {
         sc_mutex_lock(&recorder->mutex);
 
-        while (!recorder->stopped && queue_is_empty(&recorder->queue)) {
+        while (!recorder->stopped && sc_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 && queue_is_empty(&recorder->queue)) {
+        if (recorder->stopped && sc_queue_is_empty(&recorder->queue)) {
             sc_mutex_unlock(&recorder->mutex);
             struct record_packet *last = recorder->previous;
             if (last) {
@@ -162,7 +161,7 @@ run_recorder(void *data) {
         }
 
         struct record_packet *rec;
-        queue_take(&recorder->queue, next, &rec);
+        sc_queue_take(&recorder->queue, next, &rec);
 
         sc_mutex_unlock(&recorder->mutex);
 
@@ -236,7 +235,7 @@ recorder_open(struct recorder *recorder, const AVCodec *input_codec) {
         goto error_mutex_destroy;
     }
 
-    queue_init(&recorder->queue);
+    sc_queue_init(&recorder->queue);
     recorder->stopped = false;
     recorder->failed = false;
     recorder->header_written = false;
@@ -341,7 +340,7 @@ recorder_push(struct recorder *recorder, const AVPacket *packet) {
         return false;
     }
 
-    queue_push(&recorder->queue, next, rec);
+    sc_queue_push(&recorder->queue, next, rec);
     sc_cond_signal(&recorder->queue_cond);
 
     sc_mutex_unlock(&recorder->mutex);

app/src/recorder.h

@@ -17,7 +17,7 @@ struct record_packet {
     struct record_packet *next;
 };
 
-struct recorder_queue QUEUE(struct record_packet);
+struct recorder_queue SC_QUEUE(struct record_packet);
 
 struct recorder {
     struct sc_packet_sink packet_sink; // packet sink trait

app/src/scrcpy.c

@@ -343,19 +343,29 @@ scrcpy(const struct scrcpy_options *options) {
         stream_add_sink(&s->stream, &rec->packet_sink);
     }
 
-    if (options->display) {
+    if (options->control) {
-        if (options->control) {
+        if (!controller_init(&s->controller, s->server.control_socket)) {
-            if (!controller_init(&s->controller, s->server.control_socket)) {
+            goto end;
-                goto end;
-            }
-            controller_initialized = true;
-
-            if (!controller_start(&s->controller)) {
-                goto end;
-            }
-            controller_started = true;
         }
+        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) {
         const char *window_title =
             options->window_title ? options->window_title : device_name;
 
@@ -371,6 +381,7 @@ 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)) {
@@ -379,21 +390,12 @@ 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)) {
+        if (!sc_v4l2_sink_init(&s->v4l2_sink, options->v4l2_device, frame_size,
+                               options->v4l2_buffer)) {
             goto end;
         }
 

app/src/scrcpy.h

@@ -7,6 +7,8 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include "util/tick.h"
+
 enum sc_log_level {
     SC_LOG_LEVEL_VERBOSE,
     SC_LOG_LEVEL_DEBUG,
@@ -78,6 +80,8 @@ 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;
@@ -126,6 +130,8 @@ 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, \

app/src/screen.c

@@ -274,14 +274,16 @@ 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);
+}
 
-    bool previous_frame_skipped;
+static void
-    bool ok = video_buffer_push(&screen->vb, frame, &previous_frame_skipped);
+sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
-    if (!ok) {
+                             void *userdata) {
-        return false;
+    (void) vb;
-    }
+    struct screen *screen = userdata;
 
-    if (previous_frame_skipped) {
+    if (previous_skipped) {
         fps_counter_add_skipped_frame(&screen->fps_counter);
         // The EVENT_NEW_FRAME triggered for the previous frame will consume
         // this new frame instead
@@ -293,8 +295,6 @@ screen_frame_sink_push(struct sc_frame_sink *sink, const AVFrame *frame) {
         // Post the event on the UI thread
         SDL_PushEvent(&new_frame_event);
     }
-
-    return true;
 }
 
 bool
@@ -304,15 +304,26 @@ screen_init(struct screen *screen, const struct screen_params *params) {
     screen->fullscreen = false;
     screen->maximized = false;
 
-    bool ok = video_buffer_init(&screen->vb);
+    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);
     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_destroy_video_buffer;
+        goto error_stop_and_join_video_buffer;
     }
 
     screen->frame_size = params->frame_size;
@@ -453,8 +464,11 @@ 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:
-    video_buffer_destroy(&screen->vb);
+    sc_video_buffer_destroy(&screen->vb);
 
     return false;
 }
@@ -471,11 +485,13 @@ 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);
 }
 
@@ -489,7 +505,7 @@ screen_destroy(struct screen *screen) {
     SDL_DestroyRenderer(screen->renderer);
     SDL_DestroyWindow(screen->window);
     fps_counter_destroy(&screen->fps_counter);
-    video_buffer_destroy(&screen->vb);
+    sc_video_buffer_destroy(&screen->vb);
 }
 
 static void
@@ -595,7 +611,7 @@ update_texture(struct screen *screen, const AVFrame *frame) {
 static bool
 screen_update_frame(struct screen *screen) {
     av_frame_unref(screen->frame);
-    video_buffer_consume(&screen->vb, screen->frame);
+    sc_video_buffer_consume(&screen->vb, screen->frame);
     AVFrame *frame = screen->frame;
 
     fps_counter_add_rendered_frame(&screen->fps_counter);

app/src/screen.h

@@ -8,6 +8,7 @@
 #include <libavformat/avformat.h>
 
 #include "coords.h"
+#include "fps_counter.h"
 #include "opengl.h"
 #include "trait/frame_sink.h"
 #include "video_buffer.h"
@@ -19,7 +20,7 @@ struct screen {
     bool open; // track the open/close state to assert correct behavior
 #endif
 
-    struct video_buffer vb;
+    struct sc_video_buffer vb;
     struct fps_counter fps_counter;
 
     SDL_Window *window;
@@ -62,6 +63,8 @@ struct screen_params {
     bool mipmaps;
 
     bool fullscreen;
+
+    sc_tick buffering_time;
 };
 
 // initialize screen, create window, renderer and texture (window is hidden)

app/src/server.c

@@ -554,10 +554,10 @@ server_stop(struct server *server) {
     sc_mutex_lock(&server->mutex);
     bool signaled = false;
     if (!server->process_terminated) {
-#define WATCHDOG_DELAY_MS 1000
+#define WATCHDOG_DELAY SC_TICK_FROM_SEC(1)
         signaled = sc_cond_timedwait(&server->process_terminated_cond,
                                      &server->mutex,
-                                     WATCHDOG_DELAY_MS);
+                                     sc_tick_now() + WATCHDOG_DELAY);
     }
     sc_mutex_unlock(&server->mutex);
 

app/src/stream.c

@@ -151,7 +151,6 @@ 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);
         }
 
@@ -244,7 +243,6 @@ run_stream(void *data) {
     LOGD("End of frames");
 
     if (stream->pending) {
-        av_packet_unref(stream->pending);
         av_packet_free(&stream->pending);
     }
 

app/src/util/queue.h

@@ -1,6 +1,6 @@
 // generic intrusive FIFO queue
-#ifndef QUEUE_H
+#ifndef SC_QUEUE_H
-#define QUEUE_H
+#define SC_QUEUE_H
 
 #include "common.h"
 
@@ -10,15 +10,15 @@
 
 // To define a queue type of "struct foo":
 //    struct queue_foo QUEUE(struct foo);
-#define QUEUE(TYPE) { \
+#define SC_QUEUE(TYPE) { \
     TYPE *first; \
     TYPE *last; \
 }
 
-#define queue_init(PQ) \
+#define sc_queue_init(PQ) \
     (void) ((PQ)->first = (PQ)->last = NULL)
 
-#define queue_is_empty(PQ) \
+#define sc_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 QUEUE(struct foo);
+//    struct my_queue SC_QUEUE(struct foo);
 //
 //    struct my_queue queue;
-//    queue_init(&queue);
+//    sc_queue_init(&queue);
 //
 //    struct foo v1 = { .value = 42 };
 //    struct foo v2 = { .value = 27 };
 //
-//    queue_push(&queue, next, v1);
+//    sc_queue_push(&queue, next, v1);
-//    queue_push(&queue, next, v2);
+//    sc_queue_push(&queue, next, v2);
 //
 //    struct foo *foo;
-//    queue_take(&queue, next, &foo);
+//    sc_queue_take(&queue, next, &foo);
 //    assert(foo->value == 42);
-//    queue_take(&queue, next, &foo);
+//    sc_queue_take(&queue, next, &foo);
 //    assert(foo->value == 27);
-//    assert(queue_is_empty(&queue));
+//    assert(sc_queue_is_empty(&queue));
 //
 
 // push a new item into the queue
-#define queue_push(PQ, NEXTFIELD, ITEM) \
+#define sc_queue_push(PQ, NEXTFIELD, ITEM) \
     (void) ({ \
         (ITEM)->NEXTFIELD = NULL; \
-        if (queue_is_empty(PQ)) { \
+        if (sc_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 queue_take(PQ, NEXTFIELD, PITEM) \
+#define sc_queue_take(PQ, NEXTFIELD, PITEM) \
     (void) ({ \
-        assert(!queue_is_empty(PQ)); \
+        assert(!sc_queue_is_empty(PQ)); \
         *(PITEM) = (PQ)->first; \
         (PQ)->first = (PQ)->first->NEXTFIELD; \
     })

app/src/util/thread.c

@@ -31,7 +31,7 @@ sc_mutex_init(sc_mutex *mutex) {
 
     mutex->mutex = sdl_mutex;
 #ifndef NDEBUG
-    mutex->locker = 0;
+    atomic_init(&mutex->locker, 0);
 #endif
     return true;
 }
@@ -52,7 +52,8 @@ sc_mutex_lock(sc_mutex *mutex) {
         abort();
     }
 
-    mutex->locker = sc_thread_get_id();
+    atomic_store_explicit(&mutex->locker, sc_thread_get_id(),
+                          memory_order_relaxed);
 #else
     (void) r;
 #endif
@@ -62,7 +63,7 @@ void
 sc_mutex_unlock(sc_mutex *mutex) {
 #ifndef NDEBUG
     assert(sc_mutex_held(mutex));
-    mutex->locker = 0;
+    atomic_store_explicit(&mutex->locker, 0, memory_order_relaxed);
 #endif
     int r = SDL_UnlockMutex(mutex->mutex);
 #ifndef NDEBUG
@@ -83,7 +84,9 @@ sc_thread_get_id(void) {
 #ifndef NDEBUG
 bool
 sc_mutex_held(struct sc_mutex *mutex) {
-    return mutex->locker == sc_thread_get_id();
+    sc_thread_id locker_id =
+        atomic_load_explicit(&mutex->locker, memory_order_relaxed);
+    return locker_id == sc_thread_get_id();
 }
 #endif
 
@@ -112,14 +115,21 @@ sc_cond_wait(sc_cond *cond, sc_mutex *mutex) {
         abort();
     }
 
-    mutex->locker = sc_thread_get_id();
+    atomic_store_explicit(&mutex->locker, sc_thread_get_id(),
+                          memory_order_relaxed);
 #else
     (void) r;
 #endif
 }
 
 bool
-sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, uint32_t ms) {
+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);
     int r = SDL_CondWaitTimeout(cond->cond, mutex->mutex, ms);
 #ifndef NDEBUG
     if (r < 0) {
@@ -127,7 +137,8 @@ sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, uint32_t ms) {
         abort();
     }
 
-    mutex->locker = sc_thread_get_id();
+    atomic_store_explicit(&mutex->locker, sc_thread_get_id(),
+                          memory_order_relaxed);
 #endif
     assert(r == 0 || r == SDL_MUTEX_TIMEDOUT);
     return r == 0;

app/src/util/thread.h

@@ -3,8 +3,10 @@
 
 #include "common.h"
 
+#include <stdatomic.h>
 #include <stdbool.h>
-#include <stdint.h>
+
+#include "tick.h"
 
 /* Forward declarations */
 typedef struct SDL_Thread SDL_Thread;
@@ -12,7 +14,8 @@ typedef struct SDL_mutex SDL_mutex;
 typedef struct SDL_cond SDL_cond;
 
 typedef int sc_thread_fn(void *);
-typedef unsigned int sc_thread_id;
+typedef unsigned sc_thread_id;
+typedef atomic_uint sc_atomic_thread_id;
 
 typedef struct sc_thread {
     SDL_Thread *thread;
@@ -21,7 +24,7 @@ typedef struct sc_thread {
 typedef struct sc_mutex {
     SDL_mutex *mutex;
 #ifndef NDEBUG
-    sc_thread_id locker;
+    sc_atomic_thread_id locker;
 #endif
 } sc_mutex;
 
@@ -70,7 +73,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, uint32_t ms);
+sc_cond_timedwait(sc_cond *cond, sc_mutex *mutex, sc_tick deadline);
 
 void
 sc_cond_signal(sc_cond *cond);

app/src/util/tick.c

@@ -0,0 +1,16 @@
+#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 avoid loosing precision on PTS.
+    //
+    // SDL_GetPerformanceCounter()/SDL_GetPerformanceFrequency() could be used,
+    // but:
+    //  - the conversions (to avoid overflow) are not zero-cost, 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;
+}

app/src/util/tick.h

@@ -0,0 +1,21 @@
+#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

app/src/v4l2_sink.c

@@ -112,7 +112,7 @@ run_v4l2_sink(void *data) {
     for (;;) {
         sc_mutex_lock(&vs->mutex);
 
-        while (!vs->stopped && vs->vb.pending_frame_consumed) {
+        while (!vs->stopped && !vs->has_frame) {
             sc_cond_wait(&vs->cond, &vs->mutex);
         }
 
@@ -121,9 +121,11 @@ run_v4l2_sink(void *data) {
             break;
         }
 
+        vs->has_frame = false;
         sc_mutex_unlock(&vs->mutex);
 
-        video_buffer_consume(&vs->vb, vs->frame);
+        sc_video_buffer_consume(&vs->vb, vs->frame);
+
         bool ok = encode_and_write_frame(vs, vs->frame);
         av_frame_unref(vs->frame);
         if (!ok) {
@@ -137,17 +139,42 @@ 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) {
-    bool ok = video_buffer_init(&vs->vb);
+    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);
     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_destroy;
+        goto error_video_buffer_stop_and_join;
     }
 
     ok = sc_cond_init(&vs->cond);
@@ -241,6 +268,10 @@ 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) {
@@ -248,9 +279,6 @@ 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;
@@ -271,8 +299,11 @@ 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:
-    video_buffer_destroy(&vs->vb);
+    sc_video_buffer_destroy(&vs->vb);
 
     return false;
 }
@@ -284,7 +315,10 @@ 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);
@@ -294,20 +328,12 @@ 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);
-    video_buffer_destroy(&vs->vb);
+    sc_video_buffer_destroy(&vs->vb);
 }
 
 static bool
 sc_v4l2_sink_push(struct sc_v4l2_sink *vs, const AVFrame *frame) {
-    bool ok = video_buffer_push(&vs->vb, frame, NULL);
+    return sc_video_buffer_push(&vs->vb, frame);
-    if (!ok) {
-        return false;
-    }
-
-    // signal possible change of vs->vb.pending_frame_consumed
-    sc_cond_signal(&vs->cond);
-
-    return true;
 }
 
 static bool
@@ -330,7 +356,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) {
+                  struct size frame_size, sc_tick buffering_time) {
     vs->device_name = strdup(device_name);
     if (!vs->device_name) {
         LOGE("Could not strdup v4l2 device name");
@@ -338,6 +364,7 @@ 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,

app/src/v4l2_sink.h

@@ -6,22 +6,25 @@
 #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 video_buffer vb;
+    struct sc_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;
 
@@ -31,7 +34,7 @@ struct sc_v4l2_sink {
 
 bool
 sc_v4l2_sink_init(struct sc_v4l2_sink *vs, const char *device_name,
-                  struct size frame_size);
+                  struct size frame_size, sc_tick buffering_time);
 
 void
 sc_v4l2_sink_destroy(struct sc_v4l2_sink *vs);

app/src/video_buffer.c

@@ -1,88 +1,255 @@
 #include "video_buffer.h"
 
 #include <assert.h>
+#include <stdlib.h>
+
 #include <libavutil/avutil.h>
 #include <libavformat/avformat.h>
 
 #include "util/log.h"
 
-bool
+#define SC_BUFFERING_NDEBUG // comment to debug
-video_buffer_init(struct video_buffer *vb) {
+
-    vb->pending_frame = av_frame_alloc();
+static struct sc_video_buffer_frame *
-    if (!vb->pending_frame) {
+sc_video_buffer_frame_new(const AVFrame *frame) {
-        return false;
+    struct sc_video_buffer_frame *vb_frame = malloc(sizeof(*vb_frame));
+    if (!vb_frame) {
+        return NULL;
     }
 
-    vb->tmp_frame = av_frame_alloc();
+    vb_frame->frame = av_frame_alloc();
-    if (!vb->tmp_frame) {
+    if (!vb_frame->frame) {
-        av_frame_free(&vb->pending_frame);
+        free(vb_frame);
-        return false;
+        return NULL;
     }
 
-    bool ok = sc_mutex_init(&vb->mutex);
+    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);
     if (!ok) {
-        av_frame_free(&vb->pending_frame);
-        av_frame_free(&vb->tmp_frame);
         return false;
     }
 
-    // there is initially no frame, so consider it has already been consumed
+    vb->cbs->on_new_frame(vb, previous_skipped, vb->cbs_userdata);
-    vb->pending_frame_consumed = true;
-
     return true;
 }
 
-void
+static int
-video_buffer_destroy(struct video_buffer *vb) {
+run_buffering(void *data) {
-    sc_mutex_destroy(&vb->mutex);
+    struct sc_video_buffer *vb = data;
-    av_frame_free(&vb->pending_frame);
-    av_frame_free(&vb->tmp_frame);
-}
 
-static inline void
+    assert(vb->buffering_time > 0);
-swap_frames(AVFrame **lhs, AVFrame **rhs) {
+
-    AVFrame *tmp = *lhs;
+    for (;;) {
-    *lhs = *rhs;
+        sc_mutex_lock(&vb->b.mutex);
-    *rhs = tmp;
+
+        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;
 }
 
 bool
-video_buffer_push(struct video_buffer *vb, const AVFrame *frame,
+sc_video_buffer_init(struct sc_video_buffer *vb, sc_tick buffering_time,
-                  bool *previous_frame_skipped) {
+                     const struct sc_video_buffer_callbacks *cbs,
-    sc_mutex_lock(&vb->mutex);
+                     void *cbs_userdata) {
-
+    bool ok = sc_frame_buffer_init(&vb->fb);
-    // Use a temporary frame to preserve pending_frame in case of error.
+    if (!ok) {
-    // 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;
     }
 
-    // Now that av_frame_ref() succeeded, we can replace the previous
+    assert(buffering_time >= 0);
-    // pending_frame
+    if (buffering_time) {
-    swap_frames(&vb->pending_frame, &vb->tmp_frame);
+        ok = sc_mutex_init(&vb->b.mutex);
-    av_frame_unref(vb->tmp_frame);
+        if (!ok) {
+            LOGC("Could not create mutex");
+            sc_frame_buffer_destroy(&vb->fb);
+            return false;
+        }
 
-    if (previous_frame_skipped) {
+        ok = sc_cond_init(&vb->b.queue_cond);
-        *previous_frame_skipped = !vb->pending_frame_consumed;
+        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);
     }
-    vb->pending_frame_consumed = false;
 
-    sc_mutex_unlock(&vb->mutex);
+    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;
+        }
+    }
 
     return true;
 }
 
 void
-video_buffer_consume(struct video_buffer *vb, AVFrame *dst) {
+sc_video_buffer_stop(struct sc_video_buffer *vb) {
-    sc_mutex_lock(&vb->mutex);
+    if (vb->buffering_time) {
-    assert(!vb->pending_frame_consumed);
+        sc_mutex_lock(&vb->b.mutex);
-    vb->pending_frame_consumed = true;
+        vb->b.stopped = true;
-
+        sc_cond_signal(&vb->b.queue_cond);
-    av_frame_move_ref(dst, vb->pending_frame);
+        sc_cond_signal(&vb->b.wait_cond);
-    // av_frame_move_ref() resets its source frame, so no need to call
+        sc_mutex_unlock(&vb->b.mutex);
-    // av_frame_unref()
+    }
-
+}
-    sc_mutex_unlock(&vb->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);
 }

app/src/video_buffer.h

@@ -1,50 +1,76 @@
-#ifndef VIDEO_BUFFER_H
+#ifndef SC_VIDEO_BUFFER_H
-#define VIDEO_BUFFER_H
+#define SC_VIDEO_BUFFER_H
 
 #include "common.h"
 
 #include <stdbool.h>
 
-#include "fps_counter.h"
+#include "clock.h"
+#include "frame_buffer.h"
+#include "util/queue.h"
 #include "util/thread.h"
+#include "util/tick.h"
 
 // forward declarations
 typedef struct AVFrame AVFrame;
 
-/**
+struct sc_video_buffer_frame {
- * A video buffer holds 1 pending frame, which is the last frame received from
+    AVFrame *frame;
- * the producer (typically, the decoder).
+    struct sc_video_buffer_frame *next;
- *
+#ifndef NDEBUG
- * If a pending frame has not been consumed when the producer pushes a new
+    sc_tick push_date;
- * frame, then it is lost. The intent is to always provide access to the very
+#endif
- * 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 video_buffer {
+struct sc_video_buffer_frame_queue SC_QUEUE(struct sc_video_buffer_frame);
-    AVFrame *pending_frame;
-    AVFrame *tmp_frame; // To preserve the pending frame on error
 
-    sc_mutex mutex;
+struct sc_video_buffer {
+    struct sc_frame_buffer fb;
 
-    bool pending_frame_consumed;
+    sc_tick buffering_time;
+
+    // only if buffering_ms > 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
-video_buffer_init(struct video_buffer *vb);
+sc_video_buffer_init(struct sc_video_buffer *vb, sc_tick buffering_time,
-
+                     const struct sc_video_buffer_callbacks *cbs,
-void
+                     void *cbs_userdata);
-video_buffer_destroy(struct video_buffer *vb);
 
 bool
-video_buffer_push(struct video_buffer *vb, const AVFrame *frame, bool *skipped);
+sc_video_buffer_start(struct sc_video_buffer *vb);
 
 void
-video_buffer_consume(struct video_buffer *vb, AVFrame *dst);
+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);
 
 #endif

app/tests/test_clock.c

@@ -0,0 +1,79 @@
+#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;
+};

app/tests/test_queue.c

@@ -10,28 +10,28 @@ struct foo {
 };
 
 static void test_queue(void) {
-    struct my_queue QUEUE(struct foo) queue;
+    struct my_queue SC_QUEUE(struct foo) queue;
-    queue_init(&queue);
+    sc_queue_init(&queue);
 
-    assert(queue_is_empty(&queue));
+    assert(sc_queue_is_empty(&queue));
 
     struct foo v1 = { .value = 42 };
     struct foo v2 = { .value = 27 };
 
-    queue_push(&queue, next, &v1);
+    sc_queue_push(&queue, next, &v1);
-    queue_push(&queue, next, &v2);
+    sc_queue_push(&queue, next, &v2);
 
     struct foo *foo;
 
-    assert(!queue_is_empty(&queue));
+    assert(!sc_queue_is_empty(&queue));
-    queue_take(&queue, next, &foo);
+    sc_queue_take(&queue, next, &foo);
     assert(foo->value == 42);
 
-    assert(!queue_is_empty(&queue));
+    assert(!sc_queue_is_empty(&queue));
-    queue_take(&queue, next, &foo);
+    sc_queue_take(&queue, next, &foo);
     assert(foo->value == 27);
 
-    assert(queue_is_empty(&queue));
+    assert(sc_queue_is_empty(&queue));
 }
 
 int main(int argc, char *argv[]) {