Avoid additional copy on Java text parsing

Directly pass the buffer range to the String constructor.
Update copy-paste section in README
2020-07-09 12:28:42 +02:00 · 2020-07-09 12:28:42 +02:00 · 2020-07-09 12:28:42 +02:00 · 2020-07-09 12:28:42 +02:00 · 2020-07-09 12:28:42 +02:00 · 2020-07-09 12:28:42 +02:00
38 changed files with 1680 additions and 449 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@ -21,5 +21,9 @@ 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,5 +1,8 @@
 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.13`][direct-scrcpy-server]  
-   _(SHA-256: 5fee64ca1ccdc2f38550f31f5353c66de3de30c2e929a964e30fa2d005d5f885)_
+ - [`scrcpy-server-v1.14`][direct-scrcpy-server]  
+   _(SHA-256: 1d1b18a2b80e956771fd63b99b414d2d028713a8f12ddfa5a369709ad4295620)_

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

 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:
--- a/README.ko.md
+++ b/README.ko.md
@ -1,3 +1,5 @@
+_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.13)
+# scrcpy (v1.14)

 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.13.zip`][direct-win64]  
-   _(SHA-256: 806aafc00d4db01513193addaa24f47858893ba5efe75770bfef6ae1ea987d27)_
+ - [`scrcpy-win64-v1.14.zip`][direct-win64]  
+   _(SHA-256: 2be9139e46e29cf2f5f695848bb2b75a543b8f38be1133257dc5068252abc25f)_

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

 It is also available in [Chocolatey]:

@ -289,6 +289,22 @@ 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:

 ```
@ -338,7 +354,7 @@ scrcpy --fullscreen
 scrcpy -f  # short version
 ```

-Fullscreen can then be toggled dynamically with `Ctrl`+`f`.
+Fullscreen can then be toggled dynamically with `RCtrl`+`f`.

 #### Rotation

@ -354,18 +370,18 @@ Possibles values are:
 - `2`: 180 degrees
 - `3`: 90 degrees clockwise

-The rotation can also be changed dynamically with `Ctrl`+`←` _(left)_ and
-`Ctrl`+`→` _(right)_.
+The rotation can also be changed dynamically with `RCtrl`+`←` _(left)_ and
+`RCtrl`+`→` _(right)_.

 Note that _scrcpy_ manages 3 different rotations:
- - `Ctrl`+`r` requests the device to switch between portrait and landscape (the
+ - `RCtrl`+`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 `Ctrl`+`←`/`Ctrl`+`→`) rotates only the window content. This
-   affects only the display, not the recording.
+ - `--rotation` (or `RCtrl`+`←`/`RCtrl`+`→`) rotates only the window content.
+   This affects only the display, not the recording.


 ### Other mirroring options
@ -395,9 +411,13 @@ 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:
+To prevent the device to sleep after some delay when the device is plugged in:

 ```bash
 scrcpy --stay-awake
@ -417,9 +437,9 @@ scrcpy --turn-screen-off
 scrcpy -S
 ```

-Or by pressing `Ctrl`+`o` at any time.
+Or by pressing `RCtrl`+`o` at any time.

-To turn it back on, press `POWER` (or `Ctrl`+`p`).
+To turn it back on, press `RCtrl`+`Shift`+`o` (or `POWER`, `RCtrl`+`p`).

 It can be useful to also prevent the device to sleep:

@ -463,20 +483,22 @@ Note that it only shows _physical_ touches (with the finger on the device).

 #### Rotate device screen

-Press `Ctrl`+`r` to switch between portrait and landscape modes.
+Press `RCtrl`+`r` to switch between portrait and landscape modes.

 Note that it rotates only if the application in foreground supports the
 requested orientation.

 #### Copy-paste

-It is possible to synchronize clipboards between the computer and the device, in
-both directions:
+Any time the Android clipboard changes, it is automatically synchronized to the
+computer clipboard.
+
+`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

@ -536,29 +558,34 @@ Also see [issue #14].

 ## Shortcuts

- | Action                                 |   Shortcut                    |   Shortcut (macOS)
- | -------------------------------------- |:----------------------------- |:-----------------------------
- | Switch fullscreen mode                 | `Ctrl`+`f`                    | `Cmd`+`f`
- | Rotate display left                    | `Ctrl`+`←` _(left)_           | `Cmd`+`←` _(left)_
- | Rotate display right                   | `Ctrl`+`→` _(right)_          | `Cmd`+`→` _(right)_
- | Resize window to 1:1 (pixel-perfect)   | `Ctrl`+`g`                    | `Cmd`+`g`
- | 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_
- | Click on `BACK`                        | `Ctrl`+`b` \| _Right-click²_  | `Cmd`+`b`  \| _Right-click²_
- | Click on `APP_SWITCH`                  | `Ctrl`+`s`                    | `Cmd`+`s`
- | Click on `MENU`                        | `Ctrl`+`m`                    | `Ctrl`+`m`
- | Click on `VOLUME_UP`                   | `Ctrl`+`↑` _(up)_             | `Cmd`+`↑` _(up)_
- | Click on `VOLUME_DOWN`                 | `Ctrl`+`↓` _(down)_           | `Cmd`+`↓` _(down)_
- | Click on `POWER`                       | `Ctrl`+`p`                    | `Cmd`+`p`
- | Power on                               | _Right-click²_                | _Right-click²_
- | Turn device screen off (keep mirroring)| `Ctrl`+`o`                    | `Cmd`+`o`
- | Rotate device screen                   | `Ctrl`+`r`                    | `Cmd`+`r`
- | Expand notification panel              | `Ctrl`+`n`                    | `Cmd`+`n`
- | Collapse notification panel            | `Ctrl`+`Shift`+`n`            | `Cmd`+`Shift`+`n`
- | Copy device clipboard to computer      | `Ctrl`+`c`                    | `Cmd`+`c`
- | Paste computer clipboard to device     | `Ctrl`+`v`                    | `Cmd`+`v`
- | Copy computer clipboard to device      | `Ctrl`+`Shift`+`v`            | `Cmd`+`Shift`+`v`
- | Enable/disable FPS counter (on stdout) | `Ctrl`+`i`                    | `Cmd`+`i`
+`RCtrl` is the right `Ctrl` key (the left `Ctrl` key is forwarded to the
+device).
+
+On macOS, `Cmd` also works (for shortcuts which are not already captured by the
+system).
+
+ | Action                                      |   Shortcut
+ | ------------------------------------------- |:-----------------------------
+ | Switch fullscreen mode                      | `RCtrl`+`f`
+ | Rotate display left                         | `RCtrl`+`←`
+ | Rotate display right                        | `RCtrl`+`→`
+ | Resize window to 1:1 (pixel-perfect)        | `RCtrl`+`g`
+ | Resize window to remove black borders       | `RCtrl`+`w` \| _Double-click¹_
+ | Click on `HOME`                             | `RCtrl`+`h` \| _Middle-click_
+ | Click on `BACK`                             | `RCtrl`+`b` \| _Right-click²_
+ | Click on `APP_SWITCH`                       | `RCtrl`+`s`
+ | Click on `MENU`                             | `RCtrl`+`m`
+ | Click on `VOLUME_UP`                        | `RCtrl`+`↑` _(up)_
+ | Click on `VOLUME_DOWN`                      | `RCtrl`+`↓` _(down)_
+ | Click on `POWER`                            | `RCtrl`+`p`
+ | Power on                                    | _Right-click²_
+ | Turn device screen off (keep mirroring)     | `RCtrl`+`o`
+ | Turn device screen on                       | `RCtrl`+`Shift`+`o`
+ | 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
@ -0,0 +1,531 @@
+_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
@ -25,6 +25,16 @@ 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[,...]
+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
+.UR https://d.android.com/reference/android/media/MediaFormat
+.UE .
+
 .TP
 .BI "\-\-crop " width\fR:\fIheight\fR:\fIx\fR:\fIy
 Crop the device screen on the server.
@ -42,6 +52,10 @@ 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.
@ -115,6 +129,7 @@ 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

@ -136,7 +151,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).

@ -144,9 +159,15 @@ 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.
+Keep the device on while scrcpy is running, when the device is plugged in.

 .TP
 .B \-\-window\-borderless
@ -182,52 +203,54 @@ Default is 0 (automatic).\n

 .SH SHORTCUTS

+RCtrl is the right Ctrl key (the left Ctrl key is forwarded to the device).
+
 .TP
-.B Ctrl+f
+.B RCtrl+f
 Switch fullscreen mode

 .TP
-.B Ctrl+Left
+.B RCtrl+Left
 Rotate display left

 .TP
-.B Ctrl+Right
+.B RCtrl+Right
 Rotate display right

 .TP
-.B Ctrl+g
+.B RCtrl+g
 Resize window to 1:1 (pixel\-perfect)

 .TP
-.B Ctrl+x, Double\-click on black borders
+.B RCtrl+w, Double\-click on black borders
 Resize window to remove black borders

 .TP
-.B Ctrl+h, Home, Middle\-click
+.B RCtrl+h, Home, Middle\-click
 Click on HOME

 .TP
-.B Ctrl+b, Ctrl+Backspace, Right\-click (when screen is on)
+.B RCtrl+b, RCtrl+Backspace, Right\-click (when screen is on)
 Click on BACK

 .TP
-.B Ctrl+s
+.B RCtrl+s
 Click on APP_SWITCH

 .TP
-.B Ctrl+m
+.B RCtrl+m
 Click on MENU

 .TP
-.B Ctrl+Up
+.B RCtrl+Up
 Click on VOLUME_UP

 .TP
-.B Ctrl+Down
+.B RCtrl+Down
 Click on VOLUME_DOWN

 .TP
-.B Ctrl+p
+.B RCtrl+p
 Click on POWER (turn screen on/off)

 .TP
@ -235,35 +258,31 @@ Click on POWER (turn screen on/off)
 Turn screen on

 .TP
-.B Ctrl+o
+.B RCtrl+o
 Turn device screen off (keep mirroring)

 .TP
-.B Ctrl+r
+.B RCtrl+Shift+o
+Turn device screen on
+
+.TP
+.B RCtrl+r
 Rotate device screen

 .TP
-.B Ctrl+n
+.B RCtrl+n
 Expand notification panel

 .TP
-.B Ctrl+Shift+n
+.B RCtrl+Shift+n
 Collapse notification panel

 .TP
-.B Ctrl+c
-Copy device clipboard to computer
+.B RCtrl+v
+Inject computer clipboard text

 .TP
-.B Ctrl+v
-Paste computer clipboard to device
-
-.TP
-.B Ctrl+Shift+v
-Copy computer clipboard to device
-
-.TP
-.B Ctrl+i
+.B RCtrl+i
 Enable/disable FPS counter (print frames/second in logs)

 .TP
--- a/app/src/cli.c
+++ b/app/src/cli.c
@ -12,11 +12,6 @@

 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"
@ -30,6 +25,15 @@ scrcpy_print_usage(const char *arg0) {
        "        Unit suffixes are supported: 'K' (x1000) and 'M' (x1000000).\n"
        "        Default is %d.\n"
        "\n"
+        "    --codec-options key[:type]=value[,...]\n"
+        "        Set a list of comma-separated key:type=value options for the\n"
+        "        device encoder.\n"
+        "        The possible values for 'type' are 'int' (default), 'long',\n"
+        "        'float' and 'string'.\n"
+        "        The list of possible codec options is available in the\n"
+        "        Android documentation:\n"
+        "        <https://d.android.com/reference/android/media/MediaFormat>\n"
+        "\n"
        "    --crop width:height:x:y\n"
        "        Crop the device screen on the server.\n"
        "        The values are expressed in the device natural orientation\n"
@ -45,6 +49,10 @@ 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"
@ -136,9 +144,18 @@ 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.\n"
+        "        Keep the device on while scrcpy is running, when the device\n"
+        "        is plugged in.\n"
        "\n"
        "    --window-borderless\n"
        "        Disable window decorations (display borderless window).\n"
@ -164,71 +181,71 @@ scrcpy_print_usage(const char *arg0) {
        "\n"
        "Shortcuts:\n"
        "\n"
-        "    " CTRL_OR_CMD "+f\n"
+        "    RCtrl is the right Ctrl key (the left Ctrl key is forwarded to\n"
+        "    the device.\n"
+        "\n"
+        "    RCtrl+f\n"
        "        Switch fullscreen mode\n"
        "\n"
-        "    " CTRL_OR_CMD "+Left\n"
+        "    RCtrl+Left\n"
        "        Rotate display left\n"
        "\n"
-        "    " CTRL_OR_CMD "+Right\n"
+        "    RCtrl+Right\n"
        "        Rotate display right\n"
        "\n"
-        "    " CTRL_OR_CMD "+g\n"
+        "    RCtrl+g\n"
        "        Resize window to 1:1 (pixel-perfect)\n"
        "\n"
-        "    " CTRL_OR_CMD "+x\n"
+        "    RCtrl+w\n"
        "    Double-click on black borders\n"
        "        Resize window to remove black borders\n"
        "\n"
-        "    Ctrl+h\n"
+        "    RCtrl+h\n"
        "    Middle-click\n"
        "        Click on HOME\n"
        "\n"
-        "    " CTRL_OR_CMD "+b\n"
-        "    " CTRL_OR_CMD "+Backspace\n"
+        "    RCtrl+b\n"
+        "    RCtrl+Backspace\n"
        "    Right-click (when screen is on)\n"
        "        Click on BACK\n"
        "\n"
-        "    " CTRL_OR_CMD "+s\n"
+        "    RCtrl+s\n"
        "        Click on APP_SWITCH\n"
        "\n"
-        "    Ctrl+m\n"
+        "    RCtrl+m\n"
        "        Click on MENU\n"
        "\n"
-        "    " CTRL_OR_CMD "+Up\n"
+        "    RCtrl+Up\n"
        "        Click on VOLUME_UP\n"
        "\n"
-        "    " CTRL_OR_CMD "+Down\n"
+        "    RCtrl+Down\n"
        "        Click on VOLUME_DOWN\n"
        "\n"
-        "    " CTRL_OR_CMD "+p\n"
+        "    RCtrl+p\n"
        "        Click on POWER (turn screen on/off)\n"
        "\n"
        "    Right-click (when screen is off)\n"
        "        Power on\n"
        "\n"
-        "    " CTRL_OR_CMD "+o\n"
+        "    RCtrl+o\n"
        "        Turn device screen off (keep mirroring)\n"
        "\n"
-        "    " CTRL_OR_CMD "+r\n"
+        "    RCtrl+Shift+o\n"
+        "        Turn device screen on\n"
+        "\n"
+        "    RCtrl+r\n"
        "        Rotate device screen\n"
        "\n"
-        "    " CTRL_OR_CMD "+n\n"
+        "    RCtrl+n\n"
        "        Expand notification panel\n"
        "\n"
-        "    " CTRL_OR_CMD "+Shift+n\n"
+        "    RCtrl+Shift+n\n"
        "        Collapse notification panel\n"
        "\n"
-        "    " CTRL_OR_CMD "+c\n"
-        "        Copy device clipboard to computer\n"
+        "    RCtrl+v\n"
+        "        Inject computer clipboard text\n"
        "\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"
+        "    RCtrl+i\n"
        "        Enable/disable FPS counter (print frames/second in logs)\n"
        "\n"
        "    Drag & drop APK file\n"
@ -424,6 +441,32 @@ 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")) {
@ -472,14 +515,19 @@ guess_record_format(const char *filename) {
 #define OPT_ROTATION               1015
 #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[]) {
    static const struct option long_options[] = {
        {"always-on-top",          no_argument,       NULL, OPT_ALWAYS_ON_TOP},
        {"bit-rate",               required_argument, NULL, 'b'},
+        {"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,
@ -502,6 +550,7 @@ 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},
@ -518,8 +567,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:StTvw", long_options,
-                            NULL)) != -1) {
+    while ((c = getopt_long(argc, argv, "b:c:fF:hm:nNp:r:s:StTvV:w",
+                            long_options, NULL)) != -1) {
        switch (c) {
            case 'b':
                if (!parse_bit_rate(optarg, &opts->bit_rate)) {
@ -598,6 +647,11 @@ 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;
@ -647,6 +701,12 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
            case OPT_NO_MIPMAPS:
                opts->mipmaps = false;
                break;
+            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,10 +67,11 @@ 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: {
-            size_t len = write_string(msg->inject_text.text,
+            buf[1] = !!msg->set_clipboard.paste;
+            size_t len = write_string(msg->set_clipboard.text,
                                      CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH,
-                                      &buf[1]);
-            return 1 + len;
+                                      &buf[2]);
+            return 2 + 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 4093
+#define CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH 4092
 #define CONTROL_MSG_SERIALIZED_MAX_SIZE \
-    (3 + CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH)
+    (4 + CONTROL_MSG_CLIPBOARD_TEXT_MAX_LENGTH)

 #define POINTER_ID_MOUSE UINT64_C(-1);

@ -62,6 +62,7 @@ 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,6 +92,9 @@ 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))) {
@ -111,7 +114,7 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod,
        }
    }

-    if (prefer_text) {
+    if (prefer_text && !(mod & KMOD_LCTRL)) {
        // do not forward alpha and space key events
        return false;
    }
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
@ -7,33 +7,6 @@
 #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;

@ -129,17 +102,7 @@ collapse_notification_panel(struct controller *controller) {
 }

 static void
-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) {
+set_device_clipboard(struct controller *controller, bool paste) {
    char *text = SDL_GetClipboardText();
    if (!text) {
        LOGW("Could not get clipboard text: %s", SDL_GetError());
@ -154,6 +117,7 @@ set_device_clipboard(struct controller *controller) {
    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);
@ -278,6 +242,25 @@ 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,
@ -285,134 +268,127 @@ input_manager_process_key(struct input_manager *im,
    // control: indicates the state of the command-line option --no-control
    // ctrl: the Ctrl key

-    bool ctrl = event->keysym.mod & (KMOD_LCTRL | KMOD_RCTRL);
+    bool lctrl = event->keysym.mod & KMOD_LCTRL;
+    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);

-    // use Cmd on macOS, Ctrl on other platforms
+    bool shortcut_key = rctrl;
 #ifdef __APPLE__
-    bool cmd = !ctrl && meta;
+    shortcut_key |= meta;
 #else
    if (meta) {
-        // no shortcuts involve Meta on platforms other than macOS, and it must
-        // not be forwarded to the device
+        // No shortcut involve Meta, and it is not forwarded to the device
        return;
    }
-    bool cmd = ctrl; // && !meta, already guaranteed
 #endif

    if (alt) {
-        // no shortcuts involve Alt, and it must not be forwarded to the device
+        // No shortcuts involve Alt, and it is not forwarded to the device
        return;
    }

    struct controller *controller = im->controller;

-    // capture all Ctrl events
-    if (ctrl || cmd) {
    SDL_Keycode keycode = event->keysym.sym;
    bool down = event->type == SDL_KEYDOWN;
+
+    // Capture all RCtrl events
+    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 && ctrl && !meta && !shift && !repeat) {
+                if (control && !shift && !repeat) {
                    action_home(controller, action);
                }
                return;
            case SDLK_b: // fall-through
            case SDLK_BACKSPACE:
-                if (control && cmd && !shift && !repeat) {
+                if (control && !shift && !repeat) {
                    action_back(controller, action);
                }
                return;
            case SDLK_s:
-                if (control && cmd && !shift && !repeat) {
+                if (control && !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 && ctrl && !meta && !shift && !repeat) {
+                if (control && !shift && !repeat) {
                    action_menu(controller, action);
                }
                return;
            case SDLK_p:
-                if (control && cmd && !shift && !repeat) {
+                if (control && !shift && !repeat) {
                    action_power(controller, action);
                }
                return;
            case SDLK_o:
-                if (control && cmd && !shift && down) {
-                    set_screen_power_mode(controller, SCREEN_POWER_MODE_OFF);
+                if (control && !repeat && down) {
+                    enum screen_power_mode mode = shift
+                                                ? SCREEN_POWER_MODE_NORMAL
+                                                : SCREEN_POWER_MODE_OFF;
+                    set_screen_power_mode(controller, mode);
                }
                return;
            case SDLK_DOWN:
-                if (control && cmd && !shift) {
+                if (control && !shift) {
                    // forward repeated events
                    action_volume_down(controller, action);
                }
                return;
            case SDLK_UP:
-                if (control && cmd && !shift) {
+                if (control && !shift) {
                    // forward repeated events
                    action_volume_up(controller, action);
                }
                return;
            case SDLK_LEFT:
-                if (cmd && !shift && down) {
+                if (!shift && !repeat && down) {
                    rotate_client_left(im->screen);
                }
                return;
            case SDLK_RIGHT:
-                if (cmd && !shift && down) {
+                if (!shift && !repeat && 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 && cmd && !repeat && down) {
-                    if (shift) {
-                        // store the text in the device clipboard
-                        set_device_clipboard(controller);
-                    } else {
-                        // inject the text as input events
+                if (control && !shift && !repeat && down) {
+                    // Inject the text as input events
                    clipboard_paste(controller);
                }
-                }
                return;
            case SDLK_f:
-                if (!shift && cmd && !repeat && down) {
+                if (!shift && !repeat && down) {
                    screen_switch_fullscreen(im->screen);
                }
                return;
-            case SDLK_x:
-                if (!shift && cmd && !repeat && down) {
+            case SDLK_w:
+                if (!shift && !repeat && down) {
                    screen_resize_to_fit(im->screen);
                }
                return;
            case SDLK_g:
-                if (!shift && cmd && !repeat && down) {
+                if (!shift && !repeat && down) {
                    screen_resize_to_pixel_perfect(im->screen);
                }
                return;
            case SDLK_i:
-                if (!shift && cmd && !repeat && down) {
+                if (!shift && !repeat && down) {
                    struct fps_counter *fps_counter =
                        im->video_buffer->fps_counter;
                    switch_fps_counter_state(fps_counter);
                }
                return;
            case SDLK_n:
-                if (control && cmd && !repeat && down) {
+                if (control && !repeat && down) {
                    if (shift) {
                        collapse_notification_panel(controller);
                    } else {
@ -421,10 +397,19 @@ input_manager_process_key(struct input_manager *im,
                }
                return;
            case SDLK_r:
-                if (control && cmd && !shift && !repeat && down) {
+                if (control && !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;
@ -434,6 +419,12 @@ 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)) {
@ -487,11 +478,17 @@ 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]
-    float x = from->x * screen->content_size.width;
-    float y = from->y * screen->content_size.height;
+    int32_t x = from->x * ww;
+    int32_t y = from->y * wh;
    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;
@ -508,13 +505,6 @@ 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) {
@ -552,10 +542,15 @@ 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) {
-            bool outside =
-                is_outside_device_screen(im, event->x, event->y);
+            int32_t x = event->x;
+            int32_t y = 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;
@ -579,9 +574,15 @@ 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 = get_mouse_point(screen),
+        .point = screen_convert_to_frame_coords(screen, mouse_x, mouse_y),
    };

    to->type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT;
--- a/app/src/main.c
+++ b/app/src/main.c
@ -29,6 +29,24 @@ 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__
@ -38,20 +56,23 @@ 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
@ -136,7 +136,7 @@ event_watcher(void *data, SDL_Event *event) {
            && event->window.event == SDL_WINDOWEVENT_RESIZED) {
        // 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);
+        screen_render(&screen, true);
    }
    return 0;
 }
@ -293,6 +293,7 @@ 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,
@ -303,6 +304,8 @@ scrcpy(const struct scrcpy_options *options) {
        .display_id = options->display_id,
        .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,6 +8,7 @@
 #include "common.h"
 #include "input_manager.h"
 #include "recorder.h"
+#include "util/log.h"

 struct scrcpy_options {
    const char *serial;
@ -16,6 +17,8 @@ struct scrcpy_options {
    const char *window_title;
    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;
@ -39,6 +42,7 @@ struct scrcpy_options {
    bool window_borderless;
    bool mipmaps;
    bool stay_awake;
+    bool force_adb_forward;
 };

 #define SCRCPY_OPTIONS_DEFAULT { \
@ -48,6 +52,8 @@ struct scrcpy_options {
    .window_title = NULL, \
    .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, \
@ -74,6 +80,7 @@ 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(SDL_Window *window) {
+get_window_size(const struct screen *screen) {
    int width;
    int height;
-    SDL_GetWindowSize(window, &width, &height);
+    SDL_GetWindowSize(screen->window, &width, &height);

    struct size size;
    size.width = width;
@ -41,31 +41,12 @@ get_window_size(SDL_Window *window) {
    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) {
-    // setting the window size during fullscreen is implementation defined,
-    // so apply the resize only after fullscreen is disabled
-    screen->windowed_window_size = new_size;
-    apply_windowed_size(screen);
+    assert(!screen->fullscreen);
+    assert(!screen->maximized);
+    SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
 }

 // get the preferred display bounds (i.e. the screen bounds with some margins)
@ -87,6 +68,16 @@ 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)
@ -99,47 +90,43 @@ get_optimal_size(struct size current_size, struct size content_size) {
        return current_size;
    }

-    struct size display_size;
-    // 32 bits because we need to multiply two 16 bits values
-    uint32_t w;
-    uint32_t h;
+    struct size window_size;

+    struct size display_size;
    if (!get_preferred_display_bounds(&display_size)) {
        // could not get display bounds, do not constraint the size
-        w = current_size.width;
-        h = current_size.height;
+        window_size.width = current_size.width;
+        window_size.height = current_size.height;
    } else {
-        w = MIN(current_size.width, display_size.width);
-        h = MIN(current_size.height, display_size.height);
+        window_size.width = MIN(current_size.width, display_size.width);
+        window_size.height = MIN(current_size.height, display_size.height);
    }

-    if (h == w * content_size.height / content_size.width
-     || 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};
+    if (is_optimal_size(window_size, content_size)) {
+        return window_size;
    }

-    bool keep_width = content_size.width * h > content_size.height * w;
+    bool keep_width = content_size.width * window_size.height
+                    > content_size.height * window_size.width;
    if (keep_width) {
        // remove black borders on top and bottom
-        h = content_size.height * w / content_size.width;
+        window_size.height = content_size.height * window_size.width
+                           / content_size.width;
    } else {
        // remove black borders on left and right (or none at all if it already
        // fits)
-        w = content_size.width * h / content_size.height;
+        window_size.width = content_size.width * window_size.height
+                          / content_size.height;
    }

-    // w and h must fit into 16 bits
-    assert(w < 0x10000 && h < 0x10000);
-    return (struct size) {w, h};
+    return window_size;
 }

 // 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 windowed_size = get_windowed_window_size(screen);
-    return get_optimal_size(windowed_size, content_size);
+    struct size window_size = get_window_size(screen);
+    return get_optimal_size(window_size, content_size);
 }

 // initially, there is no current size, so use the frame size as current size
@ -169,6 +156,43 @@ 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;
@ -193,7 +217,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, -.5f);
+        gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -1.f);

        SDL_GL_UnbindTexture(texture);
    }
@ -258,13 +282,6 @@ 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) {
@ -288,7 +305,7 @@ screen_init_rendering(struct screen *screen, const char *window_title,
            LOGI("Trilinear filtering disabled");
        }
    } else {
-        LOGW("Trilinear filtering disabled (not an OpenGL renderer)");
+        LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
    }

    SDL_Surface *icon = read_xpm(icon_xpm);
@ -308,7 +325,12 @@ screen_init_rendering(struct screen *screen, const char *window_title,
        return false;
    }

-    screen->windowed_window_size = window_size;
+    // Reset the window size to trigger a SIZE_CHANGED event, to workaround
+    // HiDPI issues with some SDL renderers when several displays having
+    // different HiDPI scaling are connected
+    SDL_SetWindowSize(screen->window, window_size.width, window_size.height);
+
+    screen_update_content_rect(screen);

    return true;
 }
@ -331,6 +353,45 @@ 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);
@ -338,32 +399,15 @@ 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);

-    if (SDL_RenderSetLogicalSize(screen->renderer,
-                                 new_content_size.width,
-                                 new_content_size.height)) {
-        LOGE("Could not set renderer logical size: %s", SDL_GetError());
-        return;
-    }
+    set_content_size(screen, new_content_size);

-    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);
+    screen_render(screen, true);
 }

 // recreate the texture and resize the window if the frame size has changed
@ -371,31 +415,16 @@ 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);
@ -437,15 +466,19 @@ screen_update_frame(struct screen *screen, struct video_buffer *vb) {
    update_texture(screen, frame);
    mutex_unlock(vb->mutex);

-    screen_render(screen);
+    screen_render(screen, false);
    return true;
 }

 void
-screen_render(struct screen *screen) {
+screen_render(struct screen *screen, bool update_content_rect) {
+    if (update_content_rect) {
+        screen_update_content_rect(screen);
+    }
+
    SDL_RenderClear(screen->renderer);
    if (screen->rotation == 0) {
-        SDL_RenderCopy(screen->renderer, screen->texture, NULL, NULL);
+        SDL_RenderCopy(screen->renderer, screen->texture, NULL, &screen->rect);
    } else {
        // rotation in RenderCopyEx() is clockwise, while screen->rotation is
        // counterclockwise (to be consistent with --lock-video-orientation)
@ -455,12 +488,14 @@ screen_render(struct screen *screen) {
        SDL_Rect *dstrect = NULL;
        SDL_Rect rect;
        if (screen->rotation & 1) {
-            struct size size = screen->content_size;
-            rect.x = (size.width - size.height) / 2;
-            rect.y = (size.height - size.width) / 2;
-            rect.w = size.height;
-            rect.h = size.width;
+            rect.x = screen->rect.x + (screen->rect.w - screen->rect.h) / 2;
+            rect.y = screen->rect.y + (screen->rect.h - screen->rect.w) / 2;
+            rect.w = screen->rect.h;
+            rect.h = screen->rect.w;
            dstrect = &rect;
+        } else {
+            assert(screen->rotation == 2);
+            dstrect = &screen->rect;
        }

        SDL_RenderCopyEx(screen->renderer, screen->texture, NULL, dstrect,
@ -478,23 +513,20 @@ screen_switch_fullscreen(struct screen *screen) {
    }

    screen->fullscreen = !screen->fullscreen;
-    apply_windowed_size(screen);
+    if (!screen->fullscreen && !screen->maximized) {
+        apply_pending_resize(screen);
+    }

    LOGD("Switched to %s mode", screen->fullscreen ? "fullscreen" : "windowed");
-    screen_render(screen);
+    screen_render(screen, true);
 }

 void
 screen_resize_to_fit(struct screen *screen) {
-    if (screen->fullscreen) {
+    if (screen->fullscreen || screen->maximized) {
        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);
@ -524,39 +556,24 @@ screen_handle_window_event(struct screen *screen,
                           const SDL_WindowEvent *event) {
    switch (event->event) {
        case SDL_WINDOWEVENT_EXPOSED:
-            screen_render(screen);
+            screen_render(screen, true);
            break;
        case SDL_WINDOWEVENT_SIZE_CHANGED:
-            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);
+            screen_render(screen, true);
            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_windowed_size(screen);
+            apply_pending_resize(screen);
            break;
    }
 }
@ -568,6 +585,13 @@ 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:
@ -590,3 +614,15 @@ 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,13 +21,16 @@ 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.
-    struct size windowed_window_size;
-    // Since we receive the event SIZE_CHANGED before MAXIMIZED, we must be
-    // able to revert the size to its non-maximized value.
-    struct size windowed_window_size_backup;
+
+    bool resize_pending; // resize requested while fullscreen or maximized
+    // The content size the last time the window was not maximized or
+    // fullscreen (meaningful only when resize_pending is true)
+    struct size windowed_content_size;
+
    // 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;
@ -49,15 +52,18 @@ struct screen {
        .width = 0, \
        .height = 0, \
    }, \
-    .windowed_window_size = { \
-        .width = 0, \
-        .height = 0, \
-    }, \
-    .windowed_window_size_backup = { \
+    .resize_pending = false, \
+    .windowed_content_size = { \
        .width = 0, \
        .height = 0, \
    }, \
    .rotation = 0, \
+    .rect = { \
+        .x = 0, \
+        .y = 0, \
+        .w = 0, \
+        .h = 0, \
+    }, \
    .has_frame = false, \
    .fullscreen = false, \
    .maximized = false, \
@ -91,8 +97,11 @@ 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);
+screen_render(struct screen *screen, bool update_content_rect);

 // switch the fullscreen mode
 void
@ -119,4 +128,11 @@ 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,24 +217,46 @@ 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 (!force_adb_forward) {
+        // 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
+        // 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[3];
+    char lock_video_orientation_string[5];
    char display_id_string[6];
    sprintf(max_size_string, "%"PRIu16, params->max_size);
    sprintf(bit_rate_string, "%"PRIu32, params->bit_rate);
@ -259,6 +281,7 @@ 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,
@ -270,6 +293,7 @@ execute_server(struct server *server, const struct server_params *params) {
        display_id_string,
        params->show_touches ? "true" : "false",
        params->stay_awake ? "true" : "false",
+        params->codec_options ? params->codec_options : "-",
    };
 #ifdef SERVER_DEBUGGER
    LOGI("Server debugger waiting for a client on device port "
@ -365,7 +389,8 @@ 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,6 +9,7 @@
 #include "config.h"
 #include "command.h"
 #include "common.h"
+#include "util/log.h"
 #include "util/net.h"

 struct server {
@ -43,7 +44,9 @@ struct server {
 }

 struct server_params {
+    enum sc_log_level log_level;
    const char *crop;
+    const char *codec_options;
    struct port_range port_range;
    uint16_t max_size;
    uint32_t bit_rate;
@ -53,6 +56,7 @@ 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,6 +3,13 @@

 #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,17 +200,19 @@ static void test_serialize_get_clipboard(void) {
 static void test_serialize_set_clipboard(void) {
    struct control_msg msg = {
        .type = CONTROL_MSG_TYPE_SET_CLIPBOARD,
-        .inject_text = {
+        .set_clipboard = {
+            .paste = true,
            .text = "hello, world!",
        },
    };

    unsigned char buf[CONTROL_MSG_SERIALIZED_MAX_SIZE];
    int size = control_msg_serialize(&msg, buf);
-    assert(size == 16);
+    assert(size == 17);

    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.13',
+        version: '1.14',
        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_r29.0.5-windows.zip \
-		2df06160056ec9a84c7334af2a1e42740befbb1a2e34370e7af544a2cc78152c \
+	@./prepare-dep https://dl.google.com/android/repository/platform-tools_r30.0.0-windows.zip \
+		854305f9a702f5ea2c3de73edde402bd26afa0ee944c9b0c4380420f5a862e0d \
 		platform-tools
--- a/server/build.gradle
+++ b/server/build.gradle
@ -6,8 +6,8 @@ android {
        applicationId "com.genymobile.scrcpy"
        minSdkVersion 21
        targetSdkVersion 29
-        versionCode 15
-        versionName "1.13"
+        versionCode 16
+        versionName "1.14"
        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.13
+SCRCPY_VERSION_NAME=1.14

 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
@ -0,0 +1,24 @@
+/**
+ * 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/CodecOption.java
+++ b/server/src/main/java/com/genymobile/scrcpy/CodecOption.java
@ -0,0 +1,112 @@
+package com.genymobile.scrcpy;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class CodecOption {
+    private String key;
+    private Object value;
+
+    public CodecOption(String key, Object value) {
+        this.key = key;
+        this.value = value;
+    }
+
+    public String getKey() {
+        return key;
+    }
+
+    public Object getValue() {
+        return value;
+    }
+
+    public static List<CodecOption> parse(String codecOptions) {
+        if ("-".equals(codecOptions)) {
+            return null;
+        }
+
+        List<CodecOption> result = new ArrayList<>();
+
+        boolean escape = false;
+        StringBuilder buf = new StringBuilder();
+
+        for (char c : codecOptions.toCharArray()) {
+            switch (c) {
+                case '\\':
+                    if (escape) {
+                        buf.append('\\');
+                        escape = false;
+                    } else {
+                        escape = true;
+                    }
+                    break;
+                case ',':
+                    if (escape) {
+                        buf.append(',');
+                        escape = false;
+                    } else {
+                        // This comma is a separator between codec options
+                        String codecOption = buf.toString();
+                        result.add(parseOption(codecOption));
+                        // Clear buf
+                        buf.setLength(0);
+                    }
+                    break;
+                default:
+                    buf.append(c);
+                    break;
+            }
+        }
+
+        if (buf.length() > 0) {
+            String codecOption = buf.toString();
+            result.add(parseOption(codecOption));
+        }
+
+        return result;
+    }
+
+    private static CodecOption parseOption(String option) {
+        int equalSignIndex = option.indexOf('=');
+        if (equalSignIndex == -1) {
+            throw new IllegalArgumentException("'=' expected");
+        }
+        String keyAndType = option.substring(0, equalSignIndex);
+        if (keyAndType.length() == 0) {
+            throw new IllegalArgumentException("Key may not be null");
+        }
+
+        String key;
+        String type;
+
+        int colonIndex = keyAndType.indexOf(':');
+        if (colonIndex != -1) {
+            key = keyAndType.substring(0, colonIndex);
+            type = keyAndType.substring(colonIndex + 1);
+        } else {
+            key = keyAndType;
+            type = "int"; // assume int by default
+        }
+
+        Object value;
+        String valueString = option.substring(equalSignIndex + 1);
+        switch (type) {
+            case "int":
+                value = Integer.parseInt(valueString);
+                break;
+            case "long":
+                value = Long.parseLong(valueString);
+                break;
+            case "float":
+                value = Float.parseFloat(valueString);
+                break;
+            case "string":
+                value = valueString;
+                break;
+            default:
+                throw new IllegalArgumentException("Invalid codec option type (int, long, float, str): " + type);
+        }
+
+        return new CodecOption(key, value);
+    }
+}
--- a/server/src/main/java/com/genymobile/scrcpy/ControlMessage.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ControlMessage.java
@ -28,6 +28,7 @@ public final class ControlMessage {
    private Position position;
    private int hScroll;
    private int vScroll;
+    private boolean paste;

    private ControlMessage() {
    }
@ -68,10 +69,11 @@ public final class ControlMessage {
        return msg;
    }

-    public static ControlMessage createSetClipboard(String text) {
+    public static ControlMessage createSetClipboard(String text, boolean paste) {
        ControlMessage msg = new ControlMessage();
        msg.type = TYPE_SET_CLIPBOARD;
        msg.text = text;
+        msg.paste = paste;
        return msg;
    }

@ -134,4 +136,8 @@ 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,14 +12,15 @@ 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 = 4093;
+    public static final int CLIPBOARD_TEXT_MAX_LENGTH = 4092; // 4096 - 1 (type) - 1 (parse flag) - 2 (length)
    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
@ -109,8 +110,10 @@ public class ControlMessageReader {
        if (buffer.remaining() < len) {
            return null;
        }
-        buffer.get(textBuffer, 0, len);
-        return new String(textBuffer, 0, len, StandardCharsets.UTF_8);
+        int position = buffer.position();
+        // Move the buffer position to consume the text
+        buffer.position(position + len);
+        return new String(rawBuffer, position, len, StandardCharsets.UTF_8);
    }

    private ControlMessage parseInjectText() {
@ -147,11 +150,15 @@ 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);
+        return ControlMessage.createSetClipboard(text, parse);
    }

    private ControlMessage parseSetScreenPowerMode() {
--- a/server/src/main/java/com/genymobile/scrcpy/Controller.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Controller.java
@ -1,10 +1,8 @@
 package com.genymobile.scrcpy;

-import com.genymobile.scrcpy.wrappers.InputManager;
-
+import android.os.Build;
 import android.os.SystemClock;
 import android.view.InputDevice;
-import android.view.InputEvent;
 import android.view.KeyCharacterMap;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
@ -50,7 +48,7 @@ public class Controller {
    public void control() throws IOException {
        // on start, power on the device
        if (!device.isScreenOn()) {
-            injectKeycode(KeyEvent.KEYCODE_POWER);
+            device.injectKeycode(KeyEvent.KEYCODE_POWER);

            // dirty hack
            // After POWER is injected, the device is powered on asynchronously.
@ -107,14 +105,20 @@ public class Controller {
                break;
            case ControlMessage.TYPE_GET_CLIPBOARD:
                String clipboardText = device.getClipboardText();
+                if (clipboardText != null) {
                    sender.pushClipboardText(clipboardText);
+                }
                break;
            case ControlMessage.TYPE_SET_CLIPBOARD:
-                device.setClipboardText(msg.getText());
+                setClipboard(msg.getText(), msg.getPaste());
                break;
            case ControlMessage.TYPE_SET_SCREEN_POWER_MODE:
                if (device.supportsInputEvents()) {
-                    device.setScreenPowerMode(msg.getAction());
+                    int mode = 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:
@ -126,7 +130,7 @@ public class Controller {
    }

    private boolean injectKeycode(int action, int keycode, int metaState) {
-        return injectKeyEvent(action, keycode, 0, metaState);
+        return device.injectKeyEvent(action, keycode, 0, metaState);
    }

    private boolean injectChar(char c) {
@ -137,7 +141,7 @@ public class Controller {
            return false;
        }
        for (KeyEvent event : events) {
-            if (!injectEvent(event)) {
+            if (!device.injectEvent(event)) {
                return false;
            }
        }
@ -193,7 +197,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 injectEvent(event);
+        return device.injectEvent(event);
    }

    private boolean injectScroll(Position position, int hScroll, int vScroll) {
@ -216,26 +220,25 @@ 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);
-        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);
+        return device.injectEvent(event);
    }

    private boolean pressBackOrTurnScreenOn() {
        int keycode = device.isScreenOn() ? KeyEvent.KEYCODE_BACK : KeyEvent.KEYCODE_POWER;
-        return injectKeycode(keycode);
+        return device.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,12 +6,18 @@ 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.RemoteException;
+import android.os.SystemClock;
 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 {

@ -22,10 +28,16 @@ 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
@ -52,9 +64,9 @@ public final class Device {
        screenInfo = ScreenInfo.computeScreenInfo(displayInfo, options.getCrop(), options.getMaxSize(), options.getLockedVideoOrientation());
        layerStack = displayInfo.getLayerStack();

-        registerRotationWatcher(new IRotationWatcher.Stub() {
+        serviceManager.getWindowManager().registerRotationWatcher(new IRotationWatcher.Stub() {
            @Override
-            public void onRotationChanged(int rotation) throws RemoteException {
+            public void onRotationChanged(int rotation) {
                synchronized (Device.this) {
                    screenInfo = screenInfo.withDeviceRotation(rotation);

@ -66,6 +78,27 @@ 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");
        }
@ -118,7 +151,7 @@ public final class Device {
        return supportsInputEvents;
    }

-    public boolean injectInputEvent(InputEvent inputEvent, int mode) {
+    public boolean injectEvent(InputEvent inputEvent, int mode) {
        if (!supportsInputEvents()) {
            throw new AssertionError("Could not inject input event if !supportsInputEvents()");
        }
@ -130,18 +163,33 @@ 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 void registerRotationWatcher(IRotationWatcher rotationWatcher, int displayId) {
-        serviceManager.getWindowManager().registerRotationWatcher(rotationWatcher, displayId);
-    }
-
    public synchronized void setRotationListener(RotationListener rotationListener) {
        this.rotationListener = rotationListener;
    }

+    public synchronized void setClipboardListener(ClipboardListener clipboardListener) {
+        this.clipboardListener = clipboardListener;
+    }
+
    public void expandNotificationPanel() {
        serviceManager.getStatusBarManager().expandNotificationsPanel();
    }
@ -158,26 +206,31 @@ public final class Device {
        return s.toString();
    }

-    public void setClipboardText(String text) {
-        boolean ok = serviceManager.getClipboardManager().setText(text);
-        if (ok) {
-            Ln.i("Device clipboard set");
+    public boolean 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);
+        return ok;
    }

    /**
     * @param mode one of the {@code SCREEN_POWER_MODE_*} constants
     */
-    public void setScreenPowerMode(int mode) {
+    public boolean setScreenPowerMode(int mode) {
        IBinder d = SurfaceControl.getBuiltInDisplay();
        if (d == null) {
            Ln.e("Could not get built-in display");
-            return;
-        }
-        boolean ok = SurfaceControl.setDisplayPowerMode(d, mode);
-        if (ok) {
-            Ln.i("Device screen turned " + (mode == Device.POWER_MODE_OFF ? "off" : "on"));
+            return false;
        }
+        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,14 +15,25 @@ public final class Ln {
        DEBUG, INFO, WARN, ERROR
    }

-    private static final Level THRESHOLD = BuildConfig.DEBUG ? Level.DEBUG : Level.INFO;
+    private static Level threshold = 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,6 +3,7 @@ package com.genymobile.scrcpy;
 import android.graphics.Rect;

 public class Options {
+    private Ln.Level logLevel;
    private int maxSize;
    private int bitRate;
    private int maxFps;
@ -14,6 +15,15 @@ public class Options {
    private int displayId;
    private boolean showTouches;
    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;
@ -102,4 +112,12 @@ public class Options {
    public void setStayAwake(boolean stayAwake) {
        this.stayAwake = stayAwake;
    }
+
+    public String getCodecOptions() {
+        return codecOptions;
+    }
+
+    public void setCodecOptions(String codecOptions) {
+        this.codecOptions = codecOptions;
+    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
@ -12,6 +12,7 @@ import android.view.Surface;
 import java.io.FileDescriptor;
 import java.io.IOException;
 import java.nio.ByteBuffer;
+import java.util.List;
 import java.util.concurrent.atomic.AtomicBoolean;

 public class ScreenEncoder implements Device.RotationListener {
@ -25,15 +26,17 @@ public class ScreenEncoder implements Device.RotationListener {
    private final AtomicBoolean rotationChanged = new AtomicBoolean();
    private final ByteBuffer headerBuffer = ByteBuffer.allocate(12);

+    private List<CodecOption> codecOptions;
    private int bitRate;
    private int maxFps;
    private boolean sendFrameMeta;
    private long ptsOrigin;

-    public ScreenEncoder(boolean sendFrameMeta, int bitRate, int maxFps) {
+    public ScreenEncoder(boolean sendFrameMeta, int bitRate, int maxFps, List<CodecOption> codecOptions) {
        this.sendFrameMeta = sendFrameMeta;
        this.bitRate = bitRate;
        this.maxFps = maxFps;
+        this.codecOptions = codecOptions;
    }

    @Override
@ -61,7 +64,7 @@ public class ScreenEncoder implements Device.RotationListener {
    }

    private void internalStreamScreen(Device device, FileDescriptor fd) throws IOException {
-        MediaFormat format = createFormat(bitRate, maxFps);
+        MediaFormat format = createFormat(bitRate, maxFps, codecOptions);
        device.setRotationListener(this);
        boolean alive;
        try {
@ -151,7 +154,24 @@ public class ScreenEncoder implements Device.RotationListener {
        return MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC);
    }

-    private static MediaFormat createFormat(int bitRate, int maxFps) {
+    private static void setCodecOption(MediaFormat format, CodecOption codecOption) {
+        String key = codecOption.getKey();
+        Object value = codecOption.getValue();
+
+        if (value instanceof Integer) {
+            format.setInteger(key, (Integer) value);
+        } else if (value instanceof Long) {
+            format.setLong(key, (Long) value);
+        } else if (value instanceof Float) {
+            format.setFloat(key, (Float) value);
+        } else if (value instanceof String) {
+            format.setString(key, (String) value);
+        }
+
+        Ln.d("Codec option set: " + key + " (" + value.getClass().getSimpleName() + ") = " + value);
+    }
+
+    private static MediaFormat createFormat(int bitRate, int maxFps, List<CodecOption> codecOptions) {
        MediaFormat format = new MediaFormat();
        format.setString(MediaFormat.KEY_MIME, MediaFormat.MIMETYPE_VIDEO_AVC);
        format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
@ -167,6 +187,13 @@ public class ScreenEncoder implements Device.RotationListener {
            // <https://github.com/Genymobile/scrcpy/issues/488#issuecomment-567321437>
            format.setFloat(KEY_MAX_FPS_TO_ENCODER, maxFps);
        }
+
+        if (codecOptions != null) {
+            for (CodecOption option : codecOptions) {
+                setCodecOption(format, option);
+            }
+        }
+
        return format;
    }

--- a/server/src/main/java/com/genymobile/scrcpy/Server.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Server.java
@ -8,6 +8,8 @@ import android.os.BatteryManager;
 import android.os.Build;

 import java.io.IOException;
+import java.util.List;
+import java.util.Locale;

 public final class Server {

@ -19,6 +21,7 @@ public final class Server {
    private static void scrcpy(Options options) throws IOException {
        Ln.i("Device: " + Build.MANUFACTURER + " " + Build.MODEL + " (Android " + Build.VERSION.RELEASE + ")");
        final Device device = new Device(options);
+        List<CodecOption> codecOptions = CodecOption.parse(options.getCodecOptions());

        boolean mustDisableShowTouchesOnCleanUp = false;
        int restoreStayOn = -1;
@ -49,15 +52,23 @@ public final class Server {
        CleanUp.configure(mustDisableShowTouchesOnCleanUp, restoreStayOn);

        boolean tunnelForward = options.isTunnelForward();
+
        try (DesktopConnection connection = DesktopConnection.open(device, tunnelForward)) {
-            ScreenEncoder screenEncoder = new ScreenEncoder(options.getSendFrameMeta(), options.getBitRate(), options.getMaxFps());
+            ScreenEncoder screenEncoder = new ScreenEncoder(options.getSendFrameMeta(), options.getBitRate(), options.getMaxFps(), codecOptions);

            if (options.getControl()) {
-                Controller controller = new Controller(device, connection);
+                final 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 {
@ -109,47 +120,53 @@ public final class Server {
                    "The server version (" + BuildConfig.VERSION_NAME + ") does not match the client " + "(" + clientVersion + ")");
        }

-        final int expectedParameters = 12;
+        final int expectedParameters = 14;
        if (args.length != expectedParameters) {
            throw new IllegalArgumentException("Expecting " + expectedParameters + " parameters");
        }

        Options options = new Options();

-        int maxSize = Integer.parseInt(args[1]) & ~7; // multiple of 8
+        Ln.Level level = Ln.Level.valueOf(args[1].toUpperCase(Locale.ENGLISH));
+        options.setLogLevel(level);
+
+        int maxSize = Integer.parseInt(args[2]) & ~7; // multiple of 8
        options.setMaxSize(maxSize);

-        int bitRate = Integer.parseInt(args[2]);
+        int bitRate = Integer.parseInt(args[3]);
        options.setBitRate(bitRate);

-        int maxFps = Integer.parseInt(args[3]);
+        int maxFps = Integer.parseInt(args[4]);
        options.setMaxFps(maxFps);

-        int lockedVideoOrientation = Integer.parseInt(args[4]);
+        int lockedVideoOrientation = Integer.parseInt(args[5]);
        options.setLockedVideoOrientation(lockedVideoOrientation);

        // use "adb forward" instead of "adb tunnel"? (so the server must listen)
-        boolean tunnelForward = Boolean.parseBoolean(args[5]);
+        boolean tunnelForward = Boolean.parseBoolean(args[6]);
        options.setTunnelForward(tunnelForward);

-        Rect crop = parseCrop(args[6]);
+        Rect crop = parseCrop(args[7]);
        options.setCrop(crop);

-        boolean sendFrameMeta = Boolean.parseBoolean(args[7]);
+        boolean sendFrameMeta = Boolean.parseBoolean(args[8]);
        options.setSendFrameMeta(sendFrameMeta);

-        boolean control = Boolean.parseBoolean(args[8]);
+        boolean control = Boolean.parseBoolean(args[9]);
        options.setControl(control);

-        int displayId = Integer.parseInt(args[9]);
+        int displayId = Integer.parseInt(args[10]);
        options.setDisplayId(displayId);

-        boolean showTouches = Boolean.parseBoolean(args[10]);
+        boolean showTouches = Boolean.parseBoolean(args[11]);
        options.setShowTouches(showTouches);

-        boolean stayAwake = Boolean.parseBoolean(args[11]);
+        boolean stayAwake = Boolean.parseBoolean(args[12]);
        options.setStayAwake(stayAwake);

+        String codecOptions = args[13];
+        options.setCodecOptions(codecOptions);
+
        return options;
    }

@ -202,6 +219,9 @@ 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,6 +3,7 @@ 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;

@ -13,6 +14,7 @@ public class ClipboardManager {
    private final IInterface manager;
    private Method getPrimaryClipMethod;
    private Method setPrimaryClipMethod;
+    private Method addPrimaryClipChangedListener;

    public ClipboardManager(IInterface manager) {
        this.manager = manager;
@ -81,4 +83,37 @@ 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
@ -0,0 +1,114 @@
+package com.genymobile.scrcpy;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+public class CodecOptionsTest {
+
+    @Test
+    public void testIntegerImplicit() {
+        List<CodecOption> codecOptions = CodecOption.parse("some_key=5");
+
+        Assert.assertEquals(1, codecOptions.size());
+
+        CodecOption option = codecOptions.get(0);
+        Assert.assertEquals("some_key", option.getKey());
+        Assert.assertEquals(5, option.getValue());
+    }
+
+    @Test
+    public void testInteger() {
+        List<CodecOption> codecOptions = CodecOption.parse("some_key:int=5");
+
+        Assert.assertEquals(1, codecOptions.size());
+
+        CodecOption option = codecOptions.get(0);
+        Assert.assertEquals("some_key", option.getKey());
+        Assert.assertTrue(option.getValue() instanceof Integer);
+        Assert.assertEquals(5, option.getValue());
+    }
+
+    @Test
+    public void testLong() {
+        List<CodecOption> codecOptions = CodecOption.parse("some_key:long=5");
+
+        Assert.assertEquals(1, codecOptions.size());
+
+        CodecOption option = codecOptions.get(0);
+        Assert.assertEquals("some_key", option.getKey());
+        Assert.assertTrue(option.getValue() instanceof Long);
+        Assert.assertEquals(5L, option.getValue());
+    }
+
+    @Test
+    public void testFloat() {
+        List<CodecOption> codecOptions = CodecOption.parse("some_key:float=4.5");
+
+        Assert.assertEquals(1, codecOptions.size());
+
+        CodecOption option = codecOptions.get(0);
+        Assert.assertEquals("some_key", option.getKey());
+        Assert.assertTrue(option.getValue() instanceof Float);
+        Assert.assertEquals(4.5f, option.getValue());
+    }
+
+    @Test
+    public void testString() {
+        List<CodecOption> codecOptions = CodecOption.parse("some_key:string=some_value");
+
+        Assert.assertEquals(1, codecOptions.size());
+
+        CodecOption option = codecOptions.get(0);
+        Assert.assertEquals("some_key", option.getKey());
+        Assert.assertTrue(option.getValue() instanceof String);
+        Assert.assertEquals("some_value", option.getValue());
+    }
+
+    @Test
+    public void testStringEscaped() {
+        List<CodecOption> codecOptions = CodecOption.parse("some_key:string=warning\\,this_is_not=a_new_key");
+
+        Assert.assertEquals(1, codecOptions.size());
+
+        CodecOption option = codecOptions.get(0);
+        Assert.assertEquals("some_key", option.getKey());
+        Assert.assertTrue(option.getValue() instanceof String);
+        Assert.assertEquals("warning,this_is_not=a_new_key", option.getValue());
+    }
+
+    @Test
+    public void testList() {
+        List<CodecOption> codecOptions = CodecOption.parse("a=1,b:int=2,c:long=3,d:float=4.5,e:string=a\\,b=c");
+
+        Assert.assertEquals(5, codecOptions.size());
+
+        CodecOption option;
+
+        option = codecOptions.get(0);
+        Assert.assertEquals("a", option.getKey());
+        Assert.assertTrue(option.getValue() instanceof Integer);
+        Assert.assertEquals(1, option.getValue());
+
+        option = codecOptions.get(1);
+        Assert.assertEquals("b", option.getKey());
+        Assert.assertTrue(option.getValue() instanceof Integer);
+        Assert.assertEquals(2, option.getValue());
+
+        option = codecOptions.get(2);
+        Assert.assertEquals("c", option.getKey());
+        Assert.assertTrue(option.getValue() instanceof Long);
+        Assert.assertEquals(3L, option.getValue());
+
+        option = codecOptions.get(3);
+        Assert.assertEquals("d", option.getKey());
+        Assert.assertTrue(option.getValue() instanceof Float);
+        Assert.assertEquals(4.5f, option.getValue());
+
+        option = codecOptions.get(4);
+        Assert.assertEquals("e", option.getKey());
+        Assert.assertTrue(option.getValue() instanceof String);
+        Assert.assertEquals("a,b=c", option.getValue());
+    }
+}
--- a/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java
+++ b/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java
@ -216,6 +216,7 @@ 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);
@ -227,6 +228,33 @@ 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
Author	SHA1	Message	Date
Romain Vimont	a01e9c2812	Avoid additional copy on Java text parsing Directly pass the buffer range to the String constructor.	2020-07-09 12:28:42 +02:00
Romain Vimont	80f5a7c43d	Update copy-paste section in README Update documentation regarding the recent copy-paste changes.	2020-07-09 12:28:42 +02:00
Romain Vimont	ddb36e3436	Forward copy-cut shortcuts For convenience, forward RCtrl+c (or Cmd+c) and and RCtrl+x (or Cmd+x) as LCtrl+c and LCtrl+x to the device. This allows to use the "natural" keys for copy-paste (especially on macOS).	2020-07-09 12:28:42 +02:00
Romain Vimont	cac1765091	Change "resize to fit" shortcut to RCtrl+w For convenience, RCtrl+x (and Cmd+x) will be used for "cut text to clipboard", in addition to LCtrl+x.	2020-07-09 12:28:42 +02:00
Romain Vimont	f5a14b285b	Accept Cmd for shortcuts on macOS For convenience (and to keep the existing behavior), also accept shortcuts using Cmd instead of RCtrl.	2020-07-09 12:28:42 +02:00
Romain Vimont	65edae0ca6	Reformulate RCtrl+v description RCtrl+v is the only scrcpy shortcut related to copy-paste. Since it's not a real "paste", reformulate to indicate that it injects the clipboard content as text events.	2020-07-09 12:28:42 +02:00
Romain Vimont	e4a0fada10	Remove RCtrl+c copy shortcut Now that Ctrl+c is forwarded to the device, and that every device clipboard change is automatically synchronized to the computer, RCtrl+c is useless.	2020-07-09 12:28:42 +02:00
Romain Vimont	8a037e3d9b	Remove RCtrl+Shift+v paste shortcut Now that LCtrl+v synchronize the computer clipboard to the device clipboard, RCtrl+Shift+v is not needed anymore. Note: RCtrl+v is kept to send the computer clipboard content as a sequence of keys.	2020-07-09 12:28:42 +02:00
Romain Vimont	b3aa88c751	Set device clipboard only if necessary Do not explicitly set the clipboard text if it already contains the expected content. This avoids possible copy-paste loops between the computer and the device.	2020-07-09 12:28:37 +02:00
Romain Vimont	b9602e56d9	Synchronize clipboard on Ctrl+v Pressing Ctrl+v on the device will typically paste the clipboard content. Before sending the key event, synchronize the computer clipboard to the device clipboard to allow seamless copy-paste.	2020-06-02 18:27:24 +02:00
Romain Vimont	0c01ac34b4	Simplify PASTE option for "set clipboard" When the client requests to set the clipboard, it may request to press the PASTE key in addition. To be a bit generic, it was stored as a flag in ControlMessage.java. But flags suggest that it represents a bitwise union, which could become confusing when we add a COPY option for getting the clipboard.	2020-06-02 18:27:24 +02:00
Romain Vimont	82295ef4a7	Forward Shift to the device This allows to select text using Shift+(arrow keys). Fixes #942 <https://github.com/Genymobile/scrcpy/issues/942>	2020-06-02 18:27:24 +02:00
Romain Vimont	e62aca59fe	Forward LCtrl to the device Now that only RCtrl is used for scrcpy shortcuts, LCtrl can be forwarded to the device. This allows to trigger Android shortcuts. Fixes #555 <https://github.com/Genymobile/scrcpy/issues/555>	2020-06-02 18:27:24 +02:00
Romain Vimont	fbd2d0bf3e	Only use RCtrl for scrcpy shortcuts This paves the way to forward LCtrl to the device.	2020-06-02 18:27:24 +02:00
Romain Vimont	6e1069a822	Configure log level for application only Do not expose internal SDL logs to users. Fixes #1441 <https://github.com/Genymobile/scrcpy/issues/1441>	2020-06-02 18:27:23 +02:00
Romain Vimont	c4323df976	Fix incorrect log return value The function must return a SDL_LogPriority, but returned an enum sc_log_level. (It was harmless because this specific return should never happen, as asserted.)	2020-06-02 18:27:14 +02:00
Romain Vimont	8ff07e0c88	Git-ignore release directories	2020-06-02 18:25:22 +02:00
Romain Vimont	e4efd75766	Avoid repetition for some shortcuts Keeping the key pressed generate "repeat" events. It does not make sense to repeat the event for rotation or turn screen off.	2020-05-29 22:02:41 +02:00
Romain Vimont	0e4a6f462b	Mention stay awake limitation The "stay awake" feature only works when the device is plugged in. Refs #1445 <https://github.com/Genymobile/scrcpy/issues/1445>	2020-05-28 23:07:28 +02:00
Romain Vimont	8b73c90427	Mention how to turn the screen on in README Now that Ctrl+Shift+o has been reactivated, mention it in the "turn screen off" section.	2020-05-27 19:32:02 +02:00
Romain Vimont	ef91ab2841	Update links to v1.14 in README and BUILD	2020-05-27 19:31:12 +02:00
Romain Vimont	44fa4a090e	Bump version to 1.14	2020-05-27 18:26:46 +02:00
Romain Vimont	dcde578a50	Reactivate "turn device screen on" feature This reverts commit `8c8649cfcd`. I cannot reproduce the issue with Ctrl+Shift+o on any device, so in practice it works, it's too bad to remove the feature for a random bug on some Android versions on some devices.	2020-05-27 18:26:46 +02:00
Romain Vimont	93a5c5149d	Push clipboard text only if not null In practice, it does not change anything (it just avoids a spurious wake-up), but semantically, it makes no sense to call pushClipboardText() with a null value.	2020-05-27 18:26:39 +02:00
Romain Vimont	2ca8318b9d	Improve manpage formatting Add a new line to avoid unwanted text justification	2020-05-27 12:39:42 +02:00
Romain Vimont	d499ee53c9	Initialize a default log level Clean up has been broken by `3df63c579d`. The verbosity was correctly initialized for the Server process, but not for the CleanUp process. To avoid the problem, initialize a default log level.	2020-05-27 12:05:29 +02:00
Romain Vimont	8f619f337b	Upgrade platform-tools (30.0.0) for Windows Include the latest version of adb in Windows releases.	2020-05-26 19:21:05 +02:00
Romain Vimont	fc1dec0270	Paste on "set clipboard" if possible Ctrl+Shift+v synchronizes the computer clipboard to the Android device clipboard. This feature had been added to provide a way to copy UTF-8 text from the computer to the device. To make such a paste more straightforward, if the device runs at least Android 7, also send a PASTE keycode to paste immediately. <https://developer.android.com/reference/android/view/KeyEvent.html#KEYCODE_PASTE> Fixes #786 <https://github.com/Genymobile/scrcpy/issues/786>	2020-05-25 20:59:21 +02:00
Romain Vimont	274b591d18	Fix union typo The "set clipboard" event used the wrong union type to store its text. In practice, it worked because both are at the same offset.	2020-05-25 18:41:05 +02:00
Romain Vimont	4bbabfb4ef	Move injection methods to Device Only the main injection method was exposed on Device, the convenience methods were implemented in Controller. For consistency, move them all to the Device class.	2020-05-25 03:28:33 +02:00
Romain Vimont	ffc57512b3	Avoid clipboard synchronization loop The Android device listens for clipboard changes to synchronize with the computer clipboard. However, if the change comes from scrcpy (for example via Ctrl+Shift+v), do not notify the change.	2020-05-25 03:28:33 +02:00
Romain Vimont	c7a33fac36	Log actions on the caller side Some actions are exposed by the Device class, but logging success should be done by the caller.	2020-05-25 03:28:33 +02:00
Romain Vimont	81573d81a0	Pass a Locale to toUpperCase() Make lint happy.	2020-05-25 03:28:15 +02:00
Romain Vimont	5c2cf88a1d	Rename THRESHOLD to threshold Since the field is not final anymore, lint expects the name not to be capitalized.	2020-05-25 03:22:07 +02:00
Romain Vimont	8f46e18426	Add --force-adb-forward Add a command-line option to force "adb forward", without attempting "adb reverse" first. This is especially useful for using SSH tunnels without enabling remote port forwarding.	2020-05-24 23:28:31 +02:00
Romain Vimont	ee3882f8be	Fix typo in manpage	2020-05-24 23:14:30 +02:00
Romain Vimont	a3ef461d73	Add cli option to set the verbosity level The verbosity was set either to info (in release mode) or debug (in debug mode). Add a command-line argument to change it, so that users can enable debug logs using the release: scrcpy -Vdebug	2020-05-24 22:01:51 +02:00
Romain Vimont	3df63c579d	Configure server verbosity from the client Send the requested log level from the client. This paves the way to configure it via a command-line argument.	2020-05-24 21:14:25 +02:00
Romain Vimont	56bff2f718	Avoid compiler warning The field lock_video_orientation may only take values between -1 and 3 (included). But the compiler may trigger a warning on the sprintf() call, because its type could represent values which could overflow the string (like "-128"): > warning: ‘%i’ directive writing between 1 and 4 bytes into a region of > size 3 [-Wformat-overflow=] Increase the buffer size to remove the warning.	2020-05-24 21:11:21 +02:00
Tzah Mazuz	080a4ee365	Add --codec-options Add a command-line parameter to pass custom options to the device encoder (as a comma-separated list of "key[:type]=value"). The list of possible codec options is available in the Android documentation: <https://d.android.com/reference/android/media/MediaFormat> PR #1325 <https://github.com/Genymobile/scrcpy/pull/1325> Refs #1226 <https://github.com/Genymobile/scrcpy/pull/1226> Co-authored-by: Romain Vimont <rom@rom1v.com>	2020-05-24 14:54:34 +02:00
Romain Vimont	c7155a1954	Add unit test for big "set clipboard" event Add a unit test to avoid regressions. Refs #1425 <https://github.com/Genymobile/scrcpy/issues/1425>	2020-05-24 14:33:43 +02:00
Romain Vimont	517dbd9c85	Increase buffer size to fix "set clipboard" event The buffer size must be greater than any event message. Clipboard events may take up to 4096 bytes, so increase the buffer size. Fixes #1425 <https://github.com/Genymobile/scrcpy/issues/1425>	2020-05-24 14:33:23 +02:00
Romain Vimont	acc4ef31df	Synchronize device clipboard to computer Automatically synchronize the device clipboard to the computer any time it changes. This allows seamless copy-paste from Android to the computer. Fixes #1056 <https://github.com/Genymobile/scrcpy/issues/1056#issuecomment-631363684> PR #1423 <https://github.com/Genymobile/scrcpy/pull/1423>	2020-05-24 14:31:49 +02:00
Romain Vimont	73e722784d	Remove useless exception declaration The interface declares it can throw a RemoteException, but the implementation never throws such exception.	2020-05-23 18:21:54 +02:00
Romain Vimont	e1cd75792c	Simplify rotation watcher call Remove unnecessary private method (which was wrongly public).	2020-05-23 14:39:09 +02:00
Romain Vimont	ac4c8b4a3f	Increase LOD bias for mipmapping Mipmapping caused too much blurring. Using a LOD bias of -1 instead of -0.5 seems a better compromise to avoid low-quality downscaling while keeping sharp edges in any case. Refs <https://github.com/Genymobile/scrcpy/issues/1394> Refs <https://github.com/Genymobile/scrcpy/issues/40#issuecomment-591917787>	2020-05-23 14:32:16 +02:00
Romain Vimont	fae3f9eeab	Remove warning when renderer is not OpenGL Trilinear filtering can currently only be enabled for OpenGL renderers. Do not print a warning if the renderer is not OpenGL, as it can confuses users, while nothing is wrong.	2020-05-23 14:23:30 +02:00
Romain Vimont	f5aeecbc62	Reset window size on initialization On macOS with renderer "metal", HiDPI scaling may be incorrect on initialization when several displays are connected. Resetting the window size fixes the problem. Refs #15 <https://github.com/Genymobile/scrcpy/issues/15>	2020-05-23 14:19:09 +02:00
Romain Vimont	e40532a376	Manually position and scale the content Position and scale the content "manually" instead of relying on the renderer "logical size". This avoids possible rounding differences between the computed window size and the content size, causing one row or column of black pixels on the bottom or on the right. This also avoids HiDPI scale issues, by computing the scaling manually. This will also enable to draw items at their expected size on the screen (unscaled). Fixes #15 <https://github.com/Genymobile/scrcpy/issues/15>	2020-05-23 14:19:09 +02:00
Romain Vimont	d860ad48e6	Extract optimal window size detection Extract the computation to detect whether the current size of the window is already optimal. This will allow to reuse it for rendering.	2020-05-23 14:19:09 +02:00
Romain Vimont	ec047b501e	Disable "resize to fit" in maximized state In maximized state (but not fullscreen), it was possible to resize to fit the device screen (with Ctrl+x or double-clicking on black borders). This caused problems on macOS with the "expand to fullscreen" feature, which behaves like a fullscreen mode but is seen as maximized by SDL. In that state, resizing to fit causes unexpected results. To keep the behavior consistent on all platforms, just disable "resize to fit" when the window is maximized.	2020-05-23 14:19:09 +02:00
Romain Vimont	4c2e10fd74	Workaround maximized+fullscreen on Windows On Windows, in maximized+fullscreen state, 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). Moreover, apply_pending_resize() asserts that fullscreen is disabled. To avoid the issue, if fullscreen is set, just ignore the "restored" event.	2020-05-23 14:19:09 +02:00
Romain Vimont	6b1da2fcff	Simplify size changes in fullscreen or maximized If the content size changes (due to rotation for example) while the window is maximized or fullscreen, the resize must be applied once fullscreen and maximized are disabled. The previous strategy consisted in storing the windowed size, computing the target size on rotation, and applying it on window restoration. But tracking the windowed size (while ignoring the non-windowed size) was tricky, due to unspecified order of SDL events (e.g. size changes can be notified before "maximized" events), race conditions when reading window flags, different behaviors on different platforms... To simplify the whole resize management, store the old content size (the frame size, possibly rotated) when it changes while the window is maximized or fullscreen, so that the new optimal size can be computed on window restoration.	2020-05-23 14:19:09 +02:00
Romain Vimont	2608b1dc62	Factorize window resize When the content size changes, either on frame size or client rotation changes, the window must be resized. Factorize for both cases.	2020-05-23 14:19:09 +02:00
Romain Vimont	31fa115655	Merge branch 'master' into dev	2020-05-23 14:18:47 +02:00
Romain Vimont	82446b6b0d	Reference README.md from localized versions Mention that the README.md is the only one being up-to-date.	2020-05-10 11:47:56 +02:00
latreta	24c8039244	Add Brazilian Portuguese translation Signed-off-by: Romain Vimont <rom@rom1v.com>	2020-05-10 11:46:24 +02:00
Romain Vimont	1a9429f3c7	Improve bug report template Insert a code block to (hopefully) increase the chances that users format their terminal output.	2020-05-06 22:26:43 +02:00
Romain Vimont	0b4e484da0	Add a note about multi-display limitation Secondary display mirroring is read-only before Android 10.	2020-05-06 22:21:33 +02:00