Add --codec-options

Co-authored-by: Romain Vimont <rom@rom1v.com>
2020-05-04 01:17:02 +02:00
37 changed files with 456 additions and 1415 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@ -21,9 +21,5 @@ assignees: ''
 A clear and concise description of what the bug is.
 On errors, please provide the output of the console (and `adb logcat` if relevant).
-
+Format them between code blocks (delimited by ```).
 ```
 Please paste terminal output in a code block.
 ```
 Please do not post screenshots of your terminal, just post the content as text instead.
--- a/.gitignore
+++ b/.gitignore
@ -1,8 +1,5 @@
 build/
 /dist/
 /build-*/
 /build_*/
 /release-*/
 .idea/
 .gradle/
 /x/
--- a/BUILD.md
+++ b/BUILD.md
@ -249,10 +249,10 @@ You can then [run](README.md#run) _scrcpy_.
 ## Prebuilt server
- - [`scrcpy-server-v1.14`][direct-scrcpy-server]  
+ - [`scrcpy-server-v1.13`][direct-scrcpy-server]  
-   _(SHA-256: 1d1b18a2b80e956771fd63b99b414d2d028713a8f12ddfa5a369709ad4295620)_
+   _(SHA-256: 5fee64ca1ccdc2f38550f31f5353c66de3de30c2e929a964e30fa2d005d5f885)_
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.14/scrcpy-server-v1.14
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.13/scrcpy-server-v1.13
 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
--- a/README.ko.md
+++ b/README.ko.md
@ -1,5 +1,3 @@
 _Only the original [README](README.md) is guaranteed to be up-to-date._
 # scrcpy (v1.11)
 This document will be updated frequently along with the original Readme file
--- a/README.md
+++ b/README.md
@ -1,4 +1,4 @@
-# scrcpy (v1.14)
+# scrcpy (v1.13)
 This application provides display and control of Android devices connected on
 USB (or [over TCP/IP][article-tcpip]). It does not require any _root_ access.
@ -69,10 +69,10 @@ hard).
 For Windows, for simplicity, a prebuilt archive with all the dependencies
 (including `adb`) is available:
- - [`scrcpy-win64-v1.14.zip`][direct-win64]  
+ - [`scrcpy-win64-v1.13.zip`][direct-win64]  
-   _(SHA-256: 2be9139e46e29cf2f5f695848bb2b75a543b8f38be1133257dc5068252abc25f)_
+   _(SHA-256: 806aafc00d4db01513193addaa24f47858893ba5efe75770bfef6ae1ea987d27)_
-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.14/scrcpy-win64-v1.14.zip
+[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.13/scrcpy-win64-v1.13.zip
 It is also available in [Chocolatey]:
@ -210,6 +210,7 @@ To disable mirroring while recording:
 scrcpy --no-display --record file.mp4
 scrcpy -Nr file.mkv
 # interrupt recording with Ctrl+C
 # Ctrl+C does not terminate properly on Windows, so disconnect the device
 ```
 "Skipped frames" are recorded, even if they are not displayed in real time (for
@ -289,22 +290,6 @@ From another terminal:
 scrcpy
 ```
 To avoid enabling remote port forwarding, you could force a forward connection
 instead (notice the `-L` instead of `-R`):
 ```bash
 adb kill-server    # kill the local adb server on 5037
 ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
 # keep this open
 ```
 From another terminal:
 ```bash
 scrcpy --force-adb-forwrad
 ```
 Like for wireless connections, it may be useful to reduce quality:
 ```
@ -354,7 +339,7 @@ scrcpy --fullscreen
 scrcpy -f  # short version
 ```
-Fullscreen can then be toggled dynamically with `RCtrl`+`f`.
+Fullscreen can then be toggled dynamically with `Ctrl`+`f`.
 #### Rotation
@ -370,18 +355,18 @@ Possibles values are:
 - `2`: 180 degrees
 - `3`: 90 degrees clockwise
-The rotation can also be changed dynamically with `RCtrl`+`←` _(left)_ and
+The rotation can also be changed dynamically with `Ctrl`+`←` _(left)_ and
-`RCtrl`+`→` _(right)_.
+`Ctrl`+`→` _(right)_.
 Note that _scrcpy_ manages 3 different rotations:
- - `RCtrl`+`r` requests the device to switch between portrait and landscape (the
+ - `Ctrl`+`r` requests the device to switch between portrait and landscape (the
   current running app may refuse, if it does support the requested
   orientation).
 - `--lock-video-orientation` changes the mirroring orientation (the orientation
   of the video sent from the device to the computer). This affects the
   recording.
- - `--rotation` (or `RCtrl`+`←`/`RCtrl`+`→`) rotates only the window content.
+ - `--rotation` (or `Ctrl`+`←`/`Ctrl`+`→`) rotates only the window content. This
-   This affects only the display, not the recording.
+   affects only the display, not the recording.
 ### Other mirroring options
@ -411,13 +396,9 @@ The list of display ids can be retrieved by:
 adb shell dumpsys display   # search "mDisplayId=" in the output
 ```
 The secondary display may only be controlled if the device runs at least Android
 10 (otherwise it is mirrored in read-only).
 #### Stay awake
-To prevent the device to sleep after some delay when the device is plugged in:
+To prevent the device to sleep after some delay:
 ```bash
 scrcpy --stay-awake
@ -437,9 +418,9 @@ scrcpy --turn-screen-off
 scrcpy -S
 ```
-Or by pressing `RCtrl`+`o` at any time.
+Or by pressing `Ctrl`+`o` at any time.
-To turn it back on, press `RCtrl`+`Shift`+`o` (or `POWER`, `RCtrl`+`p`).
+To turn it back on, press `POWER` (or `Ctrl`+`p`).
 It can be useful to also prevent the device to sleep:
@ -483,22 +464,20 @@ Note that it only shows _physical_ touches (with the finger on the device).
 #### Rotate device screen
-Press `RCtrl`+`r` to switch between portrait and landscape modes.
+Press `Ctrl`+`r` to switch between portrait and landscape modes.
 Note that it rotates only if the application in foreground supports the
 requested orientation.
 #### Copy-paste
-Any time the Android clipboard changes, it is automatically synchronized to the
+It is possible to synchronize clipboards between the computer and the device, in
-computer clipboard.
+both directions:
 `Ctrl`+`c` (copy), `Ctrl`+`x` (cut) and `LCtrl`+`v` (paste) work as you expect.
 In addition, `RCtrl`+`v` allows to inject the computer clipboard content as a
 sequence of text event. Even if it can break non-ASCII content, this is
 sometimes necessary when pasting directly is not possible.
 - `Ctrl`+`c` copies the device clipboard to the computer clipboard;
 - `Ctrl`+`Shift`+`v` copies the computer clipboard to the device clipboard;
 - `Ctrl`+`v` _pastes_ the computer clipboard as a sequence of text events (but
   breaks non-ASCII characters).
 #### Text injection preference
@ -558,34 +537,29 @@ Also see [issue #14].
 ## Shortcuts
-`RCtrl` is the right `Ctrl` key (the left `Ctrl` key is forwarded to the
+ | Action                                 |   Shortcut                    |   Shortcut (macOS)
-device).
+ | -------------------------------------- |:----------------------------- |:-----------------------------
-
+ | Switch fullscreen mode                 | `Ctrl`+`f`                    | `Cmd`+`f`
-On macOS, `Cmd` also works (for shortcuts which are not already captured by the
+ | Rotate display left                    | `Ctrl`+`←` _(left)_           | `Cmd`+`←` _(left)_
-system).
+ | Rotate display right                   | `Ctrl`+`→` _(right)_          | `Cmd`+`→` _(right)_
-
+ | Resize window to 1:1 (pixel-perfect)   | `Ctrl`+`g`                    | `Cmd`+`g`
- | Action                                      |   Shortcut
+ | Resize window to remove black borders  | `Ctrl`+`x` \| _Double-click¹_ | `Cmd`+`x`  \| _Double-click¹_
- | ------------------------------------------- |:-----------------------------
+ | Click on `HOME`                        | `Ctrl`+`h` \| _Middle-click_  | `Ctrl`+`h` \| _Middle-click_
- | Switch fullscreen mode                      | `RCtrl`+`f`
+ | Click on `BACK`                        | `Ctrl`+`b` \| _Right-click²_  | `Cmd`+`b`  \| _Right-click²_
- | Rotate display left                         | `RCtrl`+`←`
+ | Click on `APP_SWITCH`                  | `Ctrl`+`s`                    | `Cmd`+`s`
- | Rotate display right                        | `RCtrl`+`→`
+ | Click on `MENU`                        | `Ctrl`+`m`                    | `Ctrl`+`m`
- | Resize window to 1:1 (pixel-perfect)        | `RCtrl`+`g`
+ | Click on `VOLUME_UP`                   | `Ctrl`+`↑` _(up)_             | `Cmd`+`↑` _(up)_
- | Resize window to remove black borders       | `RCtrl`+`w` \| _Double-click¹_
+ | Click on `VOLUME_DOWN`                 | `Ctrl`+`↓` _(down)_           | `Cmd`+`↓` _(down)_
- | Click on `HOME`                             | `RCtrl`+`h` \| _Middle-click_
+ | Click on `POWER`                       | `Ctrl`+`p`                    | `Cmd`+`p`
- | Click on `BACK`                             | `RCtrl`+`b` \| _Right-click²_
+ | Power on                               | _Right-click²_                | _Right-click²_
- | Click on `APP_SWITCH`                       | `RCtrl`+`s`
+ | Turn device screen off (keep mirroring)| `Ctrl`+`o`                    | `Cmd`+`o`
- | Click on `MENU`                             | `RCtrl`+`m`
+ | Rotate device screen                   | `Ctrl`+`r`                    | `Cmd`+`r`
- | Click on `VOLUME_UP`                        | `RCtrl`+`↑` _(up)_
+ | Expand notification panel              | `Ctrl`+`n`                    | `Cmd`+`n`
- | Click on `VOLUME_DOWN`                      | `RCtrl`+`↓` _(down)_
+ | Collapse notification panel            | `Ctrl`+`Shift`+`n`            | `Cmd`+`Shift`+`n`
- | Click on `POWER`                            | `RCtrl`+`p`
+ | Copy device clipboard to computer      | `Ctrl`+`c`                    | `Cmd`+`c`
- | Power on                                    | _Right-click²_
+ | Paste computer clipboard to device     | `Ctrl`+`v`                    | `Cmd`+`v`
- | Turn device screen off (keep mirroring)     | `RCtrl`+`o`
+ | Copy computer clipboard to device      | `Ctrl`+`Shift`+`v`            | `Cmd`+`Shift`+`v`
- | Turn device screen on                       | `RCtrl`+`Shift`+`o`
+ | Enable/disable FPS counter (on stdout) | `Ctrl`+`i`                    | `Cmd`+`i`
 | Rotate device screen                        | `RCtrl`+`r`
 | Expand notification panel                   | `RCtrl`+`n`
 | Collapse notification panel                 | `RCtrl`+`Shift`+`n`
 | Inject computer clipboard text              | `RCtrl`+`v`
 | Enable/disable FPS counter (on stdout)      | `RCtrl`+`i`
 _¹Double-click on black borders to remove them._  
 _²Right-click turns the screen on if it was off, presses BACK otherwise._
--- a/README.pt-br.md
+++ b/README.pt-br.md
@ -1,531 +0,0 @@
 _Only the original [README](README.md) is guaranteed to be up-to-date._
 # scrcpy (v1.12.1)
 Esta aplicação fornece visualização e controle de dispositivos Android conectados via
 USB (ou [via TCP/IP][article-tcpip]). Não requer nenhum acesso root.
 Funciona em _GNU/Linux_, _Windows_ e _macOS_.
 ![screenshot](assets/screenshot-debian-600.jpg)
 Foco em:
 - **leveza** (Nativo, mostra apenas a tela do dispositivo)
 - **performance** (30~60fps)
 - **qualidade** (1920×1080 ou acima)
 - **baixa latência** ([35~70ms][lowlatency])
 - **baixo tempo de inicialização** (~1 segundo para mostrar a primeira imagem)
 - **não intrusivo** (nada é deixado instalado no dispositivo)
 [lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
 ## Requisitos
 O Dispositivo Android requer pelo menos a API 21 (Android 5.0).
 Tenha certeza de ter [ativado a depuração USB][enable-adb] no(s) seu(s) dispositivo(s).
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 Em alguns dispositivos, você também precisará ativar [uma opção adicional][control] para controlá-lo usando o teclado e mouse.
 [control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
 ## Obtendo o app
 ### Linux
 No Debian (_em testes_ e _sid_ por enquanto):
 ```
 apt install scrcpy
 ```
 O pacote [Snap] está disponível: [`scrcpy`][snap-link].
 [snap-link]: https://snapstats.org/snaps/scrcpy
 [snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
 Para Arch Linux, um pacote [AUR] está disponível: [`scrcpy`][aur-link].
 [AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
 [aur-link]: https://aur.archlinux.org/packages/scrcpy/
 Para Gentoo, uma [Ebuild] está disponível: [`scrcpy/`][ebuild-link].
 [Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
 [ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
 Você também pode [compilar a aplicação manualmente][BUILD] (não se preocupe, não é tão difícil).
 ### Windows
 Para Windows, para simplicidade, um arquivo pré-compilado com todas as dependências
 (incluindo `adb`) está disponível:
 - [`scrcpy-win64-v1.12.1.zip`][direct-win64]  
   _(SHA-256: 57d34b6d16cfd9fe169bc37c4df58ebd256d05c1ea3febc63d9cb0a027ab47c9)_
 [direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.12.1/scrcpy-win64-v1.12.1.zip
 Também disponível em [Chocolatey]:
 [Chocolatey]: https://chocolatey.org/
 ```bash
 choco install scrcpy
 choco install adb    # se você ainda não o tem
 ```
 E no [Scoop]:
 ```bash
 scoop install scrcpy
 scoop install adb    # se você ainda não o tem
 ```
 [Scoop]: https://scoop.sh
 Você também pode [compilar a aplicação manualmente][BUILD].
 ### macOS
 A aplicação está disponível em [Homebrew]. Apenas a instale:
 [Homebrew]: https://brew.sh/
 ```bash
 brew install scrcpy
 ```
 Você precisa do `adb`, acessível através do seu `PATH`. Se você ainda não o tem:
 ```bash
 brew cask install android-platform-tools
 ```
 Você também pode [compilar a aplicação manualmente][BUILD].
 ## Executar
 Plugue um dispositivo Android e execute:
 ```bash
 scrcpy
 ```
 Também aceita argumentos de linha de comando, listados por:
 ```bash
 scrcpy --help
 ```
 ## Funcionalidades
 ### Configuração de captura
 #### Redução de tamanho
 Algumas vezes, é útil espelhar um dispositivo Android em uma resolução menor para
 aumentar performance.
 Para limitar ambos(largura e altura) para algum valor (ex: 1024):
 ```bash
 scrcpy --max-size 1024
 scrcpy -m 1024  # versão reduzida
 ```
 A outra dimensão é calculada para que a proporção do dispositivo seja preservada.
 Dessa forma, um dispositivo em 1920x1080 será espelhado em 1024x576.
 #### Mudanças no bit-rate
 O Padrão de bit-rate é 8 mbps. Para mudar o bitrate do vídeo (ex: para 2 Mbps):
 ```bash
 scrcpy --bit-rate 2M
 scrcpy -b 2M  # versão reduzida
 ```
 #### Limitar frame rates
 Em dispositivos com Android >= 10, a captura de frame rate pode ser limitada:
 ```bash
 scrcpy --max-fps 15
 ```
 #### Cortar
 A tela do dispositivo pode ser cortada para espelhar apenas uma parte da tela.
 Isso é útil por exemplo, ao espelhar apenas um olho do Oculus Go:
 ```bash
 scrcpy --crop 1224:1440:0:0   # 1224x1440 no deslocamento (0,0)
 ```
 Se `--max-size` também for especificado, redimensionar é aplicado após os cortes.
 ### Gravando
 É possível gravar a tela enquanto ocorre o espelhamento:
 ```bash
 scrcpy --record file.mp4
 scrcpy -r file.mkv
 ```
 Para desativar o espelhamento durante a gravação:
 ```bash
 scrcpy --no-display --record file.mp4
 scrcpy -Nr file.mkv
 # interrompe a gravação com Ctrl+C
 # Ctrl+C não encerrar propriamente no Windows, então desconecte o dispositivo
 ```
 "Frames pulados" são gravados, mesmo que não sejam mostrado em tempo real (por motivos de performance).
 Frames tem seu _horário_ _carimbado_ no dispositivo, então [Variação de atraso nos pacotes] não impacta na gravação do arquivo.
 [Variação de atraso de pacote]: https://en.wikipedia.org/wiki/Packet_delay_variation
 ### Conexão
 #### Wireless/Sem fio
 _Scrcpy_ usa `adb` para se comunicar com o dispositivo, e `adb` pode [conectar-se] à um dispositivo via TCP/IP:
 1. Conecte o dispositivo a mesma rede Wi-Fi do seu computador.
 2. Pegue o endereço de IP do seu dispositivo (Em Configurações → Sobre o Telefone → Status).
 3. Ative o adb via TCP/IP no seu dispositivo: `adb tcpip 5555`.
 4. Desplugue seu dispositivo.
 5. Conecte-se ao seu dispositivo: `adb connect DEVICE_IP:5555` _(substitua o `DEVICE_IP`)_.
 6. Execute `scrcpy` como de costume.
 Pode ser útil diminuir o bit-rate e a resolução:
 ```bash
 scrcpy --bit-rate 2M --max-size 800
 scrcpy -b2M -m800  # versão reduzida
 ```
 [conectar-se]: https://developer.android.com/studio/command-line/adb.html#wireless
 #### N-dispositivos
 Se alguns dispositivos estão listados em `adb devices`, você precisa especificar o _serial_:
 ```bash
 scrcpy --serial 0123456789abcdef
 scrcpy -s 0123456789abcdef  # versão reduzida
 ```
 Se o dispositivo está conectado via TCP/IP:
 ```bash
 scrcpy --serial 192.168.0.1:5555
 scrcpy -s 192.168.0.1:5555  # versão reduzida
 ```
 Você pode iniciar algumas instâncias do _scrcpy_ para alguns dispositivos.
 #### Conexão via SSH
 Para conectar-se à um dispositivo remoto, é possível se conectar um cliente local `adb`  à um servidor `adb` remoto (contanto que eles usem a mesma versão do protocolo _adb_):
 ```bash
 adb kill-server    # encerra o servidor local na 5037
 ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
 # mantém isso aberto
 ```
 De outro terminal:
 ```bash
 scrcpy
 ```
 Igual para conexões sem fio, pode ser útil reduzir a qualidade:
 ```
 scrcpy -b2M -m800 --max-fps 15
 ```
 ### Configurações de Janela
 #### Título
 Por padrão, o título da janela é o modelo do dispositivo. Isto pode ser mudado:
 ```bash
 scrcpy --window-title 'Meu dispositivo'
 ```
 #### Posição e tamanho
 A posição e tamanho iniciais da janela podem ser especificados:
 ```bash
 scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
 ```
 #### Sem bordas
 Para desativar decorações da janela:
 ```bash
 scrcpy --window-borderless
 ```
 #### Sempre visível
 Para manter a janela do scrcpy sempre visível:
 ```bash
 scrcpy --always-on-top
 ```
 #### Tela cheia
 A aplicação pode ser iniciada diretamente em tela cheia:
 ```bash
 scrcpy --fullscreen
 scrcpy -f  # versão reduzida
 ```
 Tela cheia pode ser alternada dinamicamente com `Ctrl`+`f`.
 ### Outras opções de espelhamento
 #### Apenas leitura
 Para desativar controles (tudo que possa interagir com o dispositivo: teclas de entrada, eventos de mouse, arrastar e soltar arquivos):
 ```bash
 scrcpy --no-control
 scrcpy -n
 ```
 #### Desligar a tela
 É possível desligar a tela do dispositivo durante o início do espelhamento com uma opção de linha de comando:
 ```bash
 scrcpy --turn-screen-off
 scrcpy -S
 ```
 Ou apertando `Ctrl`+`o` durante qualquer momento.
 Para ligar novamente, pressione `POWER` (ou `Ctrl`+`p`).
 #### Frames expirados de renderização
 Por padrão, para minimizar a latência, _scrcpy_ sempre renderiza o último frame decodificado disponível e descarta o anterior.
 Para forçar a renderização de todos os frames ( com o custo de aumento de latência), use:
 ```bash
 scrcpy --render-expired-frames
 ```
 #### Mostrar toques
 Para apresentações, pode ser útil mostrar toques físicos(dispositivo físico).
 Android fornece esta funcionalidade nas _Opções do Desenvolvedor_.
 _Scrcpy_ fornece esta opção de ativar esta funcionalidade no início e desativar no encerramento:
 ```bash
 scrcpy --show-touches
 scrcpy -t
 ```
 Note que isto mostra apenas toques _físicos_ (com o dedo no dispositivo).
 ### Controle de entrada
 #### Rotacionar a tela do dispositivo
 Pressione `Ctrl`+`r` para mudar entre os modos Retrato e Paisagem.
 Note que só será rotacionado se a aplicação em primeiro plano tiver suporte para o modo requisitado.
 #### Copiar-Colar
 É possível sincronizar áreas de transferência entre computador e o dispositivo,
 para ambas direções:
 - `Ctrl`+`c` copia a área de transferência do dispositivo para a área de trasferência do computador;
 - `Ctrl`+`Shift`+`v` copia a área de transferência do computador para a área de transferência do dispositivo;
 - `Ctrl`+`v` _cola_ a área de transferência do computador como uma sequência de eventos de texto (mas
   quebra caracteres não-ASCII).
 #### Preferências de injeção de texto
 Existe dois tipos de [eventos][textevents] gerados ao digitar um texto:
 - _eventos de teclas_, sinalizando que a tecla foi pressionada ou solta;
 - _eventos de texto_, sinalizando que o texto foi inserido.
 Por padrão, letras são injetadas usando eventos de teclas, assim teclados comportam-se
 como esperado em jogos (normalmente para tecladas WASD)
 Mas isto pode [causar problemas][prefertext]. Se você encontrar tal problema,
 pode evitá-lo usando:
 ```bash
 scrcpy --prefer-text
 ```
 (mas isto vai quebrar o comportamento do teclado em jogos)
 [textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
 [prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
 ### Transferência de arquivo
 #### Instalar APK
 Para instalar um APK, arraste e solte o arquivo APK(com extensão `.apk`) na janela _scrcpy_.
 Não existe feedback visual, um log é imprimido no console.
 #### Enviar arquivo para o dispositivo
 Para enviar um arquivo para o diretório `/sdcard/` no dispositivo, arraste e solte um arquivo não APK para a janela do
 _scrcpy_.
 Não existe feedback visual, um log é imprimido no console.
 O diretório alvo pode ser mudado ao iniciar:
 ```bash
 scrcpy --push-target /sdcard/foo/bar/
 ```
 ### Encaminhamento de áudio
 Áudio não é encaminhando pelo _scrcpy_. Use [USBaudio] (Apenas linux).
 Também veja [issue #14].
 [USBaudio]: https://github.com/rom1v/usbaudio
 [issue #14]: https://github.com/Genymobile/scrcpy/issues/14
 ## Atalhos
 | Ação                                                          |   Atalho                        |   Atalho (macOS)
 | ------------------------------------------------------------- |:------------------------------- |:-----------------------------
 | Alternar para modo de tela cheia                              | `Ctrl`+`f`                      | `Cmd`+`f`
 | Redimensionar janela para pixel-perfect(Escala 1:1)           | `Ctrl`+`g`                      | `Cmd`+`g`
 | Redimensionar janela para tirar as bordas pretas              | `Ctrl`+`x` \| _Clique-duplo¹_   | `Cmd`+`x`  \| _Clique-duplo¹_
 | Clicar em `HOME`                                              | `Ctrl`+`h` \| _Clique-central_  | `Ctrl`+`h` \| _Clique-central_
 | Clicar em `BACK`                                              | `Ctrl`+`b` \| _Clique-direito²_ | `Cmd`+`b`  \| _Clique-direito²_
 | Clicar em `APP_SWITCH`                                        | `Ctrl`+`s`                      | `Cmd`+`s`
 | Clicar em `MENU`                                              | `Ctrl`+`m`                      | `Ctrl`+`m`
 | Clicar em `VOLUME_UP`                                         | `Ctrl`+`↑` _(cima)_             | `Cmd`+`↑` _(cima)_
 | Clicar em `VOLUME_DOWN`                                       | `Ctrl`+`↓` _(baixo)_            | `Cmd`+`↓` _(baixo)_
 | Clicar em `POWER`                                             | `Ctrl`+`p`                      | `Cmd`+`p`
 | Ligar                                                         | _Clique-direito²_               | _Clique-direito²_
 | Desligar a tela do dispositivo                                | `Ctrl`+`o`                      | `Cmd`+`o`
 | Rotacionar tela do dispositivo                                | `Ctrl`+`r`                      | `Cmd`+`r`
 | Expandir painel de notificação                                | `Ctrl`+`n`                      | `Cmd`+`n`
 | Esconder painel de notificação                                | `Ctrl`+`Shift`+`n`              | `Cmd`+`Shift`+`n`
 | Copiar área de transferência do dispositivo para o computador | `Ctrl`+`c`                      | `Cmd`+`c`
 | Colar área de transferência do computador para o dispositivo  | `Ctrl`+`v`                      | `Cmd`+`v`
 | Copiar área de transferência do computador para dispositivo   | `Ctrl`+`Shift`+`v`              | `Cmd`+`Shift`+`v`
 | Ativar/desativar contador de FPS(Frames por segundo)          | `Ctrl`+`i`                      | `Cmd`+`i`
 _¹Clique-duplo em bordas pretas para removê-las._  
 _²Botão direito liga a tela se ela estiver desligada, clique BACK para o contrário._
 ## Caminhos personalizados
 Para usar um binário específico _adb_, configure seu caminho na variável de ambiente `ADB`:
    ADB=/caminho/para/adb scrcpy
 Para sobrepor o caminho do arquivo `scrcpy-server`, configure seu caminho em
 `SCRCPY_SERVER_PATH`.
 [useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
 ## Por quê _scrcpy_?
 Um colega me desafiou a encontrar um nome impronunciável como [gnirehtet].
 [`strcpy`] copia uma **str**ing; `scrcpy` copia uma **scr**een.
 [gnirehtet]: https://github.com/Genymobile/gnirehtet
 [`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
 ## Como compilar?
 Veja [BUILD].
 [BUILD]: BUILD.md
 ## Problemas comuns
 Veja [FAQ](FAQ.md).
 ## Desenvolvedores
 Leia a  [developers page].
 [developers page]: DEVELOP.md
 ## Licença
    Copyright (C) 2018 Genymobile
    Copyright (C) 2018-2020 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.
 ## Artigos
 - [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/scrcpy.1
+++ b/app/scrcpy.1
@ -26,12 +26,10 @@ Encode the video at the given bit\-rate, expressed in bits/s. Unit suffixes are
 Default is 8000000.
 .TP
-.BI "\-\-codec\-options " key[:type]=value[,...]
+.BI "\-\-\codec\-options " key[:type]=value[,...]
 Set a list of comma-separated key:type=value options for the device encoder.
 The possible values for 'type' are 'int' (default), 'long', 'float' and 'string'.
-
+The list of possible codec options is available in the Android documentation:
 The list of possible codec options is available in the Android documentation
 .UR https://d.android.com/reference/android/media/MediaFormat
 .UE .
@ -52,10 +50,6 @@ The list of possible display ids can be listed by "adb shell dumpsys display"
 Default is 0.
 .TP
 .B \-\-force\-adb\-forward
 Do not attempt to use "adb reverse" to connect to the device.
 .TP
 .B \-f, \-\-fullscreen
 Start in fullscreen.
@ -129,7 +123,6 @@ Force recording format (either mp4 or mkv).
 Request SDL to use the given render driver (this is just a hint).
 Supported names are currently "direct3d", "opengl", "opengles2", "opengles", "metal" and "software".
 .UR https://wiki.libsdl.org/SDL_HINT_RENDER_DRIVER
 .UE
@ -151,7 +144,7 @@ Turn the device screen off immediately.
 .TP
 .B \-t, \-\-show\-touches
-Enable "show touches" on start, restore the initial value on exit.
+Enable "show touches" on start, restore the initial value on exit..
 It only shows physical touches (not clicks from scrcpy).
@ -159,15 +152,9 @@ It only shows physical touches (not clicks from scrcpy).
 .B \-v, \-\-version
 Print the version of scrcpy.
 .TP
 .BI "\-V, \-\-verbosity " value
 Set the log level ("debug", "info", "warn" or "error").
 Default is "info" for release builds, "debug" for debug builds.
 .TP
 .B \-w, \-\-stay-awake
-Keep the device on while scrcpy is running, when the device is plugged in.
+Keep the device on while scrcpy is running.
 .TP
 .B \-\-window\-borderless
@ -203,54 +190,52 @@ Default is 0 (automatic).\n
 .SH SHORTCUTS
 RCtrl is the right Ctrl key (the left Ctrl key is forwarded to the device).
 .TP
-.B RCtrl+f
+.B Ctrl+f
 Switch fullscreen mode
 .TP
-.B RCtrl+Left
+.B Ctrl+Left
 Rotate display left
 .TP
-.B RCtrl+Right
+.B Ctrl+Right
 Rotate display right
 .TP
-.B RCtrl+g
+.B Ctrl+g
 Resize window to 1:1 (pixel\-perfect)
 .TP
-.B RCtrl+w, Double\-click on black borders
+.B Ctrl+x, Double\-click on black borders
 Resize window to remove black borders
 .TP
-.B RCtrl+h, Home, Middle\-click
+.B Ctrl+h, Home, Middle\-click
 Click on HOME
 .TP
-.B RCtrl+b, RCtrl+Backspace, Right\-click (when screen is on)
+.B Ctrl+b, Ctrl+Backspace, Right\-click (when screen is on)
 Click on BACK
 .TP
-.B RCtrl+s
+.B Ctrl+s
 Click on APP_SWITCH
 .TP
-.B RCtrl+m
+.B Ctrl+m
 Click on MENU
 .TP
-.B RCtrl+Up
+.B Ctrl+Up
 Click on VOLUME_UP
 .TP
-.B RCtrl+Down
+.B Ctrl+Down
 Click on VOLUME_DOWN
 .TP
-.B RCtrl+p
+.B Ctrl+p
 Click on POWER (turn screen on/off)
 .TP
@ -258,31 +243,35 @@ Click on POWER (turn screen on/off)
 Turn screen on
 .TP
-.B RCtrl+o
+.B Ctrl+o
 Turn device screen off (keep mirroring)
 .TP
-.B RCtrl+Shift+o
+.B Ctrl+r
 Turn device screen on
 .TP
 .B RCtrl+r
 Rotate device screen
 .TP
-.B RCtrl+n
+.B Ctrl+n
 Expand notification panel
 .TP
-.B RCtrl+Shift+n
+.B Ctrl+Shift+n
 Collapse notification panel
 .TP
-.B RCtrl+v
+.B Ctrl+c
-Inject computer clipboard text
+Copy device clipboard to computer
 .TP
-.B RCtrl+i
+.B Ctrl+v
 Paste computer clipboard to device
 .TP
 .B Ctrl+Shift+v
 Copy computer clipboard to device
 .TP
 .B Ctrl+i
 Enable/disable FPS counter (print frames/second in logs)
 .TP
--- a/app/src/cli.c
+++ b/app/src/cli.c
@ -12,6 +12,11 @@
 void
 scrcpy_print_usage(const char *arg0) {
 #ifdef __APPLE__
 # define CTRL_OR_CMD "Cmd"
 #else
 # define CTRL_OR_CMD "Ctrl"
 #endif
    fprintf(stderr,
        "Usage: %s [options]\n"
        "\n"
@ -49,10 +54,6 @@ scrcpy_print_usage(const char *arg0) {
        "\n"
        "        Default is 0.\n"
        "\n"
        "    --force-adb-forward\n"
        "        Do not attempt to use \"adb reverse\" to connect to the\n"
        "        the device.\n"
        "\n"
        "    -f, --fullscreen\n"
        "        Start in fullscreen.\n"
        "\n"
@ -144,18 +145,9 @@ scrcpy_print_usage(const char *arg0) {
        "\n"
        "    -v, --version\n"
        "        Print the version of scrcpy.\n"
        "\n"
        "    -V, --verbosity value\n"
        "        Set the log level (debug, info, warn or error).\n"
 #ifndef NDEBUG
        "        Default is debug.\n"
 #else
        "        Default is info.\n"
 #endif
        "\n"
        "    -w, --stay-awake\n"
-        "        Keep the device on while scrcpy is running, when the device\n"
+        "        Keep the device on while scrcpy is running.\n"
        "        is plugged in.\n"
        "\n"
        "    --window-borderless\n"
        "        Disable window decorations (display borderless window).\n"
@ -181,71 +173,71 @@ scrcpy_print_usage(const char *arg0) {
        "\n"
        "Shortcuts:\n"
        "\n"
-        "    RCtrl is the right Ctrl key (the left Ctrl key is forwarded to\n"
+        "    " CTRL_OR_CMD "+f\n"
        "    the device.\n"
        "\n"
        "    RCtrl+f\n"
        "        Switch fullscreen mode\n"
        "\n"
-        "    RCtrl+Left\n"
+        "    " CTRL_OR_CMD "+Left\n"
        "        Rotate display left\n"
        "\n"
-        "    RCtrl+Right\n"
+        "    " CTRL_OR_CMD "+Right\n"
        "        Rotate display right\n"
        "\n"
-        "    RCtrl+g\n"
+        "    " CTRL_OR_CMD "+g\n"
        "        Resize window to 1:1 (pixel-perfect)\n"
        "\n"
-        "    RCtrl+w\n"
+        "    " CTRL_OR_CMD "+x\n"
        "    Double-click on black borders\n"
        "        Resize window to remove black borders\n"
        "\n"
-        "    RCtrl+h\n"
+        "    Ctrl+h\n"
        "    Middle-click\n"
        "        Click on HOME\n"
        "\n"
-        "    RCtrl+b\n"
+        "    " CTRL_OR_CMD "+b\n"
-        "    RCtrl+Backspace\n"
+        "    " CTRL_OR_CMD "+Backspace\n"
        "    Right-click (when screen is on)\n"
        "        Click on BACK\n"
        "\n"
-        "    RCtrl+s\n"
+        "    " CTRL_OR_CMD "+s\n"
        "        Click on APP_SWITCH\n"
        "\n"
-        "    RCtrl+m\n"
+        "    Ctrl+m\n"
        "        Click on MENU\n"
        "\n"
-        "    RCtrl+Up\n"
+        "    " CTRL_OR_CMD "+Up\n"
        "        Click on VOLUME_UP\n"
        "\n"
-        "    RCtrl+Down\n"
+        "    " CTRL_OR_CMD "+Down\n"
        "        Click on VOLUME_DOWN\n"
        "\n"
-        "    RCtrl+p\n"
+        "    " CTRL_OR_CMD "+p\n"
        "        Click on POWER (turn screen on/off)\n"
        "\n"
        "    Right-click (when screen is off)\n"
        "        Power on\n"
        "\n"
-        "    RCtrl+o\n"
+        "    " CTRL_OR_CMD "+o\n"
        "        Turn device screen off (keep mirroring)\n"
        "\n"
-        "    RCtrl+Shift+o\n"
+        "    " CTRL_OR_CMD "+r\n"
        "        Turn device screen on\n"
        "\n"
        "    RCtrl+r\n"
        "        Rotate device screen\n"
        "\n"
-        "    RCtrl+n\n"
+        "    " CTRL_OR_CMD "+n\n"
        "        Expand notification panel\n"
        "\n"
-        "    RCtrl+Shift+n\n"
+        "    " CTRL_OR_CMD "+Shift+n\n"
        "        Collapse notification panel\n"
        "\n"
-        "    RCtrl+v\n"
+        "    " CTRL_OR_CMD "+c\n"
-        "        Inject computer clipboard text\n"
+        "        Copy device clipboard to computer\n"
        "\n"
-        "    RCtrl+i\n"
+        "    " CTRL_OR_CMD "+v\n"
        "        Paste computer clipboard to device\n"
        "\n"
        "    " CTRL_OR_CMD "+Shift+v\n"
        "        Copy computer clipboard to device\n"
        "\n"
        "    " CTRL_OR_CMD "+i\n"
        "        Enable/disable FPS counter (print frames/second in logs)\n"
        "\n"
        "    Drag & drop APK file\n"
@ -441,32 +433,6 @@ parse_display_id(const char *s, uint16_t *display_id) {
    return true;
 }
 static bool
 parse_log_level(const char *s, enum sc_log_level *log_level) {
    if (!strcmp(s, "debug")) {
        *log_level = SC_LOG_LEVEL_DEBUG;
        return true;
    }
    if (!strcmp(s, "info")) {
        *log_level = SC_LOG_LEVEL_INFO;
        return true;
    }
    if (!strcmp(s, "warn")) {
        *log_level = SC_LOG_LEVEL_WARN;
        return true;
    }
    if (!strcmp(s, "error")) {
        *log_level = SC_LOG_LEVEL_ERROR;
        return true;
    }
    LOGE("Could not parse log level: %s", s);
    return false;
 }
 static bool
 parse_record_format(const char *optarg, enum recorder_format *format) {
    if (!strcmp(optarg, "mp4")) {
@ -516,7 +482,6 @@ guess_record_format(const char *filename) {
 #define OPT_RENDER_DRIVER          1016
 #define OPT_NO_MIPMAPS             1017
 #define OPT_CODEC_OPTIONS          1018
 #define OPT_FORCE_ADB_FORWARD      1019
 bool
 scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
@ -526,8 +491,6 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
        {"codec-options",          required_argument, NULL, OPT_CODEC_OPTIONS},
        {"crop",                   required_argument, NULL, OPT_CROP},
        {"display",                required_argument, NULL, OPT_DISPLAY_ID},
        {"force-adb-forward",      no_argument,       NULL,
                                                  OPT_FORCE_ADB_FORWARD},
        {"fullscreen",             no_argument,       NULL, 'f'},
        {"help",                   no_argument,       NULL, 'h'},
        {"lock-video-orientation", required_argument, NULL,
@ -550,7 +513,6 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
        {"show-touches",           no_argument,       NULL, 't'},
        {"stay-awake",             no_argument,       NULL, 'w'},
        {"turn-screen-off",        no_argument,       NULL, 'S'},
        {"verbosity",              required_argument, NULL, 'V'},
        {"version",                no_argument,       NULL, 'v'},
        {"window-title",           required_argument, NULL, OPT_WINDOW_TITLE},
        {"window-x",               required_argument, NULL, OPT_WINDOW_X},
@ -567,8 +529,8 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
    optind = 0; // reset to start from the first argument in tests
    int c;
-    while ((c = getopt_long(argc, argv, "b:c:fF:hm:nNp:r:s:StTvV:w",
+    while ((c = getopt_long(argc, argv, "b:c:fF:hm:nNp:r:s:StTvw", long_options,
-                            long_options, NULL)) != -1) {
+                            NULL)) != -1) {
        switch (c) {
            case 'b':
                if (!parse_bit_rate(optarg, &opts->bit_rate)) {
@ -647,11 +609,6 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
            case 'v':
                args->version = true;
                break;
            case 'V':
                if (!parse_log_level(optarg, &opts->log_level)) {
                    return false;
                }
                break;
            case 'w':
                opts->stay_awake = true;
                break;
@ -704,9 +661,6 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
            case OPT_CODEC_OPTIONS:
                opts->codec_options = optarg;
                break;
            case OPT_FORCE_ADB_FORWARD:
                opts->force_adb_forward = true;
                break;
            default:
                // getopt prints the error message on stderr
                return false;
--- a/app/src/control_msg.c
+++ b/app/src/control_msg.c
@ -67,11 +67,10 @@ control_msg_serialize(const struct control_msg *msg, unsigned char *buf) {
                             (uint32_t) msg->inject_scroll_event.vscroll);
            return 21;
        case CONTROL_MSG_TYPE_SET_CLIPBOARD: {
-            buf[1] = !!msg->set_clipboard.paste;
+            size_t len = write_string(msg->inject_text.text,
            size_t len = write_string(msg->set_clipboard.text,
                                      CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH,
-                                      &buf[2]);
+                                      &buf[1]);
-            return 2 + len;
+            return 1 + len;
        }
        case CONTROL_MSG_TYPE_SET_SCREEN_POWER_MODE:
            buf[1] = msg->set_screen_power_mode.mode;
--- a/app/src/control_msg.h
+++ b/app/src/control_msg.h
@ -11,9 +11,9 @@
 #include "common.h"
 #define CONTROL_MSG_INJECT_TEXT_MAX_LENGTH 300
-#define CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH 4092
+#define CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH 4093
 #define CONTROL_MSG_SERIALIZED_MAX_SIZE \
-    (4 + CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH)
+    (3 + CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH)
 #define POINTER_ID_MOUSE UINT64_C(-1);
@ -62,7 +62,6 @@ struct control_msg {
        } inject_scroll_event;
        struct {
            char *text; // owned, to be freed by SDL_free()
            bool paste;
        } set_clipboard;
        struct {
            enum screen_power_mode mode;
--- a/app/src/event_converter.c
+++ b/app/src/event_converter.c
@ -92,9 +92,6 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
        MAP(SDLK_LEFT,         AKEYCODE_DPAD_LEFT);
        MAP(SDLK_DOWN,         AKEYCODE_DPAD_DOWN);
        MAP(SDLK_UP,           AKEYCODE_DPAD_UP);
        MAP(SDLK_LCTRL,        AKEYCODE_CTRL_LEFT);
        MAP(SDLK_LSHIFT,       AKEYCODE_SHIFT_LEFT);
        MAP(SDLK_RSHIFT,       AKEYCODE_SHIFT_RIGHT);
    }
    if (!(mod & (KMOD_NUM | KMOD_SHIFT))) {
@ -114,7 +111,7 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
        }
    }
-    if (prefer_text && !(mod & KMOD_LCTRL)) {
+    if (prefer_text) {
        // do not forward alpha and space key events
        return false;
    }
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
@ -7,6 +7,33 @@
 #include "util/lock.h"
 #include "util/log.h"
 // Convert window coordinates (as provided by SDL_GetMouseState() to renderer
 // coordinates (as provided in SDL mouse events)
 //
 // See my question:
 // <https://stackoverflow.com/questions/49111054/how-to-get-mouse-position-on-mouse-wheel-event>
 static void
 convert_to_renderer_coordinates(SDL_Renderer *renderer, int *x, int *y) {
    SDL_Rect viewport;
    float scale_x, scale_y;
    SDL_RenderGetViewport(renderer, &viewport);
    SDL_RenderGetScale(renderer, &scale_x, &scale_y);
    *x = (int) (*x / scale_x) - viewport.x;
    *y = (int) (*y / scale_y) - viewport.y;
 }
 static struct point
 get_mouse_point(struct screen *screen) {
    int x;
    int y;
    SDL_GetMouseState(&x, &y);
    convert_to_renderer_coordinates(screen->renderer, &x, &y);
    return (struct point) {
        .x = x,
        .y = y,
    };
 }
 static const int ACTION_DOWN = 1;
 static const int ACTION_UP = 1 << 1;
@ -102,7 +129,17 @@ collapse_notification_panel(struct controller *controller) {
 }
 static void
-set_device_clipboard(struct controller *controller, bool paste) {
+request_device_clipboard(struct controller *controller) {
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_GET_CLIPBOARD;
    if (!controller_push_msg(controller, &msg)) {
        LOGW("Could not request device clipboard");
    }
 }
 static void
 set_device_clipboard(struct controller *controller) {
    char *text = SDL_GetClipboardText();
    if (!text) {
        LOGW("Could not get clipboard text: %s", SDL_GetError());
@ -117,7 +154,6 @@ set_device_clipboard(struct controller *controller, bool paste) {
    struct control_msg msg;
    msg.type = CONTROL_MSG_TYPE_SET_CLIPBOARD;
    msg.set_clipboard.text = text;
    msg.set_clipboard.paste = paste;
    if (!controller_push_msg(controller, &msg)) {
        SDL_free(text);
@ -242,25 +278,6 @@ convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to,
    return true;
 }
 static void
 inject_as_ctrl(struct input_manager *im, const SDL_KeyboardEvent *event) {
    struct control_msg msg;
    if (!convert_input_key(event, &msg, false)) {
        return;
    }
    // Disable RCtrl and Meta
    msg.inject_keycode.metastate &=
        ~(AMETA_CTRL_RIGHT_ON | AMETA_META_LEFT_ON | AMETA_META_RIGHT_ON);
    // Enable LCtrl
    msg.inject_keycode.metastate |= AMETA_CTRL_LEFT_ON;
    if (!controller_push_msg(im->controller, &msg)) {
        LOGW("Could not request 'inject keycode'");
    }
 }
 void
 input_manager_process_key(struct input_manager *im,
                          const SDL_KeyboardEvent *event,
@ -268,127 +285,134 @@ input_manager_process_key(struct input_manager *im,
    // control: indicates the state of the command-line option --no-control
    // ctrl: the Ctrl key
-    bool lctrl = event->keysym.mod & KMOD_LCTRL;
+    bool ctrl = event->keysym.mod & (KMOD_LCTRL | KMOD_RCTRL);
    bool rctrl = event->keysym.mod & KMOD_RCTRL;
    bool alt = event->keysym.mod & (KMOD_LALT | KMOD_RALT);
    bool meta = event->keysym.mod & (KMOD_LGUI | KMOD_RGUI);
    bool shift = event->keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT);
-    bool shortcut_key = rctrl;
+    // use Cmd on macOS, Ctrl on other platforms
 #ifdef __APPLE__
-    shortcut_key |= meta;
+    bool cmd = !ctrl && meta;
 #else
    if (meta) {
-        // No shortcut involve Meta, and it is not forwarded to the device
+        // no shortcuts involve Meta on platforms other than macOS, and it must
        // not be forwarded to the device
        return;
    }
    bool cmd = ctrl; // && !meta, already guaranteed
 #endif
    if (alt) {
-        // No shortcuts involve Alt, and it is not forwarded to the device
+        // no shortcuts involve Alt, and it must not be forwarded to the device
        return;
    }
    struct controller *controller = im->controller;
-    SDL_Keycode keycode = event->keysym.sym;
+    // capture all Ctrl events
-    bool down = event->type == SDL_KEYDOWN;
+    if (ctrl || cmd) {
-
+        SDL_Keycode keycode = event->keysym.sym;
-    // Capture all RCtrl events
+        bool down = event->type == SDL_KEYDOWN;
    if (shortcut_key) {
        int action = down ? ACTION_DOWN : ACTION_UP;
        bool repeat = event->repeat;
        bool shift = event->keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT);
        switch (keycode) {
            case SDLK_h:
                // Ctrl+h on all platform, since Cmd+h is already captured by
                // the system on macOS to hide the window
-                if (control && !shift && !repeat) {
+                if (control && ctrl && !meta && !shift && !repeat) {
                    action_home(controller, action);
                }
                return;
            case SDLK_b: // fall-through
            case SDLK_BACKSPACE:
-                if (control && !shift && !repeat) {
+                if (control && cmd && !shift && !repeat) {
                    action_back(controller, action);
                }
                return;
            case SDLK_s:
-                if (control && !shift && !repeat) {
+                if (control && cmd && !shift && !repeat) {
                    action_app_switch(controller, action);
                }
                return;
            case SDLK_m:
                // Ctrl+m on all platform, since Cmd+m is already captured by
                // the system on macOS to minimize the window
-                if (control && !shift && !repeat) {
+                if (control && ctrl && !meta && !shift && !repeat) {
                    action_menu(controller, action);
                }
                return;
            case SDLK_p:
-                if (control && !shift && !repeat) {
+                if (control && cmd && !shift && !repeat) {
                    action_power(controller, action);
                }
                return;
            case SDLK_o:
-                if (control && !repeat && down) {
+                if (control && cmd && !shift && down) {
-                    enum screen_power_mode mode = shift
+                    set_screen_power_mode(controller, SCREEN_POWER_MODE_OFF);
                                                ? SCREEN_POWER_MODE_NORMAL
                                                : SCREEN_POWER_MODE_OFF;
                    set_screen_power_mode(controller, mode);
                }
                return;
            case SDLK_DOWN:
-                if (control && !shift) {
+                if (control && cmd && !shift) {
                    // forward repeated events
                    action_volume_down(controller, action);
                }
                return;
            case SDLK_UP:
-                if (control && !shift) {
+                if (control && cmd && !shift) {
                    // forward repeated events
                    action_volume_up(controller, action);
                }
                return;
            case SDLK_LEFT:
-                if (!shift && !repeat && down) {
+                if (cmd && !shift && down) {
                    rotate_client_left(im->screen);
                }
                return;
            case SDLK_RIGHT:
-                if (!shift && !repeat && down) {
+                if (cmd && !shift && down) {
                    rotate_client_right(im->screen);
                }
                return;
            case SDLK_c:
                if (control && cmd && !shift && !repeat && down) {
                    request_device_clipboard(controller);
                }
                return;
            case SDLK_v:
-                if (control && !shift && !repeat && down) {
+                if (control && cmd && !repeat && down) {
-                    // Inject the text as input events
+                    if (shift) {
-                    clipboard_paste(controller);
+                        // store the text in the device clipboard
                        set_device_clipboard(controller);
                    } else {
                        // inject the text as input events
                        clipboard_paste(controller);
                    }
                }
                return;
            case SDLK_f:
-                if (!shift && !repeat && down) {
+                if (!shift && cmd && !repeat && down) {
                    screen_switch_fullscreen(im->screen);
                }
                return;
-            case SDLK_w:
+            case SDLK_x:
-                if (!shift && !repeat && down) {
+                if (!shift && cmd && !repeat && down) {
                    screen_resize_to_fit(im->screen);
                }
                return;
            case SDLK_g:
-                if (!shift && !repeat && down) {
+                if (!shift && cmd && !repeat && down) {
                    screen_resize_to_pixel_perfect(im->screen);
                }
                return;
            case SDLK_i:
-                if (!shift && !repeat && down) {
+                if (!shift && cmd && !repeat && down) {
                    struct fps_counter *fps_counter =
                        im->video_buffer->fps_counter;
                    switch_fps_counter_state(fps_counter);
                }
                return;
            case SDLK_n:
-                if (control && !repeat && down) {
+                if (control && cmd && !repeat && down) {
                    if (shift) {
                        collapse_notification_panel(controller);
                    } else {
@ -397,19 +421,10 @@ input_manager_process_key(struct input_manager *im,
                }
                return;
            case SDLK_r:
-                if (control && !shift && !repeat && down) {
+                if (control && cmd && !shift && !repeat && down) {
                    rotate_device(controller);
                }
                return;
            case SDLK_c:
            case SDLK_x:
                if (control && !shift) {
                    // For convenience, forward shortcut_key+c and
                    // shortcut_key+x as Ctrl+c and Ctrl+x (typically "copy" and
                    // "cut", but not always) to the device
                    inject_as_ctrl(im, event);
                }
                return;
        }
        return;
@ -419,12 +434,6 @@ input_manager_process_key(struct input_manager *im,
        return;
    }
    if (lctrl && !shift && keycode == SDLK_v && down) {
        // Synchronize the computer clipboard to the device clipboard before
        // sending Ctrl+V, to allow seamless copy-paste.
        set_device_clipboard(controller, false);
    }
    struct control_msg msg;
    if (convert_input_key(event, &msg, im->prefer_text)) {
        if (!controller_push_msg(controller, &msg)) {
@ -478,17 +487,11 @@ convert_touch(const SDL_TouchFingerEvent *from, struct screen *screen,
    to->inject_touch_event.pointer_id = from->fingerId;
    to->inject_touch_event.position.screen_size = screen->frame_size;
    int ww;
    int wh;
    SDL_GL_GetDrawableSize(screen->window, &ww, &wh);
    // SDL touch event coordinates are normalized in the range [0; 1]
-    int32_t x = from->x * ww;
+    float x = from->x * screen->content_size.width;
-    int32_t y = from->y * wh;
+    float y = from->y * screen->content_size.height;
    to->inject_touch_event.position.point =
        screen_convert_to_frame_coords(screen, x, y);
    to->inject_touch_event.pressure = from->pressure;
    to->inject_touch_event.buttons = 0;
    return true;
@ -505,6 +508,13 @@ input_manager_process_touch(struct input_manager *im,
    }
 }
 static bool
 is_outside_device_screen(struct input_manager *im, int x, int y)
 {
    return x < 0 || x >= im->screen->content_size.width ||
           y < 0 || y >= im->screen->content_size.height;
 }
 static bool
 convert_mouse_button(const SDL_MouseButtonEvent *from, struct screen *screen,
                     struct control_msg *to) {
@ -542,15 +552,10 @@ input_manager_process_mouse_button(struct input_manager *im,
            action_home(im->controller, ACTION_DOWN | ACTION_UP);
            return;
        }
        // double-click on black borders resize to fit the device screen
        if (event->button == SDL_BUTTON_LEFT && event->clicks == 2) {
-            int32_t x = event->x;
+            bool outside =
-            int32_t y = event->y;
+                is_outside_device_screen(im, event->x, event->y);
            screen_hidpi_scale_coords(im->screen, &x, &y);
            SDL_Rect *r = &im->screen->rect;
            bool outside = x < r->x || x >= r->x + r->w
                        || y < r->y || y >= r->y + r->h;
            if (outside) {
                screen_resize_to_fit(im->screen);
                return;
@ -574,15 +579,9 @@ input_manager_process_mouse_button(struct input_manager *im,
 static bool
 convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct screen *screen,
                    struct control_msg *to) {
    // mouse_x and mouse_y are expressed in pixels relative to the window
    int mouse_x;
    int mouse_y;
    SDL_GetMouseState(&mouse_x, &mouse_y);
    struct position position = {
        .screen_size = screen->frame_size,
-        .point = screen_convert_to_frame_coords(screen, mouse_x, mouse_y),
+        .point = get_mouse_point(screen),
    };
    to->type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT;
--- a/app/src/main.c
+++ b/app/src/main.c
@ -29,24 +29,6 @@ print_version(void) {
                                               LIBAVUTIL_VERSION_MICRO);
 }
 static SDL_LogPriority
 convert_log_level_to_sdl(enum sc_log_level level) {
    switch (level) {
        case SC_LOG_LEVEL_DEBUG:
            return SDL_LOG_PRIORITY_DEBUG;
        case SC_LOG_LEVEL_INFO:
            return SDL_LOG_PRIORITY_INFO;
        case SC_LOG_LEVEL_WARN:
            return SDL_LOG_PRIORITY_WARN;
        case SC_LOG_LEVEL_ERROR:
            return SDL_LOG_PRIORITY_ERROR;
        default:
            assert(!"unexpected log level");
            return SDL_LOG_PRIORITY_INFO;
    }
 }
 int
 main(int argc, char *argv[]) {
 #ifdef __WINDOWS__
@ -56,23 +38,20 @@ main(int argc, char *argv[]) {
    setbuf(stderr, NULL);
 #endif
 #ifndef NDEBUG
    SDL_LogSetAllPriority(SDL_LOG_PRIORITY_DEBUG);
 #endif
    struct scrcpy_cli_args args = {
        .opts = SCRCPY_OPTIONS_DEFAULT,
        .help = false,
        .version = false,
    };
 #ifndef NDEBUG
    args.opts.log_level = SC_LOG_LEVEL_DEBUG;
 #endif
    if (!scrcpy_parse_args(&args, argc, argv)) {
        return 1;
    }
    SDL_LogPriority sdl_log = convert_log_level_to_sdl(args.opts.log_level);
    SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, sdl_log);
    if (args.help) {
        scrcpy_print_usage(argv[0]);
        return 0;
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@ -7,10 +7,6 @@
 #include <sys/time.h>
 #include <SDL2/SDL.h>
 #ifdef _WIN32
 # include <windows.h>
 #endif
 #include "config.h"
 #include "command.h"
 #include "common.h"
@ -49,18 +45,6 @@ static struct input_manager input_manager = {
    .prefer_text = false, // initialized later
 };
 #ifdef _WIN32
 BOOL WINAPI windows_ctrl_handler(DWORD ctrl_type) {
    if (ctrl_type == CTRL_C_EVENT) {
        SDL_Event event;
        event.type = SDL_QUIT;
        SDL_PushEvent(&event);
        return TRUE;
    }
    return FALSE;
 }
 #endif // _WIN32
 // init SDL and set appropriate hints
 static bool
 sdl_init_and_configure(bool display, const char *render_driver) {
@ -72,14 +56,6 @@ sdl_init_and_configure(bool display, const char *render_driver) {
    atexit(SDL_Quit);
 #ifdef _WIN32
    // Clean up properly on Ctrl+C on Windows
    bool ok = SetConsoleCtrlHandler(windows_ctrl_handler, TRUE);
    if (!ok) {
        LOGW("Could not set Ctrl+C handler");
    }
 #endif // _WIN32
    if (!display) {
        return true;
    }
@ -133,10 +109,10 @@ static int
 event_watcher(void *data, SDL_Event *event) {
    (void) data;
    if (event->type == SDL_WINDOWEVENT
-            && event->window.event == SDL_WINDOWEVENT_RESIZED) {
+            && event->window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
        // In practice, it seems to always be called from the same thread in
        // that specific case. Anyway, it's just a workaround.
-        screen_render(&screen, true);
+        screen_handle_window_event(&screen, &event->window);
    }
    return 0;
 }
@ -293,7 +269,6 @@ bool
 scrcpy(const struct scrcpy_options *options) {
    bool record = !!options->record_filename;
    struct server_params params = {
        .log_level = options->log_level,
        .crop = options->crop,
        .port_range = options->port_range,
        .max_size = options->max_size,
@ -305,7 +280,6 @@ scrcpy(const struct scrcpy_options *options) {
        .show_touches = options->show_touches,
        .stay_awake = options->stay_awake,
        .codec_options = options->codec_options,
        .force_adb_forward = options->force_adb_forward,
    };
    if (!server_start(&server, options->serial, &params)) {
        return false;
--- a/app/src/scrcpy.h
+++ b/app/src/scrcpy.h
@ -8,7 +8,6 @@
 #include "common.h"
 #include "input_manager.h"
 #include "recorder.h"
 #include "util/log.h"
 struct scrcpy_options {
    const char *serial;
@ -18,7 +17,6 @@ struct scrcpy_options {
    const char *push_target;
    const char *render_driver;
    const char *codec_options;
    enum sc_log_level log_level;
    enum recorder_format record_format;
    struct port_range port_range;
    uint16_t max_size;
@ -42,7 +40,6 @@ struct scrcpy_options {
    bool window_borderless;
    bool mipmaps;
    bool stay_awake;
    bool force_adb_forward;
 };
 #define SCRCPY_OPTIONS_DEFAULT { \
@ -53,7 +50,6 @@ struct scrcpy_options {
    .push_target = NULL, \
    .render_driver = NULL, \
    .codec_options = NULL, \
    .log_level = SC_LOG_LEVEL_INFO, \
    .record_format = RECORDER_FORMAT_AUTO, \
    .port_range = { \
        .first = DEFAULT_LOCAL_PORT_RANGE_FIRST, \
@ -80,7 +76,6 @@ struct scrcpy_options {
    .window_borderless = false, \
    .mipmaps = true, \
    .stay_awake = false, \
    .force_adb_forward = false, \
 }
 bool
--- a/app/src/screen.c
+++ b/app/src/screen.c
@ -30,10 +30,10 @@ get_rotated_size(struct size size, int rotation) {
 // get the window size in a struct size
 static struct size
-get_window_size(const struct screen *screen) {
+get_window_size(SDL_Window *window) {
    int width;
    int height;
-    SDL_GetWindowSize(screen->window, &width, &height);
+    SDL_GetWindowSize(window, &width, &height);
    struct size size;
    size.width = width;
@ -41,12 +41,31 @@ get_window_size(const struct screen *screen) {
    return size;
 }
 // get the windowed window size
 static struct size
 get_windowed_window_size(const struct screen *screen) {
    if (screen->fullscreen || screen->maximized) {
        return screen->windowed_window_size;
    }
    return get_window_size(screen->window);
 }
 // apply the windowed window size if fullscreen and maximized are disabled
 static void
 apply_windowed_size(struct screen *screen) {
    if (!screen->fullscreen && !screen->maximized) {
        SDL_SetWindowSize(screen->window, screen->windowed_window_size.width,
                                          screen->windowed_window_size.height);
    }
 }
 // set the window size to be applied when fullscreen is disabled
 static void
 set_window_size(struct screen *screen, struct size new_size) {
-    assert(!screen->fullscreen);
+    // setting the window size during fullscreen is implementation defined,
-    assert(!screen->maximized);
+    // so apply the resize only after fullscreen is disabled
-    SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
+    screen->windowed_window_size = new_size;
    apply_windowed_size(screen);
 }
 // get the preferred display bounds (i.e. the screen bounds with some margins)
@ -68,16 +87,6 @@ get_preferred_display_bounds(struct size *bounds) {
    return true;
 }
 static bool
 is_optimal_size(struct size current_size, struct size content_size) {
    // The size is optimal if we can recompute one dimension of the current
    // size from the other
    return current_size.height == current_size.width * content_size.height
                                                     / content_size.width
        || current_size.width == current_size.height * content_size.width
                                                     / content_size.height;
 }
 // return the optimal size of the window, with the following constraints:
 //  - it attempts to keep at least one dimension of the current_size (i.e. it
 //    crops the black borders)
@ -90,43 +99,47 @@ get_optimal_size(struct size current_size, struct size content_size) {
        return current_size;
    }
    struct size window_size;
    struct size display_size;
    // 32 bits because we need to multiply two 16 bits values
    uint32_t w;
    uint32_t h;
    if (!get_preferred_display_bounds(&display_size)) {
        // could not get display bounds, do not constraint the size
-        window_size.width = current_size.width;
+        w = current_size.width;
-        window_size.height = current_size.height;
+        h = current_size.height;
    } else {
-        window_size.width = MIN(current_size.width, display_size.width);
+        w = MIN(current_size.width, display_size.width);
-        window_size.height = MIN(current_size.height, display_size.height);
+        h = MIN(current_size.height, display_size.height);
    }
-    if (is_optimal_size(window_size, content_size)) {
+    if (h == w * content_size.height / content_size.width
-        return window_size;
+     || w == h * content_size.width / content_size.height) {
        // The size is already optimal, if we ignore rounding errors due to
        // integer window dimensions
        return (struct size) {w, h};
    }
-    bool keep_width = content_size.width * window_size.height
+    bool keep_width = content_size.width * h > content_size.height * w;
                    > content_size.height * window_size.width;
    if (keep_width) {
        // remove black borders on top and bottom
-        window_size.height = content_size.height * window_size.width
+        h = content_size.height * w / content_size.width;
                           / content_size.width;
    } else {
        // remove black borders on left and right (or none at all if it already
        // fits)
-        window_size.width = content_size.width * window_size.height
+        w = content_size.width * h / content_size.height;
                          / content_size.height;
    }
-    return window_size;
+    // w and h must fit into 16 bits
    assert(w < 0x10000 && h < 0x10000);
    return (struct size) {w, h};
 }
 // same as get_optimal_size(), but read the current size from the window
 static inline struct size
 get_optimal_window_size(const struct screen *screen, struct size content_size) {
-    struct size window_size = get_window_size(screen);
+    struct size windowed_size = get_windowed_window_size(screen);
-    return get_optimal_size(window_size, content_size);
+    return get_optimal_size(windowed_size, content_size);
 }
 // initially, there is no current size, so use the frame size as current size
@ -156,43 +169,6 @@ get_initial_optimal_size(struct size content_size, uint16_t req_width,
    return window_size;
 }
 static void
 screen_update_content_rect(struct screen *screen) {
    int dw;
    int dh;
    SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
    struct size content_size = screen->content_size;
    // The drawable size is the window size * the HiDPI scale
    struct size drawable_size = {dw, dh};
    SDL_Rect *rect = &screen->rect;
    if (is_optimal_size(drawable_size, content_size)) {
        rect->x = 0;
        rect->y = 0;
        rect->w = drawable_size.width;
        rect->h = drawable_size.height;
        return;
    }
    bool keep_width = content_size.width * drawable_size.height
                    > content_size.height * drawable_size.width;
    if (keep_width) {
        rect->x = 0;
        rect->w = drawable_size.width;
        rect->h = drawable_size.width * content_size.height
                                      / content_size.width;
        rect->y = (drawable_size.height - rect->h) / 2;
    } else {
        rect->y = 0;
        rect->h = drawable_size.height;
        rect->w = drawable_size.height * content_size.width
                                       / content_size.height;
        rect->x = (drawable_size.width - rect->w) / 2;
    }
 }
 void
 screen_init(struct screen *screen) {
    *screen = (struct screen) SCREEN_INITIALIZER;
@ -217,7 +193,7 @@ create_texture(struct screen *screen) {
        // Enable trilinear filtering for downscaling
        gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
                          GL_LINEAR_MIPMAP_LINEAR);
-        gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -1.f);
+        gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -.5f);
        SDL_GL_UnbindTexture(texture);
    }
@ -282,6 +258,13 @@ screen_init_rendering(struct screen *screen, const char *window_title,
    const char *renderer_name = r ? NULL : renderer_info.name;
    LOGI("Renderer: %s", renderer_name ? renderer_name : "(unknown)");
    if (SDL_RenderSetLogicalSize(screen->renderer, content_size.width,
                                 content_size.height)) {
        LOGE("Could not set renderer logical size: %s", SDL_GetError());
        screen_destroy(screen);
        return false;
    }
    // starts with "opengl"
    screen->use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
    if (screen->use_opengl) {
@ -305,7 +288,7 @@ screen_init_rendering(struct screen *screen, const char *window_title,
            LOGI("Trilinear filtering disabled");
        }
    } else {
-        LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
+        LOGW("Trilinear filtering disabled (not an OpenGL renderer)");
    }
    SDL_Surface *icon = read_xpm(icon_xpm);
@ -325,12 +308,7 @@ screen_init_rendering(struct screen *screen, const char *window_title,
        return false;
    }
-    // Reset the window size to trigger a SIZE_CHANGED event, to workaround
+    screen->windowed_window_size = window_size;
    // HiDPI issues with some SDL renderers when several displays having
    // different HiDPI scaling are connected
    SDL_SetWindowSize(screen->window, window_size.width, window_size.height);
    screen_update_content_rect(screen);
    return true;
 }
@ -353,45 +331,6 @@ screen_destroy(struct screen *screen) {
    }
 }
 static void
 resize_for_content(struct screen *screen, struct size old_content_size,
                                                 struct size new_content_size) {
    struct size window_size = get_window_size(screen);
    struct size target_size = {
        .width = (uint32_t) window_size.width * new_content_size.width
                / old_content_size.width,
        .height = (uint32_t) window_size.height * new_content_size.height
                / old_content_size.height,
    };
    target_size = get_optimal_size(target_size, new_content_size);
    set_window_size(screen, target_size);
 }
 static void
 set_content_size(struct screen *screen, struct size new_content_size) {
    if (!screen->fullscreen && !screen->maximized) {
        resize_for_content(screen, screen->content_size, new_content_size);
    } else if (!screen->resize_pending) {
        // Store the windowed size to be able to compute the optimal size once
        // fullscreen and maximized are disabled
        screen->windowed_content_size = screen->content_size;
        screen->resize_pending = true;
    }
    screen->content_size = new_content_size;
 }
 static void
 apply_pending_resize(struct screen *screen) {
    assert(!screen->fullscreen);
    assert(!screen->maximized);
    if (screen->resize_pending) {
        resize_for_content(screen, screen->windowed_content_size,
                                   screen->content_size);
        screen->resize_pending = false;
    }
 }
 void
 screen_set_rotation(struct screen *screen, unsigned rotation) {
    assert(rotation < 4);
@ -399,15 +338,32 @@ screen_set_rotation(struct screen *screen, unsigned rotation) {
        return;
    }
    struct size old_content_size = screen->content_size;
    struct size new_content_size =
        get_rotated_size(screen->frame_size, rotation);
-    set_content_size(screen, new_content_size);
+    if (SDL_RenderSetLogicalSize(screen->renderer,
                                 new_content_size.width,
                                 new_content_size.height)) {
        LOGE("Could not set renderer logical size: %s", SDL_GetError());
        return;
    }
    struct size windowed_size = get_windowed_window_size(screen);
    struct size target_size = {
        .width = (uint32_t) windowed_size.width * new_content_size.width
                / old_content_size.width,
        .height = (uint32_t) windowed_size.height * new_content_size.height
                / old_content_size.height,
    };
    target_size = get_optimal_size(target_size, new_content_size);
    set_window_size(screen, target_size);
    screen->content_size = new_content_size;
    screen->rotation = rotation;
    LOGI("Display rotation set to %u", rotation);
-    screen_render(screen, true);
+    screen_render(screen);
 }
 // recreate the texture and resize the window if the frame size has changed
@ -415,16 +371,31 @@ static bool
 prepare_for_frame(struct screen *screen, struct size new_frame_size) {
    if (screen->frame_size.width != new_frame_size.width
            || screen->frame_size.height != new_frame_size.height) {
        struct size new_content_size =
            get_rotated_size(new_frame_size, screen->rotation);
        if (SDL_RenderSetLogicalSize(screen->renderer,
                                     new_content_size.width,
                                     new_content_size.height)) {
            LOGE("Could not set renderer logical size: %s", SDL_GetError());
            return false;
        }
        // frame dimension changed, destroy texture
        SDL_DestroyTexture(screen->texture);
        struct size content_size = screen->content_size;
        struct size windowed_size = get_windowed_window_size(screen);
        struct size target_size = {
            (uint32_t) windowed_size.width * new_content_size.width
                    / content_size.width,
            (uint32_t) windowed_size.height * new_content_size.height
                    / content_size.height,
        };
        target_size = get_optimal_size(target_size, new_content_size);
        set_window_size(screen, target_size);
        screen->frame_size = new_frame_size;
-
+        screen->content_size = new_content_size;
        struct size new_content_size =
            get_rotated_size(new_frame_size, screen->rotation);
        set_content_size(screen, new_content_size);
        screen_update_content_rect(screen);
        LOGI("New texture: %" PRIu16 "x%" PRIu16,
                     screen->frame_size.width, screen->frame_size.height);
@ -466,19 +437,15 @@ screen_update_frame(struct screen *screen, struct video_buffer *vb) {
    update_texture(screen, frame);
    mutex_unlock(vb->mutex);
-    screen_render(screen, false);
+    screen_render(screen);
    return true;
 }
 void
-screen_render(struct screen *screen, bool update_content_rect) {
+screen_render(struct screen *screen) {
    if (update_content_rect) {
        screen_update_content_rect(screen);
    }
    SDL_RenderClear(screen->renderer);
    if (screen->rotation == 0) {
-        SDL_RenderCopy(screen->renderer, screen->texture, NULL, &screen->rect);
+        SDL_RenderCopy(screen->renderer, screen->texture, NULL, NULL);
    } else {
        // rotation in RenderCopyEx() is clockwise, while screen->rotation is
        // counterclockwise (to be consistent with --lock-video-orientation)
@ -488,14 +455,12 @@ screen_render(struct screen *screen, bool update_content_rect) {
        SDL_Rect *dstrect = NULL;
        SDL_Rect rect;
        if (screen->rotation & 1) {
-            rect.x = screen->rect.x + (screen->rect.w - screen->rect.h) / 2;
+            struct size size = screen->content_size;
-            rect.y = screen->rect.y + (screen->rect.h - screen->rect.w) / 2;
+            rect.x = (size.width - size.height) / 2;
-            rect.w = screen->rect.h;
+            rect.y = (size.height - size.width) / 2;
-            rect.h = screen->rect.w;
+            rect.w = size.height;
            rect.h = size.width;
            dstrect = &rect;
        } else {
            assert(screen->rotation == 2);
            dstrect = &screen->rect;
        }
        SDL_RenderCopyEx(screen->renderer, screen->texture, NULL, dstrect,
@ -513,20 +478,23 @@ screen_switch_fullscreen(struct screen *screen) {
    }
    screen->fullscreen = !screen->fullscreen;
-    if (!screen->fullscreen && !screen->maximized) {
+    apply_windowed_size(screen);
        apply_pending_resize(screen);
    }
    LOGD("Switched to %s mode", screen->fullscreen ? "fullscreen" : "windowed");
-    screen_render(screen, true);
+    screen_render(screen);
 }
 void
 screen_resize_to_fit(struct screen *screen) {
-    if (screen->fullscreen || screen->maximized) {
+    if (screen->fullscreen) {
        return;
    }
    if (screen->maximized) {
        SDL_RestoreWindow(screen->window);
        screen->maximized = false;
    }
    struct size optimal_size =
        get_optimal_window_size(screen, screen->content_size);
    SDL_SetWindowSize(screen->window, optimal_size.width, optimal_size.height);
@ -556,24 +524,39 @@ screen_handle_window_event(struct screen *screen,
                           const SDL_WindowEvent *event) {
    switch (event->event) {
        case SDL_WINDOWEVENT_EXPOSED:
-            screen_render(screen, true);
+            screen_render(screen);
            break;
        case SDL_WINDOWEVENT_SIZE_CHANGED:
-            screen_render(screen, true);
+            if (!screen->fullscreen && !screen->maximized) {
                // Backup the previous size: if we receive the MAXIMIZED event,
                // then the new size must be ignored (it's the maximized size).
                // We could not rely on the window flags due to race conditions
                // (they could be updated asynchronously, at least on X11).
                screen->windowed_window_size_backup =
                    screen->windowed_window_size;
                // Save the windowed size, so that it is available once the
                // window is maximized or fullscreen is enabled.
                screen->windowed_window_size = get_window_size(screen->window);
            }
            screen_render(screen);
            break;
        case SDL_WINDOWEVENT_MAXIMIZED:
            // The backup size must be non-nul.
            assert(screen->windowed_window_size_backup.width);
            assert(screen->windowed_window_size_backup.height);
            // Revert the last size, it was updated while screen was maximized.
            screen->windowed_window_size = screen->windowed_window_size_backup;
 #ifdef DEBUG
            // Reset the backup to invalid values to detect unexpected usage
            screen->windowed_window_size_backup.width = 0;
            screen->windowed_window_size_backup.height = 0;
 #endif
            screen->maximized = true;
            break;
        case SDL_WINDOWEVENT_RESTORED:
            if (screen->fullscreen) {
                // On Windows, in maximized+fullscreen, disabling fullscreen
                // mode unexpectedly triggers the "restored" then "maximized"
                // events, leaving the window in a weird state (maximized
                // according to the events, but not maximized visually).
                break;
            }
            screen->maximized = false;
-            apply_pending_resize(screen);
+            apply_windowed_size(screen);
            break;
    }
 }
@ -585,13 +568,6 @@ screen_convert_to_frame_coords(struct screen *screen, int32_t x, int32_t y) {
    int32_t w = screen->content_size.width;
    int32_t h = screen->content_size.height;
    screen_hidpi_scale_coords(screen, &x, &y);
    x = (int64_t) (x - screen->rect.x) * w / screen->rect.w;
    y = (int64_t) (y - screen->rect.y) * h / screen->rect.h;
    // rotate
    struct point result;
    switch (rotation) {
        case 0:
@ -614,15 +590,3 @@ screen_convert_to_frame_coords(struct screen *screen, int32_t x, int32_t y) {
    }
    return result;
 }
 void
 screen_hidpi_scale_coords(struct screen *screen, int32_t *x, int32_t *y) {
    // take the HiDPI scaling (dw/ww and dh/wh) into account
    int ww, wh, dw, dh;
    SDL_GetWindowSize(screen->window, &ww, &wh);
    SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
    // scale for HiDPI (64 bits for intermediate multiplications)
    *x = (int64_t) *x * dw / ww;
    *y = (int64_t) *y * dh / wh;
 }
--- a/app/src/screen.h
+++ b/app/src/screen.h
@ -21,16 +21,13 @@ struct screen {
    struct sc_opengl gl;
    struct size frame_size;
    struct size content_size; // rotated frame_size
-
+    // The window size the last time it was not maximized or fullscreen.
-    bool resize_pending; // resize requested while fullscreen or maximized
+    struct size windowed_window_size;
-    // The content size the last time the window was not maximized or
+    // Since we receive the event SIZE_CHANGED before MAXIMIZED, we must be
-    // fullscreen (meaningful only when resize_pending is true)
+    // able to revert the size to its non-maximized value.
-    struct size windowed_content_size;
+    struct size windowed_window_size_backup;
    // client rotation: 0, 1, 2 or 3 (x90 degrees counterclockwise)
    unsigned rotation;
    // rectangle of the content (excluding black borders)
    struct SDL_Rect rect;
    bool has_frame;
    bool fullscreen;
    bool maximized;
@ -52,18 +49,15 @@ struct screen {
        .width = 0, \
        .height = 0, \
    }, \
-    .resize_pending = false, \
+    .windowed_window_size = { \
-    .windowed_content_size = { \
+        .width = 0, \
        .height = 0, \
    }, \
    .windowed_window_size_backup = { \
        .width = 0, \
        .height = 0, \
    }, \
    .rotation = 0, \
    .rect = { \
        .x = 0, \
        .y = 0, \
        .w = 0, \
        .h = 0, \
    }, \
    .has_frame = false, \
    .fullscreen = false, \
    .maximized = false, \
@ -97,11 +91,8 @@ bool
 screen_update_frame(struct screen *screen, struct video_buffer *vb);
 // render the texture to the renderer
 //
 // Set the update_content_rect flag if the window or content size may have
 // changed, so that the content rectangle is recomputed
 void
-screen_render(struct screen *screen, bool update_content_rect);
+screen_render(struct screen *screen);
 // switch the fullscreen mode
 void
@ -128,11 +119,4 @@ screen_handle_window_event(struct screen *screen, const SDL_WindowEvent *event);
 struct point
 screen_convert_to_frame_coords(struct screen *screen, int32_t x, int32_t y);
 // Convert coordinates from window to drawable.
 // Events are expressed in window coordinates, but content is expressed in
 // drawable coordinates. They are the same if HiDPI scaling is 1, but differ
 // otherwise.
 void
 screen_hidpi_scale_coords(struct screen *screen, int32_t *x, int32_t *y);
 #endif
--- a/app/src/server.c
+++ b/app/src/server.c
@ -217,46 +217,24 @@ enable_tunnel_forward_any_port(struct server *server,
 }
 static bool
-enable_tunnel_any_port(struct server *server, struct port_range port_range,
+enable_tunnel_any_port(struct server *server, struct port_range port_range) {
-                       bool force_adb_forward) {
+    if (enable_tunnel_reverse_any_port(server, port_range)) {
-    if (!force_adb_forward) {
+        return true;
        // Attempt to use "adb reverse"
        if (enable_tunnel_reverse_any_port(server, port_range)) {
            return true;
        }
        // if "adb reverse" does not work (e.g. over "adb connect"), it
        // fallbacks to "adb forward", so the app socket is the client
        LOGW("'adb reverse' failed, fallback to 'adb forward'");
    }
    // if "adb reverse" does not work (e.g. over "adb connect"), it fallbacks to
    // "adb forward", so the app socket is the client
    LOGW("'adb reverse' failed, fallback to 'adb forward'");
    return enable_tunnel_forward_any_port(server, port_range);
 }
 static const char *
 log_level_to_server_string(enum sc_log_level level) {
    switch (level) {
        case SC_LOG_LEVEL_DEBUG:
            return "debug";
        case SC_LOG_LEVEL_INFO:
            return "info";
        case SC_LOG_LEVEL_WARN:
            return "warn";
        case SC_LOG_LEVEL_ERROR:
            return "error";
        default:
            assert(!"unexpected log level");
            return "(unknown)";
    }
 }
 static process_t
 execute_server(struct server *server, const struct server_params *params) {
    char max_size_string[6];
    char bit_rate_string[11];
    char max_fps_string[6];
-    char lock_video_orientation_string[5];
+    char lock_video_orientation_string[3];
    char display_id_string[6];
    sprintf(max_size_string, "%"PRIu16, params->max_size);
    sprintf(bit_rate_string, "%"PRIu32, params->bit_rate);
@ -281,7 +259,6 @@ execute_server(struct server *server, const struct server_params *params) {
        "/", // unused
        "com.genymobile.scrcpy.Server",
        SCRCPY_VERSION,
        log_level_to_server_string(params->log_level),
        max_size_string,
        bit_rate_string,
        max_fps_string,
@ -389,8 +366,7 @@ server_start(struct server *server, const char *serial,
        goto error1;
    }
-    if (!enable_tunnel_any_port(server, params->port_range,
+    if (!enable_tunnel_any_port(server, params->port_range)) {
                                params->force_adb_forward)) {
        goto error1;
    }
--- a/app/src/server.h
+++ b/app/src/server.h
@ -9,7 +9,6 @@
 #include "config.h"
 #include "command.h"
 #include "common.h"
 #include "util/log.h"
 #include "util/net.h"
 struct server {
@ -44,7 +43,6 @@ struct server {
 }
 struct server_params {
    enum sc_log_level log_level;
    const char *crop;
    const char *codec_options;
    struct port_range port_range;
@ -56,7 +54,6 @@ struct server_params {
    uint16_t display_id;
    bool show_touches;
    bool stay_awake;
    bool force_adb_forward;
 };
 // init default values
--- a/app/src/util/log.h
+++ b/app/src/util/log.h
@ -3,13 +3,6 @@
 #include <SDL2/SDL_log.h>
 enum sc_log_level {
    SC_LOG_LEVEL_DEBUG,
    SC_LOG_LEVEL_INFO,
    SC_LOG_LEVEL_WARN,
    SC_LOG_LEVEL_ERROR,
 };
 #define LOGV(...) SDL_LogVerbose(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
 #define LOGD(...) SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
 #define LOGI(...) SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
--- a/app/tests/test_control_msg_serialize.c
+++ b/app/tests/test_control_msg_serialize.c
@ -200,19 +200,17 @@ static void test_serialize_get_clipboard(void) {
 static void test_serialize_set_clipboard(void) {
    struct control_msg msg = {
        .type = CONTROL_MSG_TYPE_SET_CLIPBOARD,
-        .set_clipboard = {
+        .inject_text = {
            .paste = true,
            .text = "hello, world!",
        },
    };
    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
-    assert(size == 17);
+    assert(size == 16);
    const unsigned char expected[] = {
        CONTROL_MSG_TYPE_SET_CLIPBOARD,
        1, // paste
        0x00, 0x0d, // text length
        'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', // text
    };
--- a/meson.build
+++ b/meson.build
@ -1,5 +1,5 @@
 project('scrcpy', 'c',
-        version: '1.14',
+        version: '1.13',
        meson_version: '>= 0.48',
        default_options: [
            'c_std=c11',
--- a/prebuilt-deps/Makefile
+++ b/prebuilt-deps/Makefile
@ -35,6 +35,6 @@ prepare-sdl2:
 		SDL2-2.0.12
 prepare-adb:
-	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r30.0.0-windows.zip \
+	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r29.0.5-windows.zip \
-		854305f9a702f5ea2c3de73edde402bd26afa0ee944c9b0c4380420f5a862e0d \
+		2df06160056ec9a84c7334af2a1e42740befbb1a2e34370e7af544a2cc78152c \
 		platform-tools
--- a/server/build.gradle
+++ b/server/build.gradle
@ -6,8 +6,8 @@ android {
        applicationId "com.genymobile.scrcpy"
        minSdkVersion 21
        targetSdkVersion 29
-        versionCode 16
+        versionCode 15
-        versionName "1.14"
+        versionName "1.13"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
--- a/server/build_without_gradle.sh
+++ b/server/build_without_gradle.sh
@ -12,7 +12,7 @@
 set -e
 SCRCPY_DEBUG=false
-SCRCPY_VERSION_NAME=1.14
+SCRCPY_VERSION_NAME=1.13
 PLATFORM=${ANDROID_PLATFORM:-29}
 BUILD_TOOLS=${ANDROID_BUILD_TOOLS:-29.0.2}
--- a/server/src/main/aidl/android/content/IOnPrimaryClipChangedListener.aidl
+++ b/server/src/main/aidl/android/content/IOnPrimaryClipChangedListener.aidl
@ -1,24 +0,0 @@
 /**
 * Copyright (c) 2008, The Android Open Source Project
 *
 * 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.
 */
 package android.content;
 /**
 * {@hide}
 */
 oneway interface IOnPrimaryClipChangedListener {
    void dispatchPrimaryClipChanged();
 }
--- a/server/src/main/java/com/genymobile/scrcpy/ControlMessage.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ControlMessage.java
@ -28,7 +28,6 @@ public final class ControlMessage {
    private Position position;
    private int hScroll;
    private int vScroll;
    private boolean paste;
    private ControlMessage() {
    }
@ -69,11 +68,10 @@ public final class ControlMessage {
        return msg;
    }
-    public static ControlMessage createSetClipboard(String text, boolean paste) {
+    public static ControlMessage createSetClipboard(String text) {
        ControlMessage msg = new ControlMessage();
        msg.type = TYPE_SET_CLIPBOARD;
        msg.text = text;
        msg.paste = paste;
        return msg;
    }
@ -136,8 +134,4 @@ public final class ControlMessage {
    public int getVScroll() {
        return vScroll;
    }
    public boolean getPaste() {
        return paste;
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/ControlMessageReader.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ControlMessageReader.java
@ -12,15 +12,14 @@ public class ControlMessageReader {
    static final int INJECT_TOUCH_EVENT_PAYLOAD_LENGTH = 27;
    static final int INJECT_SCROLL_EVENT_PAYLOAD_LENGTH = 20;
    static final int SET_SCREEN_POWER_MODE_PAYLOAD_LENGTH = 1;
    static final int SET_CLIPBOARD_FIXED_PAYLOAD_LENGTH = 1;
-    public static final int CLIPBOARD_TEXT_MAX_LENGTH = 4092; // 4096 - 1 (type) - 1 (parse flag) - 2 (length)
+    public static final int CLIPBOARD_TEXT_MAX_LENGTH = 4093;
    public static final int INJECT_TEXT_MAX_LENGTH = 300;
-
+    private static final int RAW_BUFFER_SIZE = 1024;
    private static final int RAW_BUFFER_SIZE = 4096;
    private final byte[] rawBuffer = new byte[RAW_BUFFER_SIZE];
    private final ByteBuffer buffer = ByteBuffer.wrap(rawBuffer);
    private final byte[] textBuffer = new byte[CLIPBOARD_TEXT_MAX_LENGTH];
    public ControlMessageReader() {
        // invariant: the buffer is always in "get" mode
@ -110,10 +109,8 @@ public class ControlMessageReader {
        if (buffer.remaining() < len) {
            return null;
        }
-        int position = buffer.position();
+        buffer.get(textBuffer, 0, len);
-        // Move the buffer position to consume the text
+        return new String(textBuffer, 0, len, StandardCharsets.UTF_8);
        buffer.position(position + len);
        return new String(rawBuffer, position, len, StandardCharsets.UTF_8);
    }
    private ControlMessage parseInjectText() {
@ -150,15 +147,11 @@ public class ControlMessageReader {
    }
    private ControlMessage parseSetClipboard() {
        if (buffer.remaining() < SET_CLIPBOARD_FIXED_PAYLOAD_LENGTH) {
            return null;
        }
        boolean parse = buffer.get() != 0;
        String text = parseString();
        if (text == null) {
            return null;
        }
-        return ControlMessage.createSetClipboard(text, parse);
+        return ControlMessage.createSetClipboard(text);
    }
    private ControlMessage parseSetScreenPowerMode() {
--- a/server/src/main/java/com/genymobile/scrcpy/Controller.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Controller.java
@ -1,8 +1,10 @@
 package com.genymobile.scrcpy;
-import android.os.Build;
+import com.genymobile.scrcpy.wrappers.InputManager;
 import android.os.SystemClock;
 import android.view.InputDevice;
 import android.view.InputEvent;
 import android.view.KeyCharacterMap;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
@ -48,7 +50,7 @@ public class Controller {
    public void control() throws IOException {
        // on start, power on the device
        if (!device.isScreenOn()) {
-            device.injectKeycode(KeyEvent.KEYCODE_POWER);
+            injectKeycode(KeyEvent.KEYCODE_POWER);
            // dirty hack
            // After POWER is injected, the device is powered on asynchronously.
@ -105,20 +107,14 @@ public class Controller {
                break;
            case ControlMessage.TYPE_GET_CLIPBOARD:
                String clipboardText = device.getClipboardText();
-                if (clipboardText != null) {
+                sender.pushClipboardText(clipboardText);
                    sender.pushClipboardText(clipboardText);
                }
                break;
            case ControlMessage.TYPE_SET_CLIPBOARD:
-                setClipboard(msg.getText(), msg.getPaste());
+                device.setClipboardText(msg.getText());
                break;
            case ControlMessage.TYPE_SET_SCREEN_POWER_MODE:
                if (device.supportsInputEvents()) {
-                    int mode = msg.getAction();
+                    device.setScreenPowerMode(msg.getAction());
                    boolean setPowerModeOk = device.setScreenPowerMode(mode);
                    if (setPowerModeOk) {
                        Ln.i("Device screen turned " + (mode == Device.POWER_MODE_OFF ? "off" : "on"));
                    }
                }
                break;
            case ControlMessage.TYPE_ROTATE_DEVICE:
@ -130,7 +126,7 @@ public class Controller {
    }
    private boolean injectKeycode(int action, int keycode, int metaState) {
-        return device.injectKeyEvent(action, keycode, 0, metaState);
+        return injectKeyEvent(action, keycode, 0, metaState);
    }
    private boolean injectChar(char c) {
@ -141,7 +137,7 @@ public class Controller {
            return false;
        }
        for (KeyEvent event : events) {
-            if (!device.injectEvent(event)) {
+            if (!injectEvent(event)) {
                return false;
            }
        }
@ -197,7 +193,7 @@ public class Controller {
        MotionEvent event = MotionEvent
                .obtain(lastTouchDown, now, action, pointerCount, pointerProperties, pointerCoords, 0, buttons, 1f, 1f, DEVICE_ID_VIRTUAL, 0,
                        InputDevice.SOURCE_TOUCHSCREEN, 0);
-        return device.injectEvent(event);
+        return injectEvent(event);
    }
    private boolean injectScroll(Position position, int hScroll, int vScroll) {
@ -219,26 +215,27 @@ public class Controller {
        MotionEvent event = MotionEvent
                .obtain(lastTouchDown, now, MotionEvent.ACTION_SCROLL, 1, pointerProperties, pointerCoords, 0, 0, 1f, 1f, DEVICE_ID_VIRTUAL, 0,
-                        InputDevice.SOURCE_TOUCHSCREEN, 0);
+                        InputDevice.SOURCE_MOUSE, 0);
-        return device.injectEvent(event);
+        return injectEvent(event);
    }
    private boolean injectKeyEvent(int action, int keyCode, int repeat, int metaState) {
        long now = SystemClock.uptimeMillis();
        KeyEvent event = new KeyEvent(now, now, action, keyCode, repeat, metaState, KeyCharacterMap.VIRTUAL_KEYBOARD, 0, 0,
                InputDevice.SOURCE_KEYBOARD);
        return injectEvent(event);
    }
    private boolean injectKeycode(int keyCode) {
        return injectKeyEvent(KeyEvent.ACTION_DOWN, keyCode, 0, 0) && injectKeyEvent(KeyEvent.ACTION_UP, keyCode, 0, 0);
    }
    private boolean injectEvent(InputEvent event) {
        return device.injectInputEvent(event, InputManager.INJECT_INPUT_EVENT_MODE_ASYNC);
    }
    private boolean pressBackOrTurnScreenOn() {
        int keycode = device.isScreenOn() ? KeyEvent.KEYCODE_BACK : KeyEvent.KEYCODE_POWER;
-        return device.injectKeycode(keycode);
+        return injectKeycode(keycode);
    }
    private boolean setClipboard(String text, boolean paste) {
        boolean ok = device.setClipboardText(text);
        if (ok) {
            Ln.i("Device clipboard set");
        }
        // On Android >= 7, also press the PASTE key if requested
        if (paste && Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && device.supportsInputEvents()) {
            device.injectKeycode(KeyEvent.KEYCODE_PASTE);
        }
        return ok;
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/Device.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Device.java
@ -6,18 +6,12 @@ import com.genymobile.scrcpy.wrappers.ServiceManager;
 import com.genymobile.scrcpy.wrappers.SurfaceControl;
 import com.genymobile.scrcpy.wrappers.WindowManager;
 import android.content.IOnPrimaryClipChangedListener;
 import android.graphics.Rect;
 import android.os.Build;
 import android.os.IBinder;
-import android.os.SystemClock;
+import android.os.RemoteException;
 import android.view.IRotationWatcher;
 import android.view.InputDevice;
 import android.view.InputEvent;
 import android.view.KeyCharacterMap;
 import android.view.KeyEvent;
 import java.util.concurrent.atomic.AtomicBoolean;
 public final class Device {
@ -28,16 +22,10 @@ public final class Device {
        void onRotationChanged(int rotation);
    }
    public interface ClipboardListener {
        void onClipboardTextChanged(String text);
    }
    private final ServiceManager serviceManager = new ServiceManager();
    private ScreenInfo screenInfo;
    private RotationListener rotationListener;
    private ClipboardListener clipboardListener;
    private final AtomicBoolean isSettingClipboard = new AtomicBoolean();
    /**
     * Logical display identifier
@ -64,9 +52,9 @@ public final class Device {
        screenInfo = ScreenInfo.computeScreenInfo(displayInfo, options.getCrop(), options.getMaxSize(), options.getLockedVideoOrientation());
        layerStack = displayInfo.getLayerStack();
-        serviceManager.getWindowManager().registerRotationWatcher(new IRotationWatcher.Stub() {
+        registerRotationWatcher(new IRotationWatcher.Stub() {
            @Override
-            public void onRotationChanged(int rotation) {
+            public void onRotationChanged(int rotation) throws RemoteException {
                synchronized (Device.this) {
                    screenInfo = screenInfo.withDeviceRotation(rotation);
@ -78,27 +66,6 @@ public final class Device {
            }
        }, displayId);
        if (options.getControl()) {
            // If control is enabled, synchronize Android clipboard to the computer automatically
            serviceManager.getClipboardManager().addPrimaryClipChangedListener(new IOnPrimaryClipChangedListener.Stub() {
                @Override
                public void dispatchPrimaryClipChanged() {
                    if (isSettingClipboard.get()) {
                        // This is a notification for the change we are currently applying, ignore it
                        return;
                    }
                    synchronized (Device.this) {
                        if (clipboardListener != null) {
                            String text = getClipboardText();
                            if (text != null) {
                                clipboardListener.onClipboardTextChanged(text);
                            }
                        }
                    }
                }
            });
        }
        if ((displayInfoFlags & DisplayInfo.FLAG_SUPPORTS_PROTECTED_BUFFERS) == 0) {
            Ln.w("Display doesn't have FLAG_SUPPORTS_PROTECTED_BUFFERS flag, mirroring can be restricted");
        }
@ -151,7 +118,7 @@ public final class Device {
        return supportsInputEvents;
    }
-    public boolean injectEvent(InputEvent inputEvent, int mode) {
+    public boolean injectInputEvent(InputEvent inputEvent, int mode) {
        if (!supportsInputEvents()) {
            throw new AssertionError("Could not inject input event if !supportsInputEvents()");
        }
@ -163,31 +130,16 @@ public final class Device {
        return serviceManager.getInputManager().injectInputEvent(inputEvent, mode);
    }
    public boolean injectEvent(InputEvent event) {
        return injectEvent(event, InputManager.INJECT_INPUT_EVENT_MODE_ASYNC);
    }
    public boolean injectKeyEvent(int action, int keyCode, int repeat, int metaState) {
        long now = SystemClock.uptimeMillis();
        KeyEvent event = new KeyEvent(now, now, action, keyCode, repeat, metaState, KeyCharacterMap.VIRTUAL_KEYBOARD, 0, 0,
                InputDevice.SOURCE_KEYBOARD);
        return injectEvent(event);
    }
    public boolean injectKeycode(int keyCode) {
        return injectKeyEvent(KeyEvent.ACTION_DOWN, keyCode, 0, 0) && injectKeyEvent(KeyEvent.ACTION_UP, keyCode, 0, 0);
    }
    public boolean isScreenOn() {
        return serviceManager.getPowerManager().isScreenOn();
    }
-    public synchronized void setRotationListener(RotationListener rotationListener) {
+    public void registerRotationWatcher(IRotationWatcher rotationWatcher, int displayId) {
-        this.rotationListener = rotationListener;
+        serviceManager.getWindowManager().registerRotationWatcher(rotationWatcher, displayId);
    }
-    public synchronized void setClipboardListener(ClipboardListener clipboardListener) {
+    public synchronized void setRotationListener(RotationListener rotationListener) {
-        this.clipboardListener = clipboardListener;
+        this.rotationListener = rotationListener;
    }
    public void expandNotificationPanel() {
@ -206,31 +158,26 @@ public final class Device {
        return s.toString();
    }
-    public boolean setClipboardText(String text) {
+    public void setClipboardText(String text) {
        String currentClipboard = getClipboardText();
        if (currentClipboard == null || currentClipboard.equals(text)) {
            // The clipboard already contains the requested text.
            // Since pasting text from the computer involves setting the device clipboard, it could be set twice on a copy-paste. This would cause
            // the clipboard listeners to be notified twice, and that would flood the Android keyboard clipboard history. To workaround this
            // problem, do not explicitly set the clipboard text if it already contains the expected content.
            return false;
        }
        isSettingClipboard.set(true);
        boolean ok = serviceManager.getClipboardManager().setText(text);
-        isSettingClipboard.set(false);
+        if (ok) {
-        return ok;
+            Ln.i("Device clipboard set");
        }
    }
    /**
     * @param mode one of the {@code SCREEN_POWER_MODE_*} constants
     */
-    public boolean setScreenPowerMode(int mode) {
+    public void setScreenPowerMode(int mode) {
        IBinder d = SurfaceControl.getBuiltInDisplay();
        if (d == null) {
            Ln.e("Could not get built-in display");
-            return false;
+            return;
        }
        boolean ok = SurfaceControl.setDisplayPowerMode(d, mode);
        if (ok) {
            Ln.i("Device screen turned " + (mode == Device.POWER_MODE_OFF ? "off" : "on"));
        }
        return SurfaceControl.setDisplayPowerMode(d, mode);
    }
    /**
--- a/server/src/main/java/com/genymobile/scrcpy/Ln.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Ln.java
@ -15,25 +15,14 @@ public final class Ln {
        DEBUG, INFO, WARN, ERROR
    }
-    private static Level threshold = Level.INFO;
+    private static final Level THRESHOLD = BuildConfig.DEBUG ? Level.DEBUG : Level.INFO;
    private Ln() {
        // not instantiable
    }
    /**
     * Initialize the log level.
     * <p>
     * Must be called before starting any new thread.
     *
     * @param level the log level
     */
    public static void initLogLevel(Level level) {
        threshold = level;
    }
    public static boolean isEnabled(Level level) {
-        return level.ordinal() >= threshold.ordinal();
+        return level.ordinal() >= THRESHOLD.ordinal();
    }
    public static void d(String message) {
--- a/server/src/main/java/com/genymobile/scrcpy/Options.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Options.java
@ -3,7 +3,6 @@ package com.genymobile.scrcpy;
 import android.graphics.Rect;
 public class Options {
    private Ln.Level logLevel;
    private int maxSize;
    private int bitRate;
    private int maxFps;
@ -17,14 +16,6 @@ public class Options {
    private boolean stayAwake;
    private String codecOptions;
    public Ln.Level getLogLevel() {
        return logLevel;
    }
    public void setLogLevel(Ln.Level logLevel) {
        this.logLevel = logLevel;
    }
    public int getMaxSize() {
        return maxSize;
    }
--- a/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
@ -64,7 +64,7 @@ public class ScreenEncoder implements Device.RotationListener {
    }
    private void internalStreamScreen(Device device, FileDescriptor fd) throws IOException {
-        MediaFormat format = createFormat(bitRate, maxFps, codecOptions);
+        MediaFormat format = createFormat(bitRate, maxFps, DEFAULT_I_FRAME_INTERVAL, codecOptions);
        device.setRotationListener(this);
        boolean alive;
        try {
@ -171,14 +171,14 @@ public class ScreenEncoder implements Device.RotationListener {
        Ln.d("Codec option set: " + key + " (" + value.getClass().getSimpleName() + ") = " + value);
    }
-    private static MediaFormat createFormat(int bitRate, int maxFps, List<CodecOption> codecOptions) {
+    private static MediaFormat createFormat(int bitRate, int maxFps, int iFrameInterval, List<CodecOption> codecOptions) {
        MediaFormat format = new MediaFormat();
        format.setString(MediaFormat.KEY_MIME, MediaFormat.MIMETYPE_VIDEO_AVC);
        format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
        // must be present to configure the encoder, but does not impact the actual frame rate, which is variable
        format.setInteger(MediaFormat.KEY_FRAME_RATE, 60);
        format.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
-        format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, DEFAULT_I_FRAME_INTERVAL);
+        format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, iFrameInterval);
        // display the very first frame, and recover from bad quality when no new frames
        format.setLong(MediaFormat.KEY_REPEAT_PREVIOUS_FRAME_AFTER, REPEAT_FRAME_DELAY_US); // µs
        if (maxFps > 0) {
--- a/server/src/main/java/com/genymobile/scrcpy/Server.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Server.java
@ -9,7 +9,6 @@ import android.os.Build;
 import java.io.IOException;
 import java.util.List;
 import java.util.Locale;
 public final class Server {
@ -57,18 +56,11 @@ public final class Server {
            ScreenEncoder screenEncoder = new ScreenEncoder(options.getSendFrameMeta(), options.getBitRate(), options.getMaxFps(), codecOptions);
            if (options.getControl()) {
-                final Controller controller = new Controller(device, connection);
+                Controller controller = new Controller(device, connection);
                // asynchronous
                startController(controller);
                startDeviceMessageSender(controller.getSender());
                device.setClipboardListener(new Device.ClipboardListener() {
                    @Override
                    public void onClipboardTextChanged(String text) {
                        controller.getSender().pushClipboardText(text);
                    }
                });
            }
            try {
@ -120,51 +112,48 @@ public final class Server {
                    "The server version (" + BuildConfig.VERSION_NAME + ") does not match the client " + "(" + clientVersion + ")");
        }
-        final int expectedParameters = 14;
+        final int expectedParameters = 13;
        if (args.length != expectedParameters) {
            throw new IllegalArgumentException("Expecting " + expectedParameters + " parameters");
        }
        Options options = new Options();
-        Ln.Level level = Ln.Level.valueOf(args[1].toUpperCase(Locale.ENGLISH));
+        int maxSize = Integer.parseInt(args[1]) & ~7; // multiple of 8
        options.setLogLevel(level);
        int maxSize = Integer.parseInt(args[2]) & ~7; // multiple of 8
        options.setMaxSize(maxSize);
-        int bitRate = Integer.parseInt(args[3]);
+        int bitRate = Integer.parseInt(args[2]);
        options.setBitRate(bitRate);
-        int maxFps = Integer.parseInt(args[4]);
+        int maxFps = Integer.parseInt(args[3]);
        options.setMaxFps(maxFps);
-        int lockedVideoOrientation = Integer.parseInt(args[5]);
+        int lockedVideoOrientation = Integer.parseInt(args[4]);
        options.setLockedVideoOrientation(lockedVideoOrientation);
        // use "adb forward" instead of "adb tunnel"? (so the server must listen)
-        boolean tunnelForward = Boolean.parseBoolean(args[6]);
+        boolean tunnelForward = Boolean.parseBoolean(args[5]);
        options.setTunnelForward(tunnelForward);
-        Rect crop = parseCrop(args[7]);
+        Rect crop = parseCrop(args[6]);
        options.setCrop(crop);
-        boolean sendFrameMeta = Boolean.parseBoolean(args[8]);
+        boolean sendFrameMeta = Boolean.parseBoolean(args[7]);
        options.setSendFrameMeta(sendFrameMeta);
-        boolean control = Boolean.parseBoolean(args[9]);
+        boolean control = Boolean.parseBoolean(args[8]);
        options.setControl(control);
-        int displayId = Integer.parseInt(args[10]);
+        int displayId = Integer.parseInt(args[9]);
        options.setDisplayId(displayId);
-        boolean showTouches = Boolean.parseBoolean(args[11]);
+        boolean showTouches = Boolean.parseBoolean(args[10]);
        options.setShowTouches(showTouches);
-        boolean stayAwake = Boolean.parseBoolean(args[12]);
+        boolean stayAwake = Boolean.parseBoolean(args[11]);
        options.setStayAwake(stayAwake);
-        String codecOptions = args[13];
+        String codecOptions = args[12];
        options.setCodecOptions(codecOptions);
        return options;
@ -219,9 +208,6 @@ public final class Server {
        });
        Options options = createOptions(args);
        Ln.initLogLevel(options.getLogLevel());
        scrcpy(options);
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/ClipboardManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/ClipboardManager.java
@ -3,7 +3,6 @@ package com.genymobile.scrcpy.wrappers;
 import com.genymobile.scrcpy.Ln;
 import android.content.ClipData;
 import android.content.IOnPrimaryClipChangedListener;
 import android.os.Build;
 import android.os.IInterface;
@ -14,7 +13,6 @@ public class ClipboardManager {
    private final IInterface manager;
    private Method getPrimaryClipMethod;
    private Method setPrimaryClipMethod;
    private Method addPrimaryClipChangedListener;
    public ClipboardManager(IInterface manager) {
        this.manager = manager;
@ -83,37 +81,4 @@ public class ClipboardManager {
            return false;
        }
    }
    private static void addPrimaryClipChangedListener(Method method, IInterface manager, IOnPrimaryClipChangedListener listener)
            throws InvocationTargetException, IllegalAccessException {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
            method.invoke(manager, listener, ServiceManager.PACKAGE_NAME);
        } else {
            method.invoke(manager, listener, ServiceManager.PACKAGE_NAME, ServiceManager.USER_ID);
        }
    }
    private Method getAddPrimaryClipChangedListener() throws NoSuchMethodException {
        if (addPrimaryClipChangedListener == null) {
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
                addPrimaryClipChangedListener = manager.getClass()
                        .getMethod("addPrimaryClipChangedListener", IOnPrimaryClipChangedListener.class, String.class);
            } else {
                addPrimaryClipChangedListener = manager.getClass()
                        .getMethod("addPrimaryClipChangedListener", IOnPrimaryClipChangedListener.class, String.class, int.class);
            }
        }
        return addPrimaryClipChangedListener;
    }
    public boolean addPrimaryClipChangedListener(IOnPrimaryClipChangedListener listener) {
        try {
            Method method = getAddPrimaryClipChangedListener();
            addPrimaryClipChangedListener(method, manager, listener);
            return true;
        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
            Ln.e("Could not invoke method", e);
            return false;
        }
    }
 }
--- a/server/src/test/java/com/genymobile/scrcpy/CodecOptionsTest.java
+++ b/server/src/test/java/com/genymobile/scrcpy/CodecOptionsTest.java
@ -1,10 +1,10 @@
 package com.genymobile.scrcpy;
 import java.util.List;
 import org.junit.Assert;
 import org.junit.Test;
 import java.util.List;
 public class CodecOptionsTest {
    @Test
--- a/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java
+++ b/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java
@ -216,7 +216,6 @@ public class ControlMessageReaderTest {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(bos);
        dos.writeByte(ControlMessage.TYPE_SET_CLIPBOARD);
        dos.writeByte(1); // paste
        byte[] text = "testé".getBytes(StandardCharsets.UTF_8);
        dos.writeShort(text.length);
        dos.write(text);
@ -228,33 +227,6 @@ public class ControlMessageReaderTest {
        Assert.assertEquals(ControlMessage.TYPE_SET_CLIPBOARD, event.getType());
        Assert.assertEquals("testé", event.getText());
        Assert.assertTrue(event.getPaste());
    }
    @Test
    public void testParseBigSetClipboardEvent() throws IOException {
        ControlMessageReader reader = new ControlMessageReader();
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(bos);
        dos.writeByte(ControlMessage.TYPE_SET_CLIPBOARD);
        byte[] rawText = new byte[ControlMessageReader.CLIPBOARD_TEXT_MAX_LENGTH];
        dos.writeByte(1); // paste
        Arrays.fill(rawText, (byte) 'a');
        String text = new String(rawText, 0, rawText.length);
        dos.writeShort(rawText.length);
        dos.write(rawText);
        byte[] packet = bos.toByteArray();
        reader.readFrom(new ByteArrayInputStream(packet));
        ControlMessage event = reader.next();
        Assert.assertEquals(ControlMessage.TYPE_SET_CLIPBOARD, event.getType());
        Assert.assertEquals(text, event.getText());
        Assert.assertTrue(event.getPaste());
    }
    @Test