Add --codec-options

Co-authored-by: Romain Vimont <rom@rom1v.com>
2020-05-04 01:17:02 +02:00
26 changed files with 276 additions and 1207 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@ -21,9 +21,5 @@ assignees: ''
 A clear and concise description of what the bug is.

 On errors, please provide the output of the console (and `adb logcat` if relevant).
-
-```
-Please paste terminal output in a code block.
-```
-
+Format them between code blocks (delimited by ```).
 Please do not post screenshots of your terminal, just post the content as text instead.
--- a/README.ko.md
+++ b/README.ko.md
@ -1,5 +1,3 @@
-_Only the original [README](README.md) is guaranteed to be up-to-date._
-
 # scrcpy (v1.11)

 This document will be updated frequently along with the original Readme file
--- a/README.md
+++ b/README.md
@ -210,6 +210,7 @@ To disable mirroring while recording:
 scrcpy --no-display --record file.mp4
 scrcpy -Nr file.mkv
 # interrupt recording with Ctrl+C
+# Ctrl+C does not terminate properly on Windows, so disconnect the device
 ```

 "Skipped frames" are recorded, even if they are not displayed in real time (for
@ -289,22 +290,6 @@ From another terminal:
 scrcpy
 ```

-To avoid enabling remote port forwarding, you could force a forward connection
-instead (notice the `-L` instead of `-R`):
-
-```bash
-adb kill-server    # kill the local adb server on 5037
-ssh -CN -L5037:localhost:5037 -L27183:localhost:27183 your_remote_computer
-# keep this open
-```
-
-From another terminal:
-
-```bash
-scrcpy --force-adb-forwrad
-```
-
-
 Like for wireless connections, it may be useful to reduce quality:

 ```
@ -411,10 +396,6 @@ 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:
@ -498,9 +479,6 @@ both directions:
 - `Ctrl`+`v` _pastes_ the computer clipboard as a sequence of text events (but
   breaks non-ASCII characters).

-Moreover, any time the Android clipboard changes, it is automatically
-synchronized to the computer clipboard.
-
 #### Text injection preference

 There are two kinds of [events][textevents] generated when typing text:
--- a/README.pt-br.md
+++ b/README.pt-br.md
@ -1,531 +0,0 @@
-_Only the original [README](README.md) is guaranteed to be up-to-date._
-
-# scrcpy (v1.12.1)
-
-Esta aplicação fornece visualização e controle de dispositivos Android conectados via
-USB (ou [via TCP/IP][article-tcpip]). Não requer nenhum acesso root.
-Funciona em _GNU/Linux_, _Windows_ e _macOS_.
-
-![screenshot](assets/screenshot-debian-600.jpg)
-
-Foco em:
-
- - **leveza** (Nativo, mostra apenas a tela do dispositivo)
- - **performance** (30~60fps)
- - **qualidade** (1920×1080 ou acima)
- - **baixa latência** ([35~70ms][lowlatency])
- - **baixo tempo de inicialização** (~1 segundo para mostrar a primeira imagem)
- - **não intrusivo** (nada é deixado instalado no dispositivo)
-
-[lowlatency]: https://github.com/Genymobile/scrcpy/pull/646
-
-
-## Requisitos
-
-O Dispositivo Android requer pelo menos a API 21 (Android 5.0).
-
-
-Tenha certeza de ter [ativado a depuração USB][enable-adb] no(s) seu(s) dispositivo(s).
-
-[enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
-
-
-Em alguns dispositivos, você também precisará ativar [uma opção adicional][control] para controlá-lo usando o teclado e mouse.
-
-[control]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
-
-
-## Obtendo o app
-
-
-### Linux
-
-No Debian (_em testes_ e _sid_ por enquanto):
-
-```
-apt install scrcpy
-```
-
-O pacote [Snap] está disponível: [`scrcpy`][snap-link].
-
-[snap-link]: https://snapstats.org/snaps/scrcpy
-
-[snap]: https://en.wikipedia.org/wiki/Snappy_(package_manager)
-
-Para Arch Linux, um pacote [AUR] está disponível: [`scrcpy`][aur-link].
-
-[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository
-[aur-link]: https://aur.archlinux.org/packages/scrcpy/
-
-Para Gentoo, uma [Ebuild] está disponível: [`scrcpy/`][ebuild-link].
-
-[Ebuild]: https://wiki.gentoo.org/wiki/Ebuild
-[ebuild-link]: https://github.com/maggu2810/maggu2810-overlay/tree/master/app-mobilephone/scrcpy
-
-
-Você também pode [compilar a aplicação manualmente][BUILD] (não se preocupe, não é tão difícil).
-
-
-### Windows
-
-Para Windows, para simplicidade, um arquivo pré-compilado com todas as dependências
-(incluindo `adb`) está disponível:
-
- - [`scrcpy-win64-v1.12.1.zip`][direct-win64]  
-   _(SHA-256: 57d34b6d16cfd9fe169bc37c4df58ebd256d05c1ea3febc63d9cb0a027ab47c9)_
-
-[direct-win64]: https://github.com/Genymobile/scrcpy/releases/download/v1.12.1/scrcpy-win64-v1.12.1.zip
-
-Também disponível em [Chocolatey]:
-
-[Chocolatey]: https://chocolatey.org/
-
-```bash
-choco install scrcpy
-choco install adb    # se você ainda não o tem
-```
-
-E no [Scoop]:
-
-```bash
-scoop install scrcpy
-scoop install adb    # se você ainda não o tem
-```
-
-[Scoop]: https://scoop.sh
-
-Você também pode [compilar a aplicação manualmente][BUILD].
-
-
-### macOS
-
-A aplicação está disponível em [Homebrew]. Apenas a instale:
-
-[Homebrew]: https://brew.sh/
-
-```bash
-brew install scrcpy
-```
-
-Você precisa do `adb`, acessível através do seu `PATH`. Se você ainda não o tem:
-
-```bash
-brew cask install android-platform-tools
-```
-
-Você também pode [compilar a aplicação manualmente][BUILD].
-
-
-## Executar
-
-Plugue um dispositivo Android e execute:
-
-```bash
-scrcpy
-```
-
-Também aceita argumentos de linha de comando, listados por:
-
-```bash
-scrcpy --help
-```
-
-## Funcionalidades
-
-### Configuração de captura
-
-#### Redução de tamanho
-
-Algumas vezes, é útil espelhar um dispositivo Android em uma resolução menor para
-aumentar performance.
-
-Para limitar ambos(largura e altura) para algum valor (ex: 1024):
-
-```bash
-scrcpy --max-size 1024
-scrcpy -m 1024  # versão reduzida
-```
-
-A outra dimensão é calculada para que a proporção do dispositivo seja preservada.
-Dessa forma, um dispositivo em 1920x1080 será espelhado em 1024x576.
-
-
-#### Mudanças no bit-rate
-
-O Padrão de bit-rate é 8 mbps. Para mudar o bitrate do vídeo (ex: para 2 Mbps):
-
-```bash
-scrcpy --bit-rate 2M
-scrcpy -b 2M  # versão reduzida
-```
-
-#### Limitar frame rates
-
-Em dispositivos com Android >= 10, a captura de frame rate pode ser limitada:
-
-```bash
-scrcpy --max-fps 15
-```
-
-#### Cortar
-
-A tela do dispositivo pode ser cortada para espelhar apenas uma parte da tela.
-
-Isso é útil por exemplo, ao espelhar apenas um olho do Oculus Go:
-
-```bash
-scrcpy --crop 1224:1440:0:0   # 1224x1440 no deslocamento (0,0)
-```
-
-Se `--max-size` também for especificado, redimensionar é aplicado após os cortes.
-
-
-### Gravando
-
-É possível gravar a tela enquanto ocorre o espelhamento:
-
-```bash
-scrcpy --record file.mp4
-scrcpy -r file.mkv
-```
-
-Para desativar o espelhamento durante a gravação:
-
-```bash
-scrcpy --no-display --record file.mp4
-scrcpy -Nr file.mkv
-# interrompe a gravação com Ctrl+C
-# Ctrl+C não encerrar propriamente no Windows, então desconecte o dispositivo
-```
-
-"Frames pulados" são gravados, mesmo que não sejam mostrado em tempo real (por motivos de performance).
-Frames tem seu _horário_ _carimbado_ no dispositivo, então [Variação de atraso nos pacotes] não impacta na gravação do arquivo.
-
-[Variação de atraso de pacote]: https://en.wikipedia.org/wiki/Packet_delay_variation
-
-
-### Conexão
-
-#### Wireless/Sem fio
-
-_Scrcpy_ usa `adb` para se comunicar com o dispositivo, e `adb` pode [conectar-se] à um dispositivo via TCP/IP:
-
-1. Conecte o dispositivo a mesma rede Wi-Fi do seu computador.
-2. Pegue o endereço de IP do seu dispositivo (Em Configurações → Sobre o Telefone → Status).
-3. Ative o adb via TCP/IP no seu dispositivo: `adb tcpip 5555`.
-4. Desplugue seu dispositivo.
-5. Conecte-se ao seu dispositivo: `adb connect DEVICE_IP:5555` _(substitua o `DEVICE_IP`)_.
-6. Execute `scrcpy` como de costume.
-
-Pode ser útil diminuir o bit-rate e a resolução:
-
-```bash
-scrcpy --bit-rate 2M --max-size 800
-scrcpy -b2M -m800  # versão reduzida
-```
-
-[conectar-se]: https://developer.android.com/studio/command-line/adb.html#wireless
-
-
-#### N-dispositivos
-
-Se alguns dispositivos estão listados em `adb devices`, você precisa especificar o _serial_:
-
-```bash
-scrcpy --serial 0123456789abcdef
-scrcpy -s 0123456789abcdef  # versão reduzida
-```
-
-Se o dispositivo está conectado via TCP/IP:
-
-```bash
-scrcpy --serial 192.168.0.1:5555
-scrcpy -s 192.168.0.1:5555  # versão reduzida
-```
-
-Você pode iniciar algumas instâncias do _scrcpy_ para alguns dispositivos.
-
-#### Conexão via SSH
-
-Para conectar-se à um dispositivo remoto, é possível se conectar um cliente local `adb`  à um servidor `adb` remoto (contanto que eles usem a mesma versão do protocolo _adb_):
-
-```bash
-adb kill-server    # encerra o servidor local na 5037
-ssh -CN -L5037:localhost:5037 -R27183:localhost:27183 your_remote_computer
-# mantém isso aberto
-```
-
-De outro terminal:
-
-```bash
-scrcpy
-```
-
-Igual para conexões sem fio, pode ser útil reduzir a qualidade:
-
-```
-scrcpy -b2M -m800 --max-fps 15
-```
-
-### Configurações de Janela
-
-#### Título
-
-Por padrão, o título da janela é o modelo do dispositivo. Isto pode ser mudado:
-
-```bash
-scrcpy --window-title 'Meu dispositivo'
-```
-
-#### Posição e tamanho
-
-A posição e tamanho iniciais da janela podem ser especificados:
-
-```bash
-scrcpy --window-x 100 --window-y 100 --window-width 800 --window-height 600
-```
-
-#### Sem bordas
-
-Para desativar decorações da janela:
-
-```bash
-scrcpy --window-borderless
-```
-
-#### Sempre visível
-
-Para manter a janela do scrcpy sempre visível:
-
-```bash
-scrcpy --always-on-top
-```
-
-#### Tela cheia
-
-A aplicação pode ser iniciada diretamente em tela cheia:
-
-```bash
-scrcpy --fullscreen
-scrcpy -f  # versão reduzida
-```
-
-Tela cheia pode ser alternada dinamicamente com `Ctrl`+`f`.
-
-
-### Outras opções de espelhamento
-
-#### Apenas leitura
-
-Para desativar controles (tudo que possa interagir com o dispositivo: teclas de entrada, eventos de mouse, arrastar e soltar arquivos):
-
-```bash
-scrcpy --no-control
-scrcpy -n
-```
-
-#### Desligar a tela
-
-É possível desligar a tela do dispositivo durante o início do espelhamento com uma opção de linha de comando:
-
-```bash
-scrcpy --turn-screen-off
-scrcpy -S
-```
-
-Ou apertando `Ctrl`+`o` durante qualquer momento.
-
-Para ligar novamente, pressione `POWER` (ou `Ctrl`+`p`).
-
-#### Frames expirados de renderização
-
-Por padrão, para minimizar a latência, _scrcpy_ sempre renderiza o último frame decodificado disponível e descarta o anterior.
-
-Para forçar a renderização de todos os frames ( com o custo de aumento de latência), use:
-
-```bash
-scrcpy --render-expired-frames
-```
-
-#### Mostrar toques
-
-Para apresentações, pode ser útil mostrar toques físicos(dispositivo físico).
-
-Android fornece esta funcionalidade nas _Opções do Desenvolvedor_.
-
-_Scrcpy_ fornece esta opção de ativar esta funcionalidade no início e desativar no encerramento:
-
-```bash
-scrcpy --show-touches
-scrcpy -t
-```
-
-Note que isto mostra apenas toques _físicos_ (com o dedo no dispositivo).
-
-
-### Controle de entrada
-
-#### Rotacionar a tela do dispositivo
-
-Pressione `Ctrl`+`r` para mudar entre os modos Retrato e Paisagem.
-
-Note que só será rotacionado se a aplicação em primeiro plano tiver suporte para o modo requisitado.
-
-#### Copiar-Colar
-
-É possível sincronizar áreas de transferência entre computador e o dispositivo,
-para ambas direções:
-
- - `Ctrl`+`c` copia a área de transferência do dispositivo para a área de trasferência do computador;
- - `Ctrl`+`Shift`+`v` copia a área de transferência do computador para a área de transferência do dispositivo;
- - `Ctrl`+`v` _cola_ a área de transferência do computador como uma sequência de eventos de texto (mas
-   quebra caracteres não-ASCII).
-
-#### Preferências de injeção de texto
-
-Existe dois tipos de [eventos][textevents] gerados ao digitar um texto:
- - _eventos de teclas_, sinalizando que a tecla foi pressionada ou solta;
- - _eventos de texto_, sinalizando que o texto foi inserido.
-
-Por padrão, letras são injetadas usando eventos de teclas, assim teclados comportam-se
-como esperado em jogos (normalmente para tecladas WASD)
-
-Mas isto pode [causar problemas][prefertext]. Se você encontrar tal problema,
-pode evitá-lo usando:
-
-```bash
-scrcpy --prefer-text
-```
-
-(mas isto vai quebrar o comportamento do teclado em jogos)
-
-[textevents]: https://blog.rom1v.com/2018/03/introducing-scrcpy/#handle-text-input
-[prefertext]: https://github.com/Genymobile/scrcpy/issues/650#issuecomment-512945343
-
-
-### Transferência de arquivo
-
-#### Instalar APK
-
-Para instalar um APK, arraste e solte o arquivo APK(com extensão `.apk`) na janela _scrcpy_.
-
-Não existe feedback visual, um log é imprimido no console.
-
-
-#### Enviar arquivo para o dispositivo
-
-Para enviar um arquivo para o diretório `/sdcard/` no dispositivo, arraste e solte um arquivo não APK para a janela do
-_scrcpy_.
-
-Não existe feedback visual, um log é imprimido no console.
-
-O diretório alvo pode ser mudado ao iniciar:
-
-```bash
-scrcpy --push-target /sdcard/foo/bar/
-```
-
-
-### Encaminhamento de áudio
-
-Áudio não é encaminhando pelo _scrcpy_. Use [USBaudio] (Apenas linux).
-
-Também veja [issue #14].
-
-[USBaudio]: https://github.com/rom1v/usbaudio
-[issue #14]: https://github.com/Genymobile/scrcpy/issues/14
-
-
-## Atalhos
-
- | Ação                                                          |   Atalho                        |   Atalho (macOS)
- | ------------------------------------------------------------- |:------------------------------- |:-----------------------------
- | Alternar para modo de tela cheia                              | `Ctrl`+`f`                      | `Cmd`+`f`
- | Redimensionar janela para pixel-perfect(Escala 1:1)           | `Ctrl`+`g`                      | `Cmd`+`g`
- | Redimensionar janela para tirar as bordas pretas              | `Ctrl`+`x` \| _Clique-duplo¹_   | `Cmd`+`x`  \| _Clique-duplo¹_
- | Clicar em `HOME`                                              | `Ctrl`+`h` \| _Clique-central_  | `Ctrl`+`h` \| _Clique-central_
- | Clicar em `BACK`                                              | `Ctrl`+`b` \| _Clique-direito²_ | `Cmd`+`b`  \| _Clique-direito²_
- | Clicar em `APP_SWITCH`                                        | `Ctrl`+`s`                      | `Cmd`+`s`
- | Clicar em `MENU`                                              | `Ctrl`+`m`                      | `Ctrl`+`m`
- | Clicar em `VOLUME_UP`                                         | `Ctrl`+`↑` _(cima)_             | `Cmd`+`↑` _(cima)_
- | Clicar em `VOLUME_DOWN`                                       | `Ctrl`+`↓` _(baixo)_            | `Cmd`+`↓` _(baixo)_
- | Clicar em `POWER`                                             | `Ctrl`+`p`                      | `Cmd`+`p`
- | Ligar                                                         | _Clique-direito²_               | _Clique-direito²_
- | Desligar a tela do dispositivo                                | `Ctrl`+`o`                      | `Cmd`+`o`
- | Rotacionar tela do dispositivo                                | `Ctrl`+`r`                      | `Cmd`+`r`
- | Expandir painel de notificação                                | `Ctrl`+`n`                      | `Cmd`+`n`
- | Esconder painel de notificação                                | `Ctrl`+`Shift`+`n`              | `Cmd`+`Shift`+`n`
- | Copiar área de transferência do dispositivo para o computador | `Ctrl`+`c`                      | `Cmd`+`c`
- | Colar área de transferência do computador para o dispositivo  | `Ctrl`+`v`                      | `Cmd`+`v`
- | Copiar área de transferência do computador para dispositivo   | `Ctrl`+`Shift`+`v`              | `Cmd`+`Shift`+`v`
- | Ativar/desativar contador de FPS(Frames por segundo)          | `Ctrl`+`i`                      | `Cmd`+`i`
-
-_¹Clique-duplo em bordas pretas para removê-las._  
-_²Botão direito liga a tela se ela estiver desligada, clique BACK para o contrário._
-
-
-## Caminhos personalizados
-
-Para usar um binário específico _adb_, configure seu caminho na variável de ambiente `ADB`:
-
-    ADB=/caminho/para/adb scrcpy
-
-Para sobrepor o caminho do arquivo `scrcpy-server`, configure seu caminho em
-`SCRCPY_SERVER_PATH`.
-
-[useful]: https://github.com/Genymobile/scrcpy/issues/278#issuecomment-429330345
-
-
-## Por quê _scrcpy_?
-
-Um colega me desafiou a encontrar um nome impronunciável como [gnirehtet].
-
-[`strcpy`] copia uma **str**ing; `scrcpy` copia uma **scr**een.
-
-[gnirehtet]: https://github.com/Genymobile/gnirehtet
-[`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html
-
-
-## Como compilar?
-
-Veja [BUILD].
-
-[BUILD]: BUILD.md
-
-
-## Problemas comuns
-
-Veja [FAQ](FAQ.md).
-
-
-## Desenvolvedores
-
-Leia a  [developers page].
-
-[developers page]: DEVELOP.md
-
-
-## Licença
-
-    Copyright (C) 2018 Genymobile
-    Copyright (C) 2018-2020 Romain Vimont
-
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-
-## Artigos
-
- [Introducing scrcpy][article-intro]
- [Scrcpy now works wirelessly][article-tcpip]
-
-[article-intro]: https://blog.rom1v.com/2018/03/introducing-scrcpy/
-[article-tcpip]: https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/
--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@ -26,12 +26,10 @@ Encode the video at the given bit\-rate, expressed in bits/s. Unit suffixes are
 Default is 8000000.

 .TP
-.BI "\-\-codec\-options " key[:type]=value[,...]
+.BI "\-\-\codec\-options " key[:type]=value[,...]
 Set a list of comma-separated key:type=value options for the device encoder.
-
 The possible values for 'type' are 'int' (default), 'long', 'float' and 'string'.
-
-The list of possible codec options is available in the Android documentation
+The list of possible codec options is available in the Android documentation:
 .UR https://d.android.com/reference/android/media/MediaFormat
 .UE .

@ -52,10 +50,6 @@ The list of possible display ids can be listed by "adb shell dumpsys display"

 Default is 0.

-.TP
-.B \-\-force\-adb\-forward
-Do not attempt to use "adb reverse" to connect to the device.
-
 .TP
 .B \-f, \-\-fullscreen
 Start in fullscreen.
@ -150,7 +144,7 @@ Turn the device screen off immediately.

 .TP
 .B \-t, \-\-show\-touches
-Enable "show touches" on start, restore the initial value on exit.
+Enable "show touches" on start, restore the initial value on exit..

 It only shows physical touches (not clicks from scrcpy).

@ -158,12 +152,6 @@ 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.
--- a/app/src/cli.c
+++ b/app/src/cli.c
@ -54,10 +54,6 @@ scrcpy_print_usage(const char *arg0) {
        "\n"
        "        Default is 0.\n"
        "\n"
-        "    --force-adb-forward\n"
-        "        Do not attempt to use \"adb reverse\" to connect to the\n"
-        "        the device.\n"
-        "\n"
        "    -f, --fullscreen\n"
        "        Start in fullscreen.\n"
        "\n"
@ -149,14 +145,6 @@ 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"
@ -445,32 +433,6 @@ parse_display_id(const char *s, uint16_t *display_id) {
    return true;
 }

-static bool
-parse_log_level(const char *s, enum sc_log_level *log_level) {
-    if (!strcmp(s, "debug")) {
-        *log_level = SC_LOG_LEVEL_DEBUG;
-        return true;
-    }
-
-    if (!strcmp(s, "info")) {
-        *log_level = SC_LOG_LEVEL_INFO;
-        return true;
-    }
-
-    if (!strcmp(s, "warn")) {
-        *log_level = SC_LOG_LEVEL_WARN;
-        return true;
-    }
-
-    if (!strcmp(s, "error")) {
-        *log_level = SC_LOG_LEVEL_ERROR;
-        return true;
-    }
-
-    LOGE("Could not parse log level: %s", s);
-    return false;
-}
-
 static bool
 parse_record_format(const char *optarg, enum recorder_format *format) {
    if (!strcmp(optarg, "mp4")) {
@ -520,7 +482,6 @@ guess_record_format(const char *filename) {
 #define OPT_RENDER_DRIVER          1016
 #define OPT_NO_MIPMAPS             1017
 #define OPT_CODEC_OPTIONS          1018
-#define OPT_FORCE_ADB_FORWARD      1019

 bool
 scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
@ -530,8 +491,6 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
        {"codec-options",          required_argument, NULL, OPT_CODEC_OPTIONS},
        {"crop",                   required_argument, NULL, OPT_CROP},
        {"display",                required_argument, NULL, OPT_DISPLAY_ID},
-        {"force-adb-forward",      no_argument,       NULL,
-                                                  OPT_FORCE_ADB_FORWARD},
        {"fullscreen",             no_argument,       NULL, 'f'},
        {"help",                   no_argument,       NULL, 'h'},
        {"lock-video-orientation", required_argument, NULL,
@ -554,7 +513,6 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
        {"show-touches",           no_argument,       NULL, 't'},
        {"stay-awake",             no_argument,       NULL, 'w'},
        {"turn-screen-off",        no_argument,       NULL, 'S'},
-        {"verbosity",              required_argument, NULL, 'V'},
        {"version",                no_argument,       NULL, 'v'},
        {"window-title",           required_argument, NULL, OPT_WINDOW_TITLE},
        {"window-x",               required_argument, NULL, OPT_WINDOW_X},
@ -571,8 +529,8 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
    optind = 0; // reset to start from the first argument in tests

    int c;
-    while ((c = getopt_long(argc, argv, "b:c:fF:hm:nNp:r:s:StTvV:w",
-                            long_options, NULL)) != -1) {
+    while ((c = getopt_long(argc, argv, "b:c:fF:hm:nNp:r:s:StTvw", long_options,
+                            NULL)) != -1) {
        switch (c) {
            case 'b':
                if (!parse_bit_rate(optarg, &opts->bit_rate)) {
@ -651,11 +609,6 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
            case 'v':
                args->version = true;
                break;
-            case 'V':
-                if (!parse_log_level(optarg, &opts->log_level)) {
-                    return false;
-                }
-                break;
            case 'w':
                opts->stay_awake = true;
                break;
@ -708,9 +661,6 @@ scrcpy_parse_args(struct scrcpy_cli_args *args, int argc, char *argv[]) {
            case OPT_CODEC_OPTIONS:
                opts->codec_options = optarg;
                break;
-            case OPT_FORCE_ADB_FORWARD:
-                opts->force_adb_forward = true;
-                break;
            default:
                // getopt prints the error message on stderr
                return false;
--- a/app/src/input_manager.c
+++ b/app/src/input_manager.c
@ -7,6 +7,33 @@
 #include "util/lock.h"
 #include "util/log.h"

+// Convert window coordinates (as provided by SDL_GetMouseState() to renderer
+// coordinates (as provided in SDL mouse events)
+//
+// See my question:
+// <https://stackoverflow.com/questions/49111054/how-to-get-mouse-position-on-mouse-wheel-event>
+static void
+convert_to_renderer_coordinates(SDL_Renderer *renderer, int *x, int *y) {
+    SDL_Rect viewport;
+    float scale_x, scale_y;
+    SDL_RenderGetViewport(renderer, &viewport);
+    SDL_RenderGetScale(renderer, &scale_x, &scale_y);
+    *x = (int) (*x / scale_x) - viewport.x;
+    *y = (int) (*y / scale_y) - viewport.y;
+}
+
+static struct point
+get_mouse_point(struct screen *screen) {
+    int x;
+    int y;
+    SDL_GetMouseState(&x, &y);
+    convert_to_renderer_coordinates(screen->renderer, &x, &y);
+    return (struct point) {
+        .x = x,
+        .y = y,
+    };
+}
+
 static const int ACTION_DOWN = 1;
 static const int ACTION_UP = 1 << 1;

@ -460,17 +487,11 @@ convert_touch(const SDL_TouchFingerEvent *from, struct screen *screen,

    to->inject_touch_event.pointer_id = from->fingerId;
    to->inject_touch_event.position.screen_size = screen->frame_size;
-
-    int ww;
-    int wh;
-    SDL_GL_GetDrawableSize(screen->window, &ww, &wh);
-
    // SDL touch event coordinates are normalized in the range [0; 1]
-    int32_t x = from->x * ww;
-    int32_t y = from->y * wh;
+    float x = from->x * screen->content_size.width;
+    float y = from->y * screen->content_size.height;
    to->inject_touch_event.position.point =
        screen_convert_to_frame_coords(screen, x, y);
-
    to->inject_touch_event.pressure = from->pressure;
    to->inject_touch_event.buttons = 0;
    return true;
@ -487,6 +508,13 @@ input_manager_process_touch(struct input_manager *im,
    }
 }

+static bool
+is_outside_device_screen(struct input_manager *im, int x, int y)
+{
+    return x < 0 || x >= im->screen->content_size.width ||
+           y < 0 || y >= im->screen->content_size.height;
+}
+
 static bool
 convert_mouse_button(const SDL_MouseButtonEvent *from, struct screen *screen,
                     struct control_msg *to) {
@ -524,15 +552,10 @@ input_manager_process_mouse_button(struct input_manager *im,
            action_home(im->controller, ACTION_DOWN | ACTION_UP);
            return;
        }
-
        // double-click on black borders resize to fit the device screen
        if (event->button == SDL_BUTTON_LEFT && event->clicks == 2) {
-            int32_t x = event->x;
-            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;
+            bool outside =
+                is_outside_device_screen(im, event->x, event->y);
            if (outside) {
                screen_resize_to_fit(im->screen);
                return;
@ -556,15 +579,9 @@ input_manager_process_mouse_button(struct input_manager *im,
 static bool
 convert_mouse_wheel(const SDL_MouseWheelEvent *from, struct screen *screen,
                    struct control_msg *to) {
-
-    // mouse_x and mouse_y are expressed in pixels relative to the window
-    int mouse_x;
-    int mouse_y;
-    SDL_GetMouseState(&mouse_x, &mouse_y);
-
    struct position position = {
        .screen_size = screen->frame_size,
-        .point = screen_convert_to_frame_coords(screen, mouse_x, mouse_y),
+        .point = get_mouse_point(screen),
    };

    to->type = CONTROL_MSG_TYPE_INJECT_SCROLL_EVENT;
--- a/app/src/main.c
+++ b/app/src/main.c
@ -29,24 +29,6 @@ print_version(void) {
                                               LIBAVUTIL_VERSION_MICRO);
 }

-static SDL_LogPriority
-convert_log_level_to_sdl(enum sc_log_level level) {
-    switch (level) {
-        case SC_LOG_LEVEL_DEBUG:
-            return SDL_LOG_PRIORITY_DEBUG;
-        case SC_LOG_LEVEL_INFO:
-            return SDL_LOG_PRIORITY_INFO;
-        case SC_LOG_LEVEL_WARN:
-            return SDL_LOG_PRIORITY_WARN;
-        case SC_LOG_LEVEL_ERROR:
-            return SDL_LOG_PRIORITY_ERROR;
-        default:
-            assert(!"unexpected log level");
-            return SC_LOG_LEVEL_INFO;
-    }
-}
-
-
 int
 main(int argc, char *argv[]) {
 #ifdef __WINDOWS__
@ -56,23 +38,20 @@ main(int argc, char *argv[]) {
    setbuf(stderr, NULL);
 #endif

+#ifndef NDEBUG
+    SDL_LogSetAllPriority(SDL_LOG_PRIORITY_DEBUG);
+#endif
+
    struct scrcpy_cli_args args = {
        .opts = SCRCPY_OPTIONS_DEFAULT,
        .help = false,
        .version = false,
    };

-#ifndef NDEBUG
-    args.opts.log_level = SC_LOG_LEVEL_DEBUG;
-#endif
-
    if (!scrcpy_parse_args(&args, argc, argv)) {
        return 1;
    }

-    SDL_LogPriority sdl_log = convert_log_level_to_sdl(args.opts.log_level);
-    SDL_LogSetAllPriority(sdl_log);
-
    if (args.help) {
        scrcpy_print_usage(argv[0]);
        return 0;
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@ -7,10 +7,6 @@
 #include <sys/time.h>
 #include <SDL2/SDL.h>

-#ifdef _WIN32
-# include <windows.h>
-#endif
-
 #include "config.h"
 #include "command.h"
 #include "common.h"
@ -49,18 +45,6 @@ static struct input_manager input_manager = {
    .prefer_text = false, // initialized later
 };

-#ifdef _WIN32
-BOOL WINAPI windows_ctrl_handler(DWORD ctrl_type) {
-    if (ctrl_type == CTRL_C_EVENT) {
-        SDL_Event event;
-        event.type = SDL_QUIT;
-        SDL_PushEvent(&event);
-        return TRUE;
-    }
-    return FALSE;
-}
-#endif // _WIN32
-
 // init SDL and set appropriate hints
 static bool
 sdl_init_and_configure(bool display, const char *render_driver) {
@ -72,14 +56,6 @@ sdl_init_and_configure(bool display, const char *render_driver) {

    atexit(SDL_Quit);

-#ifdef _WIN32
-    // Clean up properly on Ctrl+C on Windows
-    bool ok = SetConsoleCtrlHandler(windows_ctrl_handler, TRUE);
-    if (!ok) {
-        LOGW("Could not set Ctrl+C handler");
-    }
-#endif // _WIN32
-
    if (!display) {
        return true;
    }
@ -133,10 +109,10 @@ static int
 event_watcher(void *data, SDL_Event *event) {
    (void) data;
    if (event->type == SDL_WINDOWEVENT
-            && event->window.event == SDL_WINDOWEVENT_RESIZED) {
+            && event->window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
        // In practice, it seems to always be called from the same thread in
        // that specific case. Anyway, it's just a workaround.
-        screen_render(&screen, true);
+        screen_handle_window_event(&screen, &event->window);
    }
    return 0;
 }
@ -293,7 +269,6 @@ bool
 scrcpy(const struct scrcpy_options *options) {
    bool record = !!options->record_filename;
    struct server_params params = {
-        .log_level = options->log_level,
        .crop = options->crop,
        .port_range = options->port_range,
        .max_size = options->max_size,
@ -305,7 +280,6 @@ scrcpy(const struct scrcpy_options *options) {
        .show_touches = options->show_touches,
        .stay_awake = options->stay_awake,
        .codec_options = options->codec_options,
-        .force_adb_forward = options->force_adb_forward,
    };
    if (!server_start(&server, options->serial, &params)) {
        return false;
--- a/app/src/scrcpy.h
+++ b/app/src/scrcpy.h
@ -8,7 +8,6 @@
 #include "common.h"
 #include "input_manager.h"
 #include "recorder.h"
-#include "util/log.h"

 struct scrcpy_options {
    const char *serial;
@ -18,7 +17,6 @@ struct scrcpy_options {
    const char *push_target;
    const char *render_driver;
    const char *codec_options;
-    enum sc_log_level log_level;
    enum recorder_format record_format;
    struct port_range port_range;
    uint16_t max_size;
@ -42,7 +40,6 @@ struct scrcpy_options {
    bool window_borderless;
    bool mipmaps;
    bool stay_awake;
-    bool force_adb_forward;
 };

 #define SCRCPY_OPTIONS_DEFAULT { \
@ -53,7 +50,6 @@ struct scrcpy_options {
    .push_target = NULL, \
    .render_driver = NULL, \
    .codec_options = NULL, \
-    .log_level = SC_LOG_LEVEL_INFO, \
    .record_format = RECORDER_FORMAT_AUTO, \
    .port_range = { \
        .first = DEFAULT_LOCAL_PORT_RANGE_FIRST, \
@ -80,7 +76,6 @@ struct scrcpy_options {
    .window_borderless = false, \
    .mipmaps = true, \
    .stay_awake = false, \
-    .force_adb_forward = false, \
 }

 bool
--- a/app/src/screen.c
+++ b/app/src/screen.c
@ -30,10 +30,10 @@ get_rotated_size(struct size size, int rotation) {

 // get the window size in a struct size
 static struct size
-get_window_size(const struct screen *screen) {
+get_window_size(SDL_Window *window) {
    int width;
    int height;
-    SDL_GetWindowSize(screen->window, &width, &height);
+    SDL_GetWindowSize(window, &width, &height);

    struct size size;
    size.width = width;
@ -41,12 +41,31 @@ get_window_size(const struct screen *screen) {
    return size;
 }

+// get the windowed window size
+static struct size
+get_windowed_window_size(const struct screen *screen) {
+    if (screen->fullscreen || screen->maximized) {
+        return screen->windowed_window_size;
+    }
+    return get_window_size(screen->window);
+}
+
+// apply the windowed window size if fullscreen and maximized are disabled
+static void
+apply_windowed_size(struct screen *screen) {
+    if (!screen->fullscreen && !screen->maximized) {
+        SDL_SetWindowSize(screen->window, screen->windowed_window_size.width,
+                                          screen->windowed_window_size.height);
+    }
+}
+
 // set the window size to be applied when fullscreen is disabled
 static void
 set_window_size(struct screen *screen, struct size new_size) {
-    assert(!screen->fullscreen);
-    assert(!screen->maximized);
-    SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
+    // 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);
 }

 // get the preferred display bounds (i.e. the screen bounds with some margins)
@ -68,16 +87,6 @@ get_preferred_display_bounds(struct size *bounds) {
    return true;
 }

-static bool
-is_optimal_size(struct size current_size, struct size content_size) {
-    // The size is optimal if we can recompute one dimension of the current
-    // size from the other
-    return current_size.height == current_size.width * content_size.height
-                                                     / content_size.width
-        || current_size.width == current_size.height * content_size.width
-                                                     / content_size.height;
-}
-
 // return the optimal size of the window, with the following constraints:
 //  - it attempts to keep at least one dimension of the current_size (i.e. it
 //    crops the black borders)
@ -90,43 +99,47 @@ get_optimal_size(struct size current_size, struct size content_size) {
        return current_size;
    }

-    struct size window_size;
-
    struct size display_size;
+    // 32 bits because we need to multiply two 16 bits values
+    uint32_t w;
+    uint32_t h;
+
    if (!get_preferred_display_bounds(&display_size)) {
        // could not get display bounds, do not constraint the size
-        window_size.width = current_size.width;
-        window_size.height = current_size.height;
+        w = current_size.width;
+        h = current_size.height;
    } else {
-        window_size.width = MIN(current_size.width, display_size.width);
-        window_size.height = MIN(current_size.height, display_size.height);
+        w = MIN(current_size.width, display_size.width);
+        h = MIN(current_size.height, display_size.height);
    }

-    if (is_optimal_size(window_size, content_size)) {
-        return window_size;
+    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};
    }

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

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

 // same as get_optimal_size(), but read the current size from the window
 static inline struct size
 get_optimal_window_size(const struct screen *screen, struct size content_size) {
-    struct size window_size = get_window_size(screen);
-    return get_optimal_size(window_size, content_size);
+    struct size windowed_size = get_windowed_window_size(screen);
+    return get_optimal_size(windowed_size, content_size);
 }

 // initially, there is no current size, so use the frame size as current size
@ -156,43 +169,6 @@ get_initial_optimal_size(struct size content_size, uint16_t req_width,
    return window_size;
 }

-static void
-screen_update_content_rect(struct screen *screen) {
-    int dw;
-    int dh;
-    SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
-
-    struct size content_size = screen->content_size;
-    // The drawable size is the window size * the HiDPI scale
-    struct size drawable_size = {dw, dh};
-
-    SDL_Rect *rect = &screen->rect;
-
-    if (is_optimal_size(drawable_size, content_size)) {
-        rect->x = 0;
-        rect->y = 0;
-        rect->w = drawable_size.width;
-        rect->h = drawable_size.height;
-        return;
-    }
-
-    bool keep_width = content_size.width * drawable_size.height
-                    > content_size.height * drawable_size.width;
-    if (keep_width) {
-        rect->x = 0;
-        rect->w = drawable_size.width;
-        rect->h = drawable_size.width * content_size.height
-                                      / content_size.width;
-        rect->y = (drawable_size.height - rect->h) / 2;
-    } else {
-        rect->y = 0;
-        rect->h = drawable_size.height;
-        rect->w = drawable_size.height * content_size.width
-                                       / content_size.height;
-        rect->x = (drawable_size.width - rect->w) / 2;
-    }
-}
-
 void
 screen_init(struct screen *screen) {
    *screen = (struct screen) SCREEN_INITIALIZER;
@ -217,7 +193,7 @@ create_texture(struct screen *screen) {
        // Enable trilinear filtering for downscaling
        gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
                          GL_LINEAR_MIPMAP_LINEAR);
-        gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -1.f);
+        gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -.5f);

        SDL_GL_UnbindTexture(texture);
    }
@ -282,6 +258,13 @@ screen_init_rendering(struct screen *screen, const char *window_title,
    const char *renderer_name = r ? NULL : renderer_info.name;
    LOGI("Renderer: %s", renderer_name ? renderer_name : "(unknown)");

+    if (SDL_RenderSetLogicalSize(screen->renderer, content_size.width,
+                                 content_size.height)) {
+        LOGE("Could not set renderer logical size: %s", SDL_GetError());
+        screen_destroy(screen);
+        return false;
+    }
+
    // starts with "opengl"
    screen->use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
    if (screen->use_opengl) {
@ -305,7 +288,7 @@ screen_init_rendering(struct screen *screen, const char *window_title,
            LOGI("Trilinear filtering disabled");
        }
    } else {
-        LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
+        LOGW("Trilinear filtering disabled (not an OpenGL renderer)");
    }

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

-    // Reset the window size to trigger a SIZE_CHANGED event, to workaround
-    // 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);
+    screen->windowed_window_size = window_size;

    return true;
 }
@ -353,45 +331,6 @@ screen_destroy(struct screen *screen) {
    }
 }

-static void
-resize_for_content(struct screen *screen, struct size old_content_size,
-                                                 struct size new_content_size) {
-    struct size window_size = get_window_size(screen);
-    struct size target_size = {
-        .width = (uint32_t) window_size.width * new_content_size.width
-                / old_content_size.width,
-        .height = (uint32_t) window_size.height * new_content_size.height
-                / old_content_size.height,
-    };
-    target_size = get_optimal_size(target_size, new_content_size);
-    set_window_size(screen, target_size);
-}
-
-static void
-set_content_size(struct screen *screen, struct size new_content_size) {
-    if (!screen->fullscreen && !screen->maximized) {
-        resize_for_content(screen, screen->content_size, new_content_size);
-    } else if (!screen->resize_pending) {
-        // Store the windowed size to be able to compute the optimal size once
-        // fullscreen and maximized are disabled
-        screen->windowed_content_size = screen->content_size;
-        screen->resize_pending = true;
-    }
-
-    screen->content_size = new_content_size;
-}
-
-static void
-apply_pending_resize(struct screen *screen) {
-    assert(!screen->fullscreen);
-    assert(!screen->maximized);
-    if (screen->resize_pending) {
-        resize_for_content(screen, screen->windowed_content_size,
-                                   screen->content_size);
-        screen->resize_pending = false;
-    }
-}
-
 void
 screen_set_rotation(struct screen *screen, unsigned rotation) {
    assert(rotation < 4);
@ -399,15 +338,32 @@ screen_set_rotation(struct screen *screen, unsigned rotation) {
        return;
    }

+    struct size old_content_size = screen->content_size;
    struct size new_content_size =
        get_rotated_size(screen->frame_size, rotation);

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

+    struct size windowed_size = get_windowed_window_size(screen);
+    struct size target_size = {
+        .width = (uint32_t) windowed_size.width * new_content_size.width
+                / old_content_size.width,
+        .height = (uint32_t) windowed_size.height * new_content_size.height
+                / old_content_size.height,
+    };
+    target_size = get_optimal_size(target_size, new_content_size);
+    set_window_size(screen, target_size);
+
+    screen->content_size = new_content_size;
    screen->rotation = rotation;
    LOGI("Display rotation set to %u", rotation);

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

 // recreate the texture and resize the window if the frame size has changed
@ -415,16 +371,31 @@ static bool
 prepare_for_frame(struct screen *screen, struct size new_frame_size) {
    if (screen->frame_size.width != new_frame_size.width
            || screen->frame_size.height != new_frame_size.height) {
+        struct size new_content_size =
+            get_rotated_size(new_frame_size, screen->rotation);
+        if (SDL_RenderSetLogicalSize(screen->renderer,
+                                     new_content_size.width,
+                                     new_content_size.height)) {
+            LOGE("Could not set renderer logical size: %s", SDL_GetError());
+            return false;
+        }
+
        // frame dimension changed, destroy texture
        SDL_DestroyTexture(screen->texture);

+        struct size content_size = screen->content_size;
+        struct size windowed_size = get_windowed_window_size(screen);
+        struct size target_size = {
+            (uint32_t) windowed_size.width * new_content_size.width
+                    / content_size.width,
+            (uint32_t) windowed_size.height * new_content_size.height
+                    / content_size.height,
+        };
+        target_size = get_optimal_size(target_size, new_content_size);
+        set_window_size(screen, target_size);
+
        screen->frame_size = new_frame_size;
-
-        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);
+        screen->content_size = new_content_size;

        LOGI("New texture: %" PRIu16 "x%" PRIu16,
                     screen->frame_size.width, screen->frame_size.height);
@ -466,19 +437,15 @@ screen_update_frame(struct screen *screen, struct video_buffer *vb) {
    update_texture(screen, frame);
    mutex_unlock(vb->mutex);

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

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

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

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

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

 void
 screen_resize_to_fit(struct screen *screen) {
-    if (screen->fullscreen || screen->maximized) {
+    if (screen->fullscreen) {
        return;
    }

+    if (screen->maximized) {
+        SDL_RestoreWindow(screen->window);
+        screen->maximized = false;
+    }
+
    struct size optimal_size =
        get_optimal_window_size(screen, screen->content_size);
    SDL_SetWindowSize(screen->window, optimal_size.width, optimal_size.height);
@ -556,24 +524,39 @@ screen_handle_window_event(struct screen *screen,
                           const SDL_WindowEvent *event) {
    switch (event->event) {
        case SDL_WINDOWEVENT_EXPOSED:
-            screen_render(screen, true);
+            screen_render(screen);
            break;
        case SDL_WINDOWEVENT_SIZE_CHANGED:
-            screen_render(screen, true);
+            if (!screen->fullscreen && !screen->maximized) {
+                // Backup the previous size: if we receive the MAXIMIZED event,
+                // then the new size must be ignored (it's the maximized size).
+                // We could not rely on the window flags due to race conditions
+                // (they could be updated asynchronously, at least on X11).
+                screen->windowed_window_size_backup =
+                    screen->windowed_window_size;
+
+                // Save the windowed size, so that it is available once the
+                // window is maximized or fullscreen is enabled.
+                screen->windowed_window_size = get_window_size(screen->window);
+            }
+            screen_render(screen);
            break;
        case SDL_WINDOWEVENT_MAXIMIZED:
+            // The backup size must be non-nul.
+            assert(screen->windowed_window_size_backup.width);
+            assert(screen->windowed_window_size_backup.height);
+            // Revert the last size, it was updated while screen was maximized.
+            screen->windowed_window_size = screen->windowed_window_size_backup;
+#ifdef DEBUG
+            // Reset the backup to invalid values to detect unexpected usage
+            screen->windowed_window_size_backup.width = 0;
+            screen->windowed_window_size_backup.height = 0;
+#endif
            screen->maximized = true;
            break;
        case SDL_WINDOWEVENT_RESTORED:
-            if (screen->fullscreen) {
-                // On Windows, in maximized+fullscreen, disabling fullscreen
-                // mode unexpectedly triggers the "restored" then "maximized"
-                // events, leaving the window in a weird state (maximized
-                // according to the events, but not maximized visually).
-                break;
-            }
            screen->maximized = false;
-            apply_pending_resize(screen);
+            apply_windowed_size(screen);
            break;
    }
 }
@ -585,13 +568,6 @@ screen_convert_to_frame_coords(struct screen *screen, int32_t x, int32_t y) {

    int32_t w = screen->content_size.width;
    int32_t h = screen->content_size.height;
-
-    screen_hidpi_scale_coords(screen, &x, &y);
-
-    x = (int64_t) (x - screen->rect.x) * w / screen->rect.w;
-    y = (int64_t) (y - screen->rect.y) * h / screen->rect.h;
-
-    // rotate
    struct point result;
    switch (rotation) {
        case 0:
@ -614,15 +590,3 @@ screen_convert_to_frame_coords(struct screen *screen, int32_t x, int32_t y) {
    }
    return result;
 }
-
-void
-screen_hidpi_scale_coords(struct screen *screen, int32_t *x, int32_t *y) {
-    // take the HiDPI scaling (dw/ww and dh/wh) into account
-    int ww, wh, dw, dh;
-    SDL_GetWindowSize(screen->window, &ww, &wh);
-    SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
-
-    // scale for HiDPI (64 bits for intermediate multiplications)
-    *x = (int64_t) *x * dw / ww;
-    *y = (int64_t) *y * dh / wh;
-}
--- a/app/src/screen.h
+++ b/app/src/screen.h
@ -21,16 +21,13 @@ struct screen {
    struct sc_opengl gl;
    struct size frame_size;
    struct size content_size; // rotated frame_size
-
-    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;
-
+    // 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;
    // client rotation: 0, 1, 2 or 3 (x90 degrees counterclockwise)
    unsigned rotation;
-    // rectangle of the content (excluding black borders)
-    struct SDL_Rect rect;
    bool has_frame;
    bool fullscreen;
    bool maximized;
@ -52,18 +49,15 @@ struct screen {
        .width = 0, \
        .height = 0, \
    }, \
-    .resize_pending = false, \
-    .windowed_content_size = { \
+    .windowed_window_size = { \
+        .width = 0, \
+        .height = 0, \
+    }, \
+    .windowed_window_size_backup = { \
        .width = 0, \
        .height = 0, \
    }, \
    .rotation = 0, \
-    .rect = { \
-        .x = 0, \
-        .y = 0, \
-        .w = 0, \
-        .h = 0, \
-    }, \
    .has_frame = false, \
    .fullscreen = false, \
    .maximized = false, \
@ -97,11 +91,8 @@ bool
 screen_update_frame(struct screen *screen, struct video_buffer *vb);

 // render the texture to the renderer
-//
-// Set the update_content_rect flag if the window or content size may have
-// changed, so that the content rectangle is recomputed
 void
-screen_render(struct screen *screen, bool update_content_rect);
+screen_render(struct screen *screen);

 // switch the fullscreen mode
 void
@ -128,11 +119,4 @@ screen_handle_window_event(struct screen *screen, const SDL_WindowEvent *event);
 struct point
 screen_convert_to_frame_coords(struct screen *screen, int32_t x, int32_t y);

-// Convert coordinates from window to drawable.
-// Events are expressed in window coordinates, but content is expressed in
-// drawable coordinates. They are the same if HiDPI scaling is 1, but differ
-// otherwise.
-void
-screen_hidpi_scale_coords(struct screen *screen, int32_t *x, int32_t *y);
-
 #endif
--- a/app/src/server.c
+++ b/app/src/server.c
@ -217,46 +217,24 @@ enable_tunnel_forward_any_port(struct server *server,
 }

 static bool
-enable_tunnel_any_port(struct server *server, struct port_range port_range,
-                       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
-
-        LOGW("'adb reverse' failed, fallback to 'adb forward'");
+enable_tunnel_any_port(struct server *server, struct port_range port_range) {
+    if (enable_tunnel_reverse_any_port(server, port_range)) {
+        return true;
    }

+    // if "adb reverse" does not work (e.g. over "adb connect"), it fallbacks to
+    // "adb forward", so the app socket is the client
+
+    LOGW("'adb reverse' failed, fallback to 'adb forward'");
    return enable_tunnel_forward_any_port(server, port_range);
 }

-static const char *
-log_level_to_server_string(enum sc_log_level level) {
-    switch (level) {
-        case SC_LOG_LEVEL_DEBUG:
-            return "debug";
-        case SC_LOG_LEVEL_INFO:
-            return "info";
-        case SC_LOG_LEVEL_WARN:
-            return "warn";
-        case SC_LOG_LEVEL_ERROR:
-            return "error";
-        default:
-            assert(!"unexpected log level");
-            return "(unknown)";
-    }
-}
-
 static process_t
 execute_server(struct server *server, const struct server_params *params) {
    char max_size_string[6];
    char bit_rate_string[11];
    char max_fps_string[6];
-    char lock_video_orientation_string[5];
+    char lock_video_orientation_string[3];
    char display_id_string[6];
    sprintf(max_size_string, "%"PRIu16, params->max_size);
    sprintf(bit_rate_string, "%"PRIu32, params->bit_rate);
@ -281,7 +259,6 @@ execute_server(struct server *server, const struct server_params *params) {
        "/", // unused
        "com.genymobile.scrcpy.Server",
        SCRCPY_VERSION,
-        log_level_to_server_string(params->log_level),
        max_size_string,
        bit_rate_string,
        max_fps_string,
@ -389,8 +366,7 @@ server_start(struct server *server, const char *serial,
        goto error1;
    }

-    if (!enable_tunnel_any_port(server, params->port_range,
-                                params->force_adb_forward)) {
+    if (!enable_tunnel_any_port(server, params->port_range)) {
        goto error1;
    }

--- a/app/src/server.h
+++ b/app/src/server.h
@ -9,7 +9,6 @@
 #include "config.h"
 #include "command.h"
 #include "common.h"
-#include "util/log.h"
 #include "util/net.h"

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

 struct server_params {
-    enum sc_log_level log_level;
    const char *crop;
    const char *codec_options;
    struct port_range port_range;
@ -56,7 +54,6 @@ struct server_params {
    uint16_t display_id;
    bool show_touches;
    bool stay_awake;
-    bool force_adb_forward;
 };

 // init default values
--- a/app/src/util/log.h
+++ b/app/src/util/log.h
@ -3,13 +3,6 @@

 #include <SDL2/SDL_log.h>

-enum sc_log_level {
-    SC_LOG_LEVEL_DEBUG,
-    SC_LOG_LEVEL_INFO,
-    SC_LOG_LEVEL_WARN,
-    SC_LOG_LEVEL_ERROR,
-};
-
 #define LOGV(...) SDL_LogVerbose(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
 #define LOGD(...) SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
 #define LOGI(...) SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
--- a/server/src/main/aidl/android/content/IOnPrimaryClipChangedListener.aidl
+++ b/server/src/main/aidl/android/content/IOnPrimaryClipChangedListener.aidl
@ -1,24 +0,0 @@
-/**
- * Copyright (c) 2008, The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.content;
-
-/**
- * {@hide}
- */
-oneway interface IOnPrimaryClipChangedListener {
-    void dispatchPrimaryClipChanged();
-}
--- a/server/src/main/java/com/genymobile/scrcpy/ControlMessageReader.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ControlMessageReader.java
@ -15,8 +15,7 @@ public class ControlMessageReader {

    public static final int CLIPBOARD_TEXT_MAX_LENGTH = 4093;
    public static final int INJECT_TEXT_MAX_LENGTH = 300;
-
-    private static final int RAW_BUFFER_SIZE = 4096;
+    private static final int RAW_BUFFER_SIZE = 1024;

    private final byte[] rawBuffer = new byte[RAW_BUFFER_SIZE];
    private final ByteBuffer buffer = ByteBuffer.wrap(rawBuffer);
--- a/server/src/main/java/com/genymobile/scrcpy/Controller.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Controller.java
@ -1,7 +1,10 @@
 package com.genymobile.scrcpy;

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

            // dirty hack
            // After POWER is injected, the device is powered on asynchronously.
@ -107,18 +110,11 @@ public class Controller {
                sender.pushClipboardText(clipboardText);
                break;
            case ControlMessage.TYPE_SET_CLIPBOARD:
-                boolean setClipboardOk = device.setClipboardText(msg.getText());
-                if (setClipboardOk) {
-                    Ln.i("Device clipboard set");
-                }
+                device.setClipboardText(msg.getText());
                break;
            case ControlMessage.TYPE_SET_SCREEN_POWER_MODE:
                if (device.supportsInputEvents()) {
-                    int mode = msg.getAction();
-                    boolean setPowerModeOk = device.setScreenPowerMode(mode);
-                    if (setPowerModeOk) {
-                        Ln.i("Device screen turned " + (mode == Device.POWER_MODE_OFF ? "off" : "on"));
-                    }
+                    device.setScreenPowerMode(msg.getAction());
                }
                break;
            case ControlMessage.TYPE_ROTATE_DEVICE:
@ -130,7 +126,7 @@ public class Controller {
    }

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

    private boolean injectChar(char c) {
@ -141,7 +137,7 @@ public class Controller {
            return false;
        }
        for (KeyEvent event : events) {
-            if (!device.injectEvent(event)) {
+            if (!injectEvent(event)) {
                return false;
            }
        }
@ -149,10 +145,6 @@ public class Controller {
    }

    private int injectText(String text) {
-        if (device.injectTextPaste(text)) {
-            // The best method (fastest and UTF-8) worked!
-            return text.length();
-        }
        int successCount = 0;
        for (char c : text.toCharArray()) {
            if (!injectChar(c)) {
@ -201,7 +193,7 @@ public class Controller {
        MotionEvent event = MotionEvent
                .obtain(lastTouchDown, now, action, pointerCount, pointerProperties, pointerCoords, 0, buttons, 1f, 1f, DEVICE_ID_VIRTUAL, 0,
                        InputDevice.SOURCE_TOUCHSCREEN, 0);
-        return device.injectEvent(event);
+        return injectEvent(event);
    }

    private boolean injectScroll(Position position, int hScroll, int vScroll) {
@ -223,12 +215,27 @@ public class Controller {

        MotionEvent event = MotionEvent
                .obtain(lastTouchDown, now, MotionEvent.ACTION_SCROLL, 1, pointerProperties, pointerCoords, 0, 0, 1f, 1f, DEVICE_ID_VIRTUAL, 0,
-                        InputDevice.SOURCE_TOUCHSCREEN, 0);
-        return device.injectEvent(event);
+                        InputDevice.SOURCE_MOUSE, 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);
    }

    private boolean pressBackOrTurnScreenOn() {
        int keycode = device.isScreenOn() ? KeyEvent.KEYCODE_BACK : KeyEvent.KEYCODE_POWER;
-        return device.injectKeycode(keycode);
+        return injectKeycode(keycode);
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/Device.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Device.java
@ -6,18 +6,12 @@ import com.genymobile.scrcpy.wrappers.ServiceManager;
 import com.genymobile.scrcpy.wrappers.SurfaceControl;
 import com.genymobile.scrcpy.wrappers.WindowManager;

-import android.content.IOnPrimaryClipChangedListener;
 import android.graphics.Rect;
 import android.os.Build;
 import android.os.IBinder;
-import android.os.SystemClock;
+import android.os.RemoteException;
 import android.view.IRotationWatcher;
-import android.view.InputDevice;
 import android.view.InputEvent;
-import android.view.KeyCharacterMap;
-import android.view.KeyEvent;
-
-import java.util.concurrent.atomic.AtomicBoolean;

 public final class Device {

@ -28,16 +22,10 @@ public final class Device {
        void onRotationChanged(int rotation);
    }

-    public interface ClipboardListener {
-        void onClipboardTextChanged(String text);
-    }
-
    private final ServiceManager serviceManager = new ServiceManager();

    private ScreenInfo screenInfo;
    private RotationListener rotationListener;
-    private ClipboardListener clipboardListener;
-    private final AtomicBoolean isSettingClipboard = new AtomicBoolean();

    /**
     * Logical display identifier
@ -64,9 +52,9 @@ public final class Device {
        screenInfo = ScreenInfo.computeScreenInfo(displayInfo, options.getCrop(), options.getMaxSize(), options.getLockedVideoOrientation());
        layerStack = displayInfo.getLayerStack();

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

@ -78,27 +66,6 @@ public final class Device {
            }
        }, displayId);

-        if (options.getControl()) {
-            // If control is enabled, synchronize Android clipboard to the computer automatically
-            serviceManager.getClipboardManager().addPrimaryClipChangedListener(new IOnPrimaryClipChangedListener.Stub() {
-                @Override
-                public void dispatchPrimaryClipChanged() {
-                    if (isSettingClipboard.get()) {
-                        // This is a notification for the change we are currently applying, ignore it
-                        return;
-                    }
-                    synchronized (Device.this) {
-                        if (clipboardListener != null) {
-                            String text = getClipboardText();
-                            if (text != null) {
-                                clipboardListener.onClipboardTextChanged(text);
-                            }
-                        }
-                    }
-                }
-            });
-        }
-
        if ((displayInfoFlags & DisplayInfo.FLAG_SUPPORTS_PROTECTED_BUFFERS) == 0) {
            Ln.w("Display doesn't have FLAG_SUPPORTS_PROTECTED_BUFFERS flag, mirroring can be restricted");
        }
@ -151,7 +118,7 @@ public final class Device {
        return supportsInputEvents;
    }

-    public boolean injectEvent(InputEvent inputEvent, int mode) {
+    public boolean injectInputEvent(InputEvent inputEvent, int mode) {
        if (!supportsInputEvents()) {
            throw new AssertionError("Could not inject input event if !supportsInputEvents()");
        }
@ -163,60 +130,16 @@ public final class Device {
        return serviceManager.getInputManager().injectInputEvent(inputEvent, mode);
    }

-    public boolean injectEvent(InputEvent event) {
-        return injectEvent(event, InputManager.INJECT_INPUT_EVENT_MODE_ASYNC);
-    }
-
-    public boolean injectKeyEvent(int action, int keyCode, int repeat, int metaState, int mode) {
-        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, mode);
-    }
-
-    public boolean injectKeyEvent(int action, int keyCode, int repeat, int metaState) {
-        return injectKeyEvent(action, keyCode, repeat, metaState, InputManager.INJECT_INPUT_EVENT_MODE_ASYNC);
-    }
-
-    public boolean injectKeycode(int keyCode, int mode) {
-        return injectKeyEvent(KeyEvent.ACTION_DOWN, keyCode, 0, 0) && injectKeyEvent(KeyEvent.ACTION_UP, keyCode, 0, 0, mode);
-    }
-
-    public boolean injectKeycode(int keyCode) {
-        return injectKeycode(keyCode, InputManager.INJECT_INPUT_EVENT_MODE_ASYNC);
-    }
-
-    public boolean injectTextPaste(String text) {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
-            return false;
-        }
-
-        // On Android >= 7, we can inject UTF-8 text as follow:
-        // - set the clipboard
-        // - inject the PASTE key event
-        // - restore the clipboard
-
-        String clipboardBackup = getClipboardText();
-        isSettingClipboard.set(true);
-
-        rawSetClipboardText(text);
-        boolean ok = injectKeycode(KeyEvent.KEYCODE_PASTE, InputManager.INJECT_INPUT_EVENT_MODE_WAIT_FOR_RESULT);
-        rawSetClipboardText(clipboardBackup);
-
-        isSettingClipboard.set(false);
-        return ok;
-    }
-
    public boolean isScreenOn() {
        return serviceManager.getPowerManager().isScreenOn();
    }

-    public synchronized void setRotationListener(RotationListener rotationListener) {
-        this.rotationListener = rotationListener;
+    public void registerRotationWatcher(IRotationWatcher rotationWatcher, int displayId) {
+        serviceManager.getWindowManager().registerRotationWatcher(rotationWatcher, displayId);
    }

-    public synchronized void setClipboardListener(ClipboardListener clipboardListener) {
-        this.clipboardListener = clipboardListener;
+    public synchronized void setRotationListener(RotationListener rotationListener) {
+        this.rotationListener = rotationListener;
    }

    public void expandNotificationPanel() {
@ -235,27 +158,26 @@ public final class Device {
        return s.toString();
    }

-    private boolean rawSetClipboardText(String text) {
-        return serviceManager.getClipboardManager().setText(text);
-    }
-
-    public boolean setClipboardText(String text) {
-        isSettingClipboard.set(true);
-        boolean ok = rawSetClipboardText(text);
-        isSettingClipboard.set(false);
-        return ok;
+    public void setClipboardText(String text) {
+        boolean ok = serviceManager.getClipboardManager().setText(text);
+        if (ok) {
+            Ln.i("Device clipboard set");
+        }
    }

    /**
     * @param mode one of the {@code SCREEN_POWER_MODE_*} constants
     */
-    public boolean setScreenPowerMode(int mode) {
+    public void setScreenPowerMode(int mode) {
        IBinder d = SurfaceControl.getBuiltInDisplay();
        if (d == null) {
            Ln.e("Could not get built-in display");
-            return false;
+            return;
+        }
+        boolean ok = SurfaceControl.setDisplayPowerMode(d, mode);
+        if (ok) {
+            Ln.i("Device screen turned " + (mode == Device.POWER_MODE_OFF ? "off" : "on"));
        }
-        return SurfaceControl.setDisplayPowerMode(d, mode);
    }

    /**
--- a/server/src/main/java/com/genymobile/scrcpy/Ln.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Ln.java
@ -15,25 +15,14 @@ public final class Ln {
        DEBUG, INFO, WARN, ERROR
    }

-    private static Level threshold;
+    private static final Level THRESHOLD = BuildConfig.DEBUG ? Level.DEBUG : Level.INFO;

    private Ln() {
        // not instantiable
    }

-    /**
-     * Initialize the log level.
-     * <p>
-     * Must be called before starting any new thread.
-     *
-     * @param level the log level
-     */
-    public static void initLogLevel(Level level) {
-        threshold = level;
-    }
-
    public static boolean isEnabled(Level level) {
-        return level.ordinal() >= threshold.ordinal();
+        return level.ordinal() >= THRESHOLD.ordinal();
    }

    public static void d(String message) {
--- a/server/src/main/java/com/genymobile/scrcpy/Options.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Options.java
@ -3,7 +3,6 @@ package com.genymobile.scrcpy;
 import android.graphics.Rect;

 public class Options {
-    private Ln.Level logLevel;
    private int maxSize;
    private int bitRate;
    private int maxFps;
@ -17,14 +16,6 @@ public class Options {
    private boolean stayAwake;
    private String codecOptions;

-    public Ln.Level getLogLevel() {
-        return logLevel;
-    }
-
-    public void setLogLevel(Ln.Level logLevel) {
-        this.logLevel = logLevel;
-    }
-
    public int getMaxSize() {
        return maxSize;
    }
--- a/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
@ -64,7 +64,7 @@ public class ScreenEncoder implements Device.RotationListener {
    }

    private void internalStreamScreen(Device device, FileDescriptor fd) throws IOException {
-        MediaFormat format = createFormat(bitRate, maxFps, codecOptions);
+        MediaFormat format = createFormat(bitRate, maxFps, DEFAULT_I_FRAME_INTERVAL, codecOptions);
        device.setRotationListener(this);
        boolean alive;
        try {
@ -171,14 +171,14 @@ public class ScreenEncoder implements Device.RotationListener {
        Ln.d("Codec option set: " + key + " (" + value.getClass().getSimpleName() + ") = " + value);
    }

-    private static MediaFormat createFormat(int bitRate, int maxFps, List<CodecOption> codecOptions) {
+    private static MediaFormat createFormat(int bitRate, int maxFps, int iFrameInterval, List<CodecOption> codecOptions) {
        MediaFormat format = new MediaFormat();
        format.setString(MediaFormat.KEY_MIME, MediaFormat.MIMETYPE_VIDEO_AVC);
        format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
        // must be present to configure the encoder, but does not impact the actual frame rate, which is variable
        format.setInteger(MediaFormat.KEY_FRAME_RATE, 60);
        format.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
-        format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, DEFAULT_I_FRAME_INTERVAL);
+        format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, iFrameInterval);
        // display the very first frame, and recover from bad quality when no new frames
        format.setLong(MediaFormat.KEY_REPEAT_PREVIOUS_FRAME_AFTER, REPEAT_FRAME_DELAY_US); // µs
        if (maxFps > 0) {
--- a/server/src/main/java/com/genymobile/scrcpy/Server.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Server.java
@ -9,7 +9,6 @@ import android.os.Build;

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

 public final class Server {

@ -57,18 +56,11 @@ public final class Server {
            ScreenEncoder screenEncoder = new ScreenEncoder(options.getSendFrameMeta(), options.getBitRate(), options.getMaxFps(), codecOptions);

            if (options.getControl()) {
-                final Controller controller = new Controller(device, connection);
+                Controller controller = new Controller(device, connection);

                // asynchronous
                startController(controller);
                startDeviceMessageSender(controller.getSender());
-
-                device.setClipboardListener(new Device.ClipboardListener() {
-                    @Override
-                    public void onClipboardTextChanged(String text) {
-                        controller.getSender().pushClipboardText(text);
-                    }
-                });
            }

            try {
@ -120,51 +112,48 @@ public final class Server {
                    "The server version (" + BuildConfig.VERSION_NAME + ") does not match the client " + "(" + clientVersion + ")");
        }

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

        Options options = new Options();

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

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

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

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

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

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

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

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

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

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

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

-        String codecOptions = args[13];
+        String codecOptions = args[12];
        options.setCodecOptions(codecOptions);

        return options;
@ -219,9 +208,6 @@ public final class Server {
        });

        Options options = createOptions(args);
-
-        Ln.initLogLevel(options.getLogLevel());
-
        scrcpy(options);
    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/wrappers/ClipboardManager.java
+++ b/server/src/main/java/com/genymobile/scrcpy/wrappers/ClipboardManager.java
@ -3,7 +3,6 @@ package com.genymobile.scrcpy.wrappers;
 import com.genymobile.scrcpy.Ln;

 import android.content.ClipData;
-import android.content.IOnPrimaryClipChangedListener;
 import android.os.Build;
 import android.os.IInterface;

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

    public ClipboardManager(IInterface manager) {
        this.manager = manager;
@ -83,37 +81,4 @@ public class ClipboardManager {
            return false;
        }
    }
-
-    private static void addPrimaryClipChangedListener(Method method, IInterface manager, IOnPrimaryClipChangedListener listener)
-            throws InvocationTargetException, IllegalAccessException {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-            method.invoke(manager, listener, ServiceManager.PACKAGE_NAME);
-        } else {
-            method.invoke(manager, listener, ServiceManager.PACKAGE_NAME, ServiceManager.USER_ID);
-        }
-    }
-
-    private Method getAddPrimaryClipChangedListener() throws NoSuchMethodException {
-        if (addPrimaryClipChangedListener == null) {
-            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-                addPrimaryClipChangedListener = manager.getClass()
-                        .getMethod("addPrimaryClipChangedListener", IOnPrimaryClipChangedListener.class, String.class);
-            } else {
-                addPrimaryClipChangedListener = manager.getClass()
-                        .getMethod("addPrimaryClipChangedListener", IOnPrimaryClipChangedListener.class, String.class, int.class);
-            }
-        }
-        return addPrimaryClipChangedListener;
-    }
-
-    public boolean addPrimaryClipChangedListener(IOnPrimaryClipChangedListener listener) {
-        try {
-            Method method = getAddPrimaryClipChangedListener();
-            addPrimaryClipChangedListener(method, manager, listener);
-            return true;
-        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
-            Ln.e("Could not invoke method", e);
-            return false;
-        }
-    }
 }
--- a/server/src/test/java/com/genymobile/scrcpy/CodecOptionsTest.java
+++ b/server/src/test/java/com/genymobile/scrcpy/CodecOptionsTest.java
@ -1,10 +1,10 @@
 package com.genymobile.scrcpy;

+import java.util.List;
+
 import org.junit.Assert;
 import org.junit.Test;

-import java.util.List;
-
 public class CodecOptionsTest {

    @Test
--- a/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java
+++ b/server/src/test/java/com/genymobile/scrcpy/ControlMessageReaderTest.java
@ -229,30 +229,6 @@ public class ControlMessageReaderTest {
        Assert.assertEquals("testé", event.getText());
    }

-    @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];
-        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());
-    }
-
    @Test
    public void testParseSetScreenPowerMode() throws IOException {
        ControlMessageReader reader = new ControlMessageReader();