Implement audio forwarding

Use Android Open Accessory 2 to redirect the device audio output to the computer, creating a new audio input source. Record this new source and play it to the default output. <https://source.android.com/devices/accessories/aoa2#audio-support>
Expose functions to get device serial and model
2018-04-12 13:33:17 +02:00 · 2018-04-12 13:32:32 +02:00 · 2018-04-12 13:32:32 +02:00 · 2018-04-08 12:41:51 +02:00 · 2018-04-08 12:40:05 +02:00 · 2018-04-05 02:03:26 +02:00
44 changed files with 1692 additions and 377 deletions
--- a/DEVELOP.md
+++ b/DEVELOP.md
@@ -32,7 +32,7 @@ The server is a Java application (with a [`public static void main(String...
 args)`][main] method), compiled against the Android framework, and executed as
 `shell` on the Android device.

-[main]: server/src/main/java/com/genymobile/scrcpy/Server.java#L61
+[main]: https://github.com/Genymobile/scrcpy/blob/v1.0/server/src/main/java/com/genymobile/scrcpy/Server.java#L61

 To run such a Java application, the classes must be [_dexed_][dex] (typically,
 to `classes.dex`). If `my.package.MainClass` is the main class, compiled to
@@ -57,7 +57,7 @@ build system, the server is built to an (unsigned) APK (renamed to

 ### Hidden methods

-Albeit compiled against the Android framework, [hidden] methods and classes are
+Although compiled against the Android framework, [hidden] methods and classes are
 not directly accessible (and they may differ from one Android version to
 another).

@@ -65,8 +65,8 @@ They can be called using reflection though. The communication with hidden
 components is provided by [_wrappers_ classes][wrappers] and [aidl].

 [hidden]: https://stackoverflow.com/a/31908373/1987178
-[wrappers]: https://github.com/Genymobile/scrcpy/blob/079d750d41b7849eb1b9caaa6151ef2429581584/server/src/main/java/com/genymobile/scrcpy/wrappers
-[aidl]: https://github.com/Genymobile/scrcpy/blob/079d750d41b7849eb1b9caaa6151ef2429581584/server/src/main/aidl/android/view
+[wrappers]: https://github.com/Genymobile/scrcpy/blob/v1.0/server/src/main/java/com/genymobile/scrcpy/wrappers
+[aidl]: https://github.com/Genymobile/scrcpy/blob/v1.0/server/src/main/aidl/android/view


 ### Threading
@@ -89,9 +89,9 @@ The video is encoded using the [`MediaCodec`] API. The codec takes its input
 from a [surface] associated to the display, and writes the resulting H.264
 stream to the provided output stream (the socket connected to the client).

-[`ScreenEncoder`]: https://github.com/Genymobile/scrcpy/blob/079d750d41b7849eb1b9caaa6151ef2429581584/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
+[`ScreenEncoder`]: https://github.com/Genymobile/scrcpy/blob/v1.0/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java
 [`MediaCodec`]: https://developer.android.com/reference/android/media/MediaCodec.html
-[surface]: https://github.com/Genymobile/scrcpy/blob/079d750d41b7849eb1b9caaa6151ef2429581584/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L63-L64
+[surface]: https://github.com/Genymobile/scrcpy/blob/v1.0/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L63-L64

 On device [rotation], the codec, surface and display are reinitialized, and a
 new video stream is produced.
@@ -105,8 +105,8 @@ because it avoids to send unnecessary frames, but there are drawbacks:
 Both problems are [solved][repeat] by the flag
 [`KEY_REPEAT_PREVIOUS_FRAME_AFTER`][repeat-flag].

-[rotation]: https://github.com/Genymobile/scrcpy/blob/079d750d41b7849eb1b9caaa6151ef2429581584/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L89-L92
-[repeat]: https://github.com/Genymobile/scrcpy/blob/079d750d41b7849eb1b9caaa6151ef2429581584/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L125-L126
+[rotation]: https://github.com/Genymobile/scrcpy/blob/v1.0/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L89-L92
+[repeat]: https://github.com/Genymobile/scrcpy/blob/v1.0/server/src/main/java/com/genymobile/scrcpy/ScreenEncoder.java#L125-L126
 [repeat-flag]: https://developer.android.com/reference/android/media/MediaFormat.html#KEY_REPEAT_PREVIOUS_FRAME_AFTER


@@ -124,11 +124,11 @@ All of them may need to inject input events to the system. To do so, they use
 the _hidden_ method [`InputManager.injectInputEvent`] (exposed by our
 [`InputManager` wrapper][inject-wrapper]).

-[`EventController`]: https://github.com/Genymobile/scrcpy/blob/079d750d41b7849eb1b9caaa6151ef2429581584/server/src/main/java/com/genymobile/scrcpy/EventController.java#L70
+[`EventController`]: https://github.com/Genymobile/scrcpy/blob/v1.0/server/src/main/java/com/genymobile/scrcpy/EventController.java#L70
 [`KeyEvent`]: https://developer.android.com/reference/android/view/KeyEvent.html
 [`MotionEvent`]: https://developer.android.com/reference/android/view/MotionEvent.html
 [`InputManager.injectInputEvent`]: https://android.googlesource.com/platform/frameworks/base/+/oreo-release/core/java/android/hardware/input/InputManager.java#857
-[inject-wrapper]: https://github.com/Genymobile/scrcpy/blob/079d750d41b7849eb1b9caaa6151ef2429581584/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java#L27
+[inject-wrapper]: https://github.com/Genymobile/scrcpy/blob/v1.0/server/src/main/java/com/genymobile/scrcpy/wrappers/InputManager.java#L27



@@ -195,8 +195,8 @@ When a new decoded frame is available, the decoder _swaps_ the decoding and
 rendering frame (with proper synchronization). Thus, it immediatly starts
 to decode a new frame while the main thread renders the last one.

-[decoder]: https://github.com/Genymobile/scrcpy/blob/079d750d41b7849eb1b9caaa6151ef2429581584/app/src/decoder.c
-[frames]: https://github.com/Genymobile/scrcpy/blob/079d750d41b7849eb1b9caaa6151ef2429581584/app/src/frames.h
+[decoder]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/decoder.c
+[frames]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/frames.h


 ### Controller
@@ -211,10 +211,10 @@ events_ to a blocking queue hold by the controller. On its own thread, the
 controller takes events from the queue, that it serializes and sends to the
 client.

-[controller]: https://github.com/Genymobile/scrcpy/blob/079d750d41b7849eb1b9caaa6151ef2429581584/app/src/controller.h
-[controlevent]: https://github.com/Genymobile/scrcpy/blob/079d750d41b7849eb1b9caaa6151ef2429581584/app/src/controlevent.h
-[inputmanager]: https://github.com/Genymobile/scrcpy/blob/079d750d41b7849eb1b9caaa6151ef2429581584/app/src/inputmanager.h
-[convert]: https://github.com/Genymobile/scrcpy/blob/079d750d41b7849eb1b9caaa6151ef2429581584/app/src/convert.h
+[controller]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/controller.h
+[controlevent]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/controlevent.h
+[inputmanager]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/inputmanager.h
+[convert]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/convert.h


 ### UI and event loop
@@ -225,9 +225,9 @@ thread.
 Events are handled in the [event loop], which either updates the [screen] or
 delegates to the [input manager][inputmanager].

-[scrcpy]: https://github.com/Genymobile/scrcpy/blob/079d750d41b7849eb1b9caaa6151ef2429581584/app/src/scrcpy.c
-[event loop]: https://github.com/Genymobile/scrcpy/blob/079d750d41b7849eb1b9caaa6151ef2429581584/app/src/scrcpy.c#L38
-[screen]: https://github.com/Genymobile/scrcpy/blob/079d750d41b7849eb1b9caaa6151ef2429581584/app/src/screen.h
+[scrcpy]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/scrcpy.c
+[event loop]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/scrcpy.c#L38
+[screen]: https://github.com/Genymobile/scrcpy/blob/v1.0/app/src/screen.h


 ## Hack
--- a/FAQ.md
+++ b/FAQ.md
@@ -0,0 +1,90 @@
+# Frequently Asked Questions
+
+## Common issues
+
+The application is very young, it is not unlikely that you encounter problems
+with it.
+
+Here are the common reported problems and their status.
+
+### On Windows, I have no output in the console
+
+When run in `cmd.exe`, the application does not print anything. Even `scrcpy
+--help` have no output. We don't know why yet.
+
+However, if you run the very same `scrcpy.exe` from
+[MSYS2](https://www.msys2.org/) (`mingw64`), then it correctly prints output.
+
+As a workaround, redirect outputs to files, so that you can read the files
+afterwards:
+
+```bash
+scrcpy >stdout 2>stderr
+type stdout
+type stderr
+```
+
+_Note that all SDL logs are printed to stderr._
+
+
+### On Windows, when I start the application, nothing happens
+
+The previous problem does not help to get a clue about the cause.
+
+The most common is your device not being detected by `adb`, or is unauthorized.
+Check everything is ok by calling:
+
+    adb devices
+
+Windows may need some [drivers] to detect your device.
+
+[drivers]: https://developer.android.com/studio/run/oem-usb.html
+
+If you still encounter problems, please see [issue 9].
+
+[issue 9]: https://github.com/Genymobile/scrcpy/issues/9
+
+
+### I get a black screen for some applications like Silence
+
+This is expected, they requested to protect the screen.
+
+In [Silence], you can disable it in settings → Privacy → Screen security.
+
+[silence]: https://f-droid.org/en/packages/org.smssecure.smssecure/
+
+See [issue 36].
+
+[issue 36]: https://github.com/Genymobile/scrcpy/issues/36
+
+
+### Mouse clicks do not work
+
+On some devices, you may need to enable an option to allow [simulating input].
+
+[simulating input]: https://github.com/Genymobile/scrcpy/issues/70#issuecomment-373286323
+
+
+### Mouse clicks at wrong location
+
+On MacOS, with HiDPI support and multiple screens, input location are wrongly
+scaled. See [issue 15].
+
+[issue 15]: https://github.com/Genymobile/scrcpy/issues/15
+
+A workaround is to build with HiDPI support disabled:
+
+```bash
+meson x --buildtype release -Dhidpi_support=false
+```
+
+However, the video will be displayed at lower resolution.
+
+
+### KWin compositor crashes
+
+On Plasma Desktop, compositor is disabled while _scrcpy_ is running.
+
+As a workaround, [disable "Block compositing"][kwin].
+
+[kwin]: https://github.com/Genymobile/scrcpy/issues/114#issuecomment-378778613
--- a/3
+++ b/3
@@ -9,6 +9,9 @@
 #
 # "make release-portable" builds a zip containing the client and the server.
 #
+# On Windows with MSYS2/mingw64, execute:
+#     GRADLE="$PWD/gradlew" mingw32-make release-portable
+#
 # This is a simple Makefile because Meson is not flexible enough to execute some
 # arbitrary commands.

--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@

 This application provides display and control of Android devices connected on
 USB. It does not require any _root_ access. It works on _GNU/Linux_, _Windows_
-and _Mac OS_.
+and _MacOS_.

 ![screenshot](assets/screenshot-debian-600.jpg)

@@ -11,25 +11,27 @@ and _Mac OS_.

 The Android part requires at least API 21 (Android 5.0).

-You need [adb] (recent enough so that `adb reverse` is implemented, it works
-with 1.0.36). It is available in the [Android SDK platform
-tools][platform-tools], on packaged in your distribution (`android-adb-tools`).
+You need [adb]. It is available in the [Android SDK platform
+tools][platform-tools], or packaged in your distribution (`android-adb-tools`).

-On Windows, just download the [platform-tools][platform-tools-windows] and
-extract the following files to a directory accessible from your `PATH`:
+On Windows, if you use the [prebuilt application](#windows), it is already
+included. Otherwise, just download the [platform-tools][platform-tools-windows]
+and extract the following files to a directory accessible from your `PATH`:
 - `adb.exe`
 - `AdbWinApi.dll`
 - `AdbWinUsbApi.dll`

 Make sure you [enabled adb debugging][enable-adb] on your device(s).

+The client requires [FFmpeg], [LibSDL2] and [LibUSB].
+
 [adb]: https://developer.android.com/studio/command-line/adb.html
 [enable-adb]: https://developer.android.com/studio/command-line/adb.html#Enabling
 [platform-tools]: https://developer.android.com/studio/releases/platform-tools.html
 [platform-tools-windows]: https://dl.google.com/android/repository/platform-tools-latest-windows.zip
-
-The client requires _FFmpeg_ and _LibSDL2_.
-
+[ffmpeg]: https://en.wikipedia.org/wiki/FFmpeg
+[libsdl2]: https://en.wikipedia.org/wiki/Simple_DirectMedia_Layer
+[libusb]: https://en.wikipedia.org/wiki/Libusb

 ## Build and install

@@ -37,61 +39,131 @@ The client requires _FFmpeg_ and _LibSDL2_.

 #### Linux

-Install the required packages from your package manager (here, for Debian):
+Install the required packages from your package manager.

-    # runtime dependencies
-    sudo apt install ffmpeg libsdl2-2.0.0
+##### Debian/Ubuntu

-    # build dependencies
-    sudo apt install make gcc openjdk-8-jdk pkg-config meson zip \
-                     libavcodec-dev libavformat-dev libavutil-dev \
-                     libsdl2-dev
+```bash
+# runtime dependencies
+sudo apt install ffmpeg libsdl2-2.0.0 libusb-1.0-0
+
+# client build dependencies
+sudo apt install make gcc pkg-config meson \
+                 libavcodec-dev libavformat-dev libavutil-dev \
+                 libsdl2-dev libusb-1.0-0-dev
+
+# server build dependencies
+sudo apt install openjdk-8-jdk
+```
+
+##### Fedora
+
+```bash
+# enable RPM fusion free
+sudo dnf install https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm
+
+# client build dependencies
+sudo dnf install SDL2-devel ffms2-devel meson gcc make
+
+# server build dependencies
+sudo dnf install java
+```
+
+##### Arch Linux
+
+Two [AUR] packages have been created by users:
+
+ - [`scrcpy`](https://aur.archlinux.org/packages/scrcpy/)
+ - [`scrcpy-prebuiltserver`](https://aur.archlinux.org/packages/scrcpy-prebuiltserver/)
+
+[AUR]: https://wiki.archlinux.org/index.php/Arch_User_Repository


 #### Windows

-For Windows, for simplicity, a prebuilt package with all the dependencies
-(including `adb`) is available: TODO.
+For Windows, for simplicity, a prebuilt archive with all the dependencies
+(including `adb`) is available:
+
+ - [`scrcpy-windows-with-deps-v1.1.zip`][direct-windows-with-deps].  
+   _(SHA-256: 27eb36c15937601d1062c1dc0b45faae0e06fefea2019aadeb4fa7f76a07bb4c)_
+
+[direct-windows-with-deps]: https://github.com/Genymobile/scrcpy/releases/download/v1.1/scrcpy-windows-with-deps-v1.1.zip
+
+_(It's just a portable version including _dll_ copied from MSYS2.)_

 Instead, you may want to build it manually. You need [MSYS2] to build the
 project. From an MSYS2 terminal, install the required packages:

 [MSYS2]: http://www.msys2.org/

-    # runtime dependencies
-    pacman -S mingw-w64-x86_64-SDL2 \
-              mingw-w64-x86_64-ffmpeg
+```bash
+# runtime dependencies
+pacman -S mingw-w64-x86_64-SDL2 \
+          mingw-w64-x86_64-ffmpeg

-    # build dependencies
-    pacman -S mingw-w64-x86_64-make \
-              mingw-w64-x86_64-gcc \
-              mingw-w64-x86_64-pkg-config \
-              mingw-w64-x86_64-meson \
-              zip
+# client build dependencies
+pacman -S mingw-w64-x86_64-make \
+          mingw-w64-x86_64-gcc \
+          mingw-w64-x86_64-pkg-config \
+          mingw-w64-x86_64-meson \
+          mingw-w64-x86_64-libusb
+```
+
+For a 32 bits version, replace `x86_64` by `i686`:
+
+```bash
+# runtime dependencies
+pacman -S mingw-w64-i686-SDL2 \
+          mingw-w64-i686-ffmpeg
+
+# client build dependencies
+pacman -S mingw-w64-i686-make \
+          mingw-w64-i686-gcc \
+          mingw-w64-i686-pkg-config \
+          mingw-w64-i686-meson
+```

 Java (>= 7) is not available in MSYS2, so if you plan to build the server,
 install it manually and make it available from the `PATH`:

-    export PATH="$JAVA_HOME/bin:$PATH"
-
+```bash
+export PATH="$JAVA_HOME/bin:$PATH"
+```

 #### Mac OS

-Use [Homebrew] to install the packages:
+The application is available in [Homebrew]. Just install it:

 [Homebrew]: https://brew.sh/

-    # runtime dependencies
-    brew install sdl2 ffmpeg
+```bash
+brew install scrcpy
+```

-    # build dependencies
-    brew install gcc pkg-config meson zip
+Instead, you may want to build it manually. Install the packages:

-Java (>= 7) is not available in Homebrew, so if you plan to build the server,
-install it manually and make it available from the `PATH`:

-    export PATH="$JAVA_HOME/bin:$PATH"
+```bash
+# runtime dependencies
+brew install sdl2 ffmpeg

+# client build dependencies
+brew install pkg-config meson libusb
+```
+
+Additionally, if you want to build the server, install Java 8 from Caskroom, and
+make it avaliable from the `PATH`:
+
+```bash
+brew tap caskroom/versions
+brew cask install java8
+export JAVA_HOME="$(/usr/libexec/java_home --version 1.8)"
+export PATH="$JAVA_HOME/bin:$PATH"
+```
+
+#### Docker
+
+See [pierlon/scrcpy-docker](https://github.com/pierlon/scrcpy-docker).

 ### Common steps

@@ -100,21 +172,36 @@ its directory. For example:

 [Android SDK]: https://developer.android.com/studio/index.html

-    export ANDROID_HOME=~/android/sdk
+```bash
+export ANDROID_HOME=~/android/sdk
+```

-Then, build `scrcpy`:
+Clone the project:

-    meson x --buildtype release --strip -Db_lto=true
-    cd x
-    ninja
+```bash
+git clone https://github.com/Genymobile/scrcpy
+cd scrcpy
+```
+
+Then, build:
+
+```bash
+meson x --buildtype release --strip -Db_lto=true
+cd x
+ninja
+```

 You can test it from here:

-    ninja run
+```bash
+ninja run
+```

 Or you can install it on the system:

-    sudo ninja install    # without sudo on Windows
+```bash
+sudo ninja install    # without sudo on Windows
+```

 This installs two files:

@@ -128,19 +215,25 @@ Just remove them to "uninstall" the application.

 Since the server binary, that will be pushed to the Android device, does not
 depend on your system and architecture, you may want to use the prebuilt binary
-instead: [`scrcpy-server.jar`](TODO).
+instead:
+
+ - [`scrcpy-server-v1.1.jar`][direct-scrcpy-server].  
+   _(SHA-256: 14826512bf38447ec94adf3b531676ce038d19e7e06757fb4e537882b17e77b3)_
+
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.1/scrcpy-server-v1.1.jar

 In that case, the build does not require Java or the Android SDK.

 Download the prebuilt server somewhere, and specify its path during the Meson
 configuration:

-    meson x --buildtype release --strip -Db_lto=true \
-        -Dprebuilt_server=/path/to/scrcpy-server.jar
-    cd x
-    ninja
-    sudo ninja install
-
+```bash
+meson x --buildtype release --strip -Db_lto=true \
+    -Dprebuilt_server=/path/to/scrcpy-server.jar
+cd x
+ninja
+sudo ninja install
+```

 ## Run

@@ -148,41 +241,76 @@ _At runtime, `adb` must be accessible from your `PATH`._

 If everything is ok, just plug an Android device, and execute:

-    scrcpy
+```bash
+scrcpy
+```

 It accepts command-line arguments, listed by:

-    scrcpy --help
+```bash
+scrcpy --help
+```

 For example, to decrease video bitrate to 2Mbps (default is 8Mbps):

-    scrcpy -b 2M
+```bash
+scrcpy -b 2M
+```

 To limit the video dimensions (e.g. if the device is 2540×1440, but the host
 screen is smaller, or cannot decode such a high definition):

-    scrcpy -m 1024
+```bash
+scrcpy -m 1024
+```

 If several devices are listed in `adb devices`, you must specify the _serial_:

-    scrcpy -s 0123456789abcdef
+```bash
+scrcpy -s 0123456789abcdef
+```
+
+To show physical touches while scrcpy is running:
+
+```bash
+scrcpy -t
+```
+
+To enable audio forwarding:
+
+```bash
+scrcpy -a
+```
+
+To run without installing:
+
+```bash
+./run x [options]
+```
+
+(where `x` is your build directory).


 ## Shortcuts

- | Action                                 |   Shortcut    |
- | -------------------------------------  | -------------:|
- | switch fullscreen mode                 | `Ctrl`+`f`    |
- | resize window to 1:1 (pixel-perfect)   | `Ctrl`+`g`    |
- | resize window to remove black borders  | `Ctrl`+`x`    |
- | click on `HOME`                        | `Ctrl`+`h`    |
- | click on `BACK`                        | `Ctrl`+`b`    |
- | click on `APP_SWITCH`                  | `Ctrl`+`m`    |
- | click on `VOLUME_UP`                   | `Ctrl`+`+`    |
- | click on `VOLUME_DOWN`                 | `Ctrl`+`-`    |
- | click on `POWER`                       | `Ctrl`+`p`    |
- | turn screen on                         | _Right-click_ |
- | enable/disable FPS counter (on stdout) | `Ctrl`+`i`    |
+ | Action                                 |   Shortcut                    |
+ | -------------------------------------- |:----------------------------  |
+ | switch fullscreen mode                 | `Ctrl`+`f`                    |
+ | resize window to 1:1 (pixel-perfect)   | `Ctrl`+`g`                    |
+ | resize window to remove black borders  | `Ctrl`+`x` \| _Double-click¹_ |
+ | click on `HOME`                        | `Ctrl`+`h` \| _Middle-click_  |
+ | click on `BACK`                        | `Ctrl`+`b` \| _Right-click²_  |
+ | click on `APP_SWITCH`                  | `Ctrl`+`s`                    |
+ | click on `MENU`                        | `Ctrl`+`m`                    |
+ | click on `VOLUME_UP`                   | `Ctrl`+`↑` _(up)_             |
+ | click on `VOLUME_DOWN`                 | `Ctrl`+`↓` _(down)_           |
+ | click on `POWER`                       | `Ctrl`+`p`                    |
+ | turn screen on                         | _Right-click²_                |
+ | paste computer clipboard to device     | `Ctrl`+`v`                    |
+ | enable/disable FPS counter (on stdout) | `Ctrl`+`i`                    |
+
+_¹Double-click on black borders to remove them._  
+_²Right-click turns the screen on if it was off, presses BACK otherwise._


 ## Why _scrcpy_?
@@ -195,6 +323,11 @@ A colleague challenged me to find a name as unpronounceable as [gnirehtet].
 [`strcpy`]: http://man7.org/linux/man-pages/man3/strcpy.3.html


+## Common issues
+
+See the [FAQ](FAQ.md).
+
+
 ## Developers

 Read the [developers page].
@@ -217,3 +350,8 @@ Read the [developers page].
    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.
+
+## Articles
+
+- [Introducing scrcpy](https://blog.rom1v.com/2018/03/introducing-scrcpy/)
+- [Scrcpy now works wirelessly](https://www.genymotion.com/blog/open-source-project-scrcpy-now-works-wirelessly/)
--- a/app/meson.build
+++ b/app/meson.build
@@ -18,6 +18,13 @@ src = [
    'src/tinyxpm.c',
 ]

+if get_option('audio_support')
+    src += [
+        'src/aoa.c',
+        'src/audio.c'
+    ]
+endif
+
 dependencies = [
    dependency('libavformat'),
    dependency('libavcodec'),
@@ -25,6 +32,10 @@ dependencies = [
    dependency('sdl2'),
 ]

+if get_option('audio_support')
+    dependencies += dependency('libusb-1.0')
+endif
+
 cc = meson.get_compiler('c')

 if host_machine.system() == 'windows'
@@ -42,7 +53,7 @@ conf = configuration_data()
 conf.set('BUILD_DEBUG', get_option('buildtype') == 'debug')

 # the version, updated on release
-conf.set_quoted('SCRCPY_VERSION', '0.1')
+conf.set_quoted('SCRCPY_VERSION', '1.1')

 # the prefix used during configuration (meson --prefix=PREFIX)
 conf.set_quoted('PREFIX', get_option('prefix'))
@@ -80,9 +91,16 @@ conf.set('DEFAULT_BIT_RATE', '8000000')  # 8Mbps
 # SKIP_FRAMES improves latency at the cost of framerate
 conf.set('SKIP_FRAMES', get_option('skip_frames'))

+# enable High DPI support
+conf.set('HIDPI_SUPPORT', get_option('hidpi_support'))
+
+# enable audio support (enable audio forwarding with --forward-audio)
+conf.set('AUDIO_SUPPORT', get_option('audio_support'))
+
 configure_file(configuration: conf, output: 'config.h')

-executable('scrcpy', src, dependencies: dependencies, install: true)
+src_dir = include_directories('src')
+executable('scrcpy', src, dependencies: dependencies, include_directories: src_dir, install: true)


 ### TESTS
@@ -93,8 +111,6 @@ tests = [
    ['test_strutil', ['tests/test_strutil.c', 'src/strutil.c']],
 ]

-src_dir = include_directories('src')
-
 foreach t : tests
    exe = executable(t[0], t[1], include_directories: src_dir, dependencies: dependencies)
    test(t[0], exe)
--- a/app/src/aoa.c
+++ b/app/src/aoa.c
@@ -0,0 +1,206 @@
+#include "aoa.h"
+
+#include "command.h" // must be first to include "winsock2.h" before "windows.h"
+#include <libusb-1.0/libusb.h>
+#include "log.h"
+
+// <https://source.android.com/devices/accessories/aoa2>
+#define AOA_GET_PROTOCOL     51
+#define AOA_START_ACCESSORY  53
+#define AOA_SET_AUDIO_MODE   58
+
+#define AUDIO_MODE_NO_AUDIO               0
+#define AUDIO_MODE_S16LSB_STEREO_44100HZ  1
+
+#define DEFAULT_TIMEOUT 1000
+
+typedef struct control_params {
+    uint8_t request_type;
+    uint8_t request;
+    uint16_t value;
+    uint16_t index;
+    unsigned char *data;
+    uint16_t length;
+    unsigned int timeout;
+} control_params;
+
+static void log_libusb_error(enum libusb_error errcode) {
+    LOGE("%s", libusb_strerror(errcode));
+}
+
+static SDL_bool control_transfer(libusb_device_handle *handle, control_params *params) {
+    int r = libusb_control_transfer(handle,
+                                    params->request_type,
+                                    params->request,
+                                    params->value,
+                                    params->index,
+                                    params->data,
+                                    params->length,
+                                    params->timeout);
+    if (r < 0) {
+        log_libusb_error(r);
+        return SDL_FALSE;
+    }
+    return SDL_TRUE;
+}
+
+static SDL_bool get_serial(libusb_device *device, struct libusb_device_descriptor *desc, unsigned char *data, int length) {
+
+    libusb_device_handle *handle;
+    int r;
+    if ((r = libusb_open(device, &handle))) {
+        // silently ignore
+        LOGD("USB: cannot open device %04x:%04x (%s)", desc->idVendor, desc->idProduct, libusb_strerror(r));
+        return SDL_FALSE;
+    }
+
+    if (!desc->iSerialNumber) {
+        LOGD("USB: device %04x:%04x has no serial number available", desc->idVendor, desc->idProduct);
+        libusb_close(handle);
+        return SDL_FALSE;
+    }
+
+    if ((r = libusb_get_string_descriptor_ascii(handle, desc->iSerialNumber, data, length)) <= 0) {
+        // silently ignore
+        LOGD("USB: cannot read serial of device %04x:%04x (%s)", desc->idVendor, desc->idProduct, libusb_strerror(r));
+        libusb_close(handle);
+        return SDL_FALSE;
+    }
+    data[length - 1] = '\0'; // just in case
+
+    libusb_close(handle);
+    return SDL_TRUE;
+}
+
+static libusb_device *find_device(const char *serial) {
+    libusb_device **list;
+    libusb_device *found = NULL;
+    ssize_t cnt = libusb_get_device_list(NULL, &list);
+    ssize_t i = 0;
+    if (cnt < 0) {
+        log_libusb_error(cnt);
+        return NULL;
+    }
+    for (i = 0; i < cnt; ++i) {
+        libusb_device *device = list[i];
+
+        struct libusb_device_descriptor desc;
+        libusb_get_device_descriptor(device, &desc);
+
+        char usb_serial[128];
+        if (get_serial(device, &desc, (unsigned char *) usb_serial, sizeof(usb_serial))) {
+            if (!strncmp(serial, usb_serial, sizeof(usb_serial))) {
+                libusb_ref_device(device);
+                found = device;
+                LOGD("USB device with serial %s found: %04x:%04x", serial, desc.idVendor, desc.idProduct);
+                break;
+            }
+        }
+    }
+    libusb_free_device_list(list, 1);
+    return found;
+}
+
+static SDL_bool aoa_get_protocol(libusb_device_handle *handle, uint16_t *version) {
+    unsigned char data[2];
+    control_params params = {
+        .request_type = LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR,
+        .request = AOA_GET_PROTOCOL,
+        .value = 0,
+        .index = 0,
+        .data = data,
+        .length = sizeof(data),
+        .timeout = DEFAULT_TIMEOUT
+    };
+    if (control_transfer(handle, &params)) {
+        // little endian
+        *version = (data[1] << 8) | data[0];
+        return SDL_TRUE;
+    }
+    return SDL_FALSE;
+}
+
+static SDL_bool set_audio_mode(libusb_device_handle *handle, uint16_t mode) {
+    control_params params = {
+        .request_type = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR,
+        .request = AOA_SET_AUDIO_MODE,
+        // <https://source.android.com/devices/accessories/aoa2.html#audio-support>
+        .value = mode,
+        .index = 0, // unused
+        .data = NULL,
+        .length = 0,
+        .timeout = DEFAULT_TIMEOUT
+    };
+    return control_transfer(handle, &params);
+}
+
+static SDL_bool start_accessory(libusb_device_handle *handle) {
+    control_params params = {
+        .request_type = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR,
+        .request = AOA_START_ACCESSORY,
+        .value = 0, // unused
+        .index = 0, // unused
+        .data = NULL,
+        .length = 0,
+        .timeout = DEFAULT_TIMEOUT
+    };
+    return control_transfer(handle, &params);
+}
+
+SDL_bool aoa_init(void) {
+    return !libusb_init(NULL);
+}
+
+void aoa_exit(void) {
+    libusb_exit(NULL);
+}
+
+SDL_bool aoa_forward_audio(const char *serial, SDL_bool forward) {
+    LOGD("%s audio accessory...", forward ? "Enabling" : "Disabling");
+    libusb_device *device = find_device(serial);
+    if (!device) {
+        LOGE("Cannot find USB device having serial %s", serial);
+        return SDL_FALSE;
+    }
+
+    SDL_bool ret = SDL_FALSE;
+
+    libusb_device_handle *handle;
+    int r = libusb_open(device, &handle);
+    if (r) {
+        log_libusb_error(r);
+        goto finally_unref_device;
+    }
+
+    uint16_t version;
+    if (!aoa_get_protocol(handle, &version)) {
+        LOGE("Cannot get AOA protocol version");
+        goto finally_close_handle;
+    }
+
+    LOGD("Device AOA version: %" PRIu16 "\n", version);
+    if (version < 2) {
+        LOGE("Device does not support AOA 2: %" PRIu16, version);
+        goto finally_close_handle;
+    }
+
+    uint16_t mode = forward ? AUDIO_MODE_S16LSB_STEREO_44100HZ : AUDIO_MODE_NO_AUDIO;
+    if (!set_audio_mode(handle, mode)) {
+        LOGE("Cannot set audio mode: %" PRIu16, mode);
+        goto finally_close_handle;
+    }
+
+    if (!start_accessory(handle)) {
+        LOGE("Cannot start accessory");
+        return SDL_FALSE;
+    }
+
+    ret = SDL_TRUE;
+
+finally_close_handle:
+    libusb_close(handle);
+finally_unref_device:
+    libusb_unref_device(device);
+
+    return ret;
+}
--- a/app/src/aoa.h
+++ b/app/src/aoa.h
@@ -0,0 +1,15 @@
+#ifndef AOA_H
+#define AOA_H
+
+#include <SDL2/SDL_stdinc.h>
+
+#define AUDIO_MODE_NO_AUDIO               0
+#define AUDIO_MODE_S16LSB_STEREO_44100HZ  1
+
+SDL_bool aoa_init(void);
+void aoa_exit(void);
+
+// serial must not be NULL
+SDL_bool aoa_forward_audio(const char *serial, SDL_bool forward);
+
+#endif
--- a/app/src/audio.c
+++ b/app/src/audio.c
@@ -0,0 +1,205 @@
+#include "audio.h"
+
+#include <SDL2/SDL.h>
+#include "aoa.h"
+#include "command.h"
+#include "log.h"
+
+SDL_bool sdl_audio_init(void) {
+    if (SDL_InitSubSystem(SDL_INIT_AUDIO)) {
+        LOGC("Could not initialize SDL audio: %s", SDL_GetError());
+        return SDL_FALSE;
+    }
+    return SDL_TRUE;
+}
+
+static void init_audio_spec(SDL_AudioSpec *spec) {
+    SDL_zero(*spec);
+    spec->freq = 44100;
+    spec->format = AUDIO_S16LSB;
+    spec->channels = 2;
+    spec->samples = 1024;
+}
+
+SDL_bool audio_player_init(struct audio_player *player, const char *serial) {
+    player->serial = SDL_strdup(serial);
+    return !!player->serial;
+}
+
+void audio_player_destroy(struct audio_player *player) {
+    SDL_free((void *) player->serial);
+}
+
+static void audio_input_callback(void *userdata, Uint8 *stream, int len) {
+    struct audio_player *player = userdata;
+    if (SDL_QueueAudio(player->output_device, stream, len)) {
+        LOGE("Cannot queue audio: %s", SDL_GetError());
+    }
+}
+
+static int get_matching_audio_device(const char *serial, int count) {
+    for (int i = 0; i < count; ++i) {
+        LOGD("Audio input #%d: %s", i, SDL_GetAudioDeviceName(i, 1));
+    }
+
+    char model[128];
+    int r = adb_read_model(serial, model, sizeof(model));
+    if (r <= 0) {
+        LOGE("Cannot read Android device model");
+        return -1;
+    }
+
+    LOGD("Device model is: %s", model);
+
+    // iterate backwards since the matching device is probably the last one
+    for (int i = count - 1; i >= 0; i--) {
+        // model is a NUL-terminated string
+        const char *name = SDL_GetAudioDeviceName(i, 1);
+        if (strstr(name, model)) {
+            // the device name contains the device model, we found it!
+            return i;
+        }
+    }
+    return -1;
+}
+
+static SDL_AudioDeviceID open_accessory_audio_input(struct audio_player *player) {
+    int count = SDL_GetNumAudioDevices(1);
+    if (!count) {
+        LOGE("No audio input source found");
+        return 0;
+    }
+
+    int selected = get_matching_audio_device(player->serial, count);
+    if (selected == -1) {
+        LOGE("Cannot find the Android accessory audio input source");
+        return 0;
+    }
+
+    const char *selected_name = SDL_GetAudioDeviceName(selected, 1);
+    LOGI("Selecting audio input source: %s", selected_name);
+
+    SDL_AudioSpec spec;
+    init_audio_spec(&spec);
+    spec.callback = audio_input_callback;
+    spec.userdata = player;
+
+    int id = SDL_OpenAudioDevice(selected_name, 1, &spec, NULL, 0);
+    if (!id) {
+        LOGE("Cannot open audio input: %s", SDL_GetError());
+    }
+    return id;
+}
+
+static SDL_AudioDeviceID open_default_audio_output() {
+    SDL_AudioSpec spec;
+    init_audio_spec(&spec);
+    int id = SDL_OpenAudioDevice(NULL, 0, &spec, NULL, 0);
+    if (!id) {
+        LOGE("Cannot open audio output: %s", SDL_GetError());
+    }
+    return id;
+}
+
+SDL_bool audio_player_open(struct audio_player *player) {
+    player->output_device = open_default_audio_output();
+    if (!player->output_device) {
+        return SDL_FALSE;
+    }
+
+    player->input_device = open_accessory_audio_input(player);
+    if (!player->input_device) {
+        SDL_CloseAudioDevice(player->output_device);
+        return SDL_FALSE;
+    }
+
+    return SDL_TRUE;
+}
+
+static void audio_player_set_paused(struct audio_player *player, SDL_bool paused) {
+    SDL_PauseAudioDevice(player->input_device, paused);
+    SDL_PauseAudioDevice(player->output_device, paused);
+}
+
+void audio_player_play(struct audio_player *player) {
+    audio_player_set_paused(player, SDL_FALSE);
+}
+
+void audio_player_pause(struct audio_player *player) {
+    audio_player_set_paused(player, SDL_TRUE);
+}
+
+void audio_player_close(struct audio_player *player) {
+    SDL_CloseAudioDevice(player->input_device);
+    SDL_CloseAudioDevice(player->output_device);
+}
+
+SDL_bool audio_forwarding_start(struct audio_player *player, const char *serial) {
+    if (!aoa_init()) {
+        LOGE("Cannot initialize AOA");
+        return SDL_FALSE;
+    }
+
+    char serialno[128];
+    if (!serial) {
+        LOGD("No serial provided, request it to the device");
+        int r = adb_read_serialno(NULL, serialno, sizeof(serialno));
+        if (r <= 0) {
+            LOGE("Cannot read serial from the device");
+            goto error_aoa_exit;
+        }
+        LOGD("Device serial is %s", serialno);
+        serial = serialno;
+    }
+
+    if (!audio_player_init(player, serial)) {
+        LOGE("Cannot initialize audio player");
+        goto error_aoa_exit;
+    }
+
+    // adb connection will be reset!
+    if (!aoa_forward_audio(player->serial, SDL_TRUE)) {
+        LOGE("AOA audio forwarding failed");
+        goto error_destroy_player;
+    }
+
+    LOGI("Audio accessory enabled");
+
+    if (!sdl_audio_init()) {
+        goto error_disable_audio_forwarding;
+    }
+
+    LOGI("Waiting 2s for USB reconfiguration...");
+    SDL_Delay(2000);
+
+    if (!audio_player_open(player)) {
+        goto error_disable_audio_forwarding;
+    }
+
+    audio_player_play(player);
+    return SDL_TRUE;
+
+error_disable_audio_forwarding:
+    if (!aoa_forward_audio(serial, SDL_FALSE)) {
+        LOGW("Cannot disable audio forwarding");
+    }
+error_destroy_player:
+    audio_player_destroy(player);
+error_aoa_exit:
+    aoa_exit();
+
+    return SDL_FALSE;
+}
+
+void audio_forwarding_stop(struct audio_player *player) {
+    audio_player_close(player);
+
+    if (aoa_forward_audio(player->serial, SDL_FALSE)) {
+        LOGI("Audio forwarding disabled");
+    } else {
+        LOGW("Cannot disable audio forwarding");
+    }
+    aoa_exit();
+
+    audio_player_destroy(player);
+}
--- a/app/src/audio.h
+++ b/app/src/audio.h
@@ -0,0 +1,29 @@
+#ifndef AUDIO_H
+#define AUDIO_H
+
+#include <SDL2/SDL_audio.h>
+#include <SDL2/SDL_stdinc.h>
+
+struct audio_player {
+    const char *serial;
+    SDL_AudioDeviceID input_device;
+    SDL_AudioDeviceID output_device;
+};
+
+SDL_bool sdl_audio_init(void);
+
+// serial must not be NULL
+SDL_bool audio_player_init(struct audio_player *player, const char *serial);
+void audio_player_destroy(struct audio_player *player);
+
+SDL_bool audio_player_open(struct audio_player *player);
+void audio_player_close(struct audio_player *player);
+
+void audio_player_play(struct audio_player *player);
+void audio_player_pause(struct audio_player *player);
+
+// for convenience, these functions handle everything
+SDL_bool audio_forwarding_start(struct audio_player *player, const char *serial);
+void audio_forwarding_stop(struct audio_player *player);
+
+#endif
--- a/app/src/command.c
+++ b/app/src/command.c
@@ -4,10 +4,9 @@
 #include <stdlib.h>
 #include <string.h>

+#include "common.h"
 #include "log.h"

-#define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0]))
-
 static const char *adb_command;

 static inline const char *get_adb_command() {
@@ -19,8 +18,7 @@ static inline const char *get_adb_command() {
    return adb_command;
 }

-process_t adb_execute(const char *serial, const char *const adb_cmd[], int len) {
-    const char *cmd[len + 4];
+static void fill_cmd(const char *cmd[], const char *serial, const char *const adb_cmd[], int len) {
    int i;
    cmd[0] = get_adb_command();
    if (serial) {
@@ -33,9 +31,21 @@ process_t adb_execute(const char *serial, const char *const adb_cmd[], int len)

    memcpy(&cmd[i], adb_cmd, len * sizeof(const char *));
    cmd[len + i] = NULL;
+}
+
+process_t adb_execute(const char *serial, const char *const adb_cmd[], int len) {
+    const char *cmd[len + 4];
+    fill_cmd(cmd, serial, adb_cmd, len);
    return cmd_execute(cmd[0], cmd);
 }

+process_t adb_execute_redirect(const char *serial, const char *const adb_cmd[], int len,
+                               pipe_t *pipe_stdin, pipe_t *pipe_stdout, pipe_t *pipe_stderr) {
+    const char *cmd[len + 4];
+    fill_cmd(cmd, serial, adb_cmd, len);
+    return cmd_execute_redirect(cmd[0], cmd, pipe_stdin, pipe_stdout, pipe_stderr);
+}
+
 process_t adb_forward(const char *serial, uint16_t local_port, const char *device_socket_name) {
    char local[4 + 5 + 1]; // tcp:PORT
    char remote[108 + 14 + 1]; // localabstract:NAME
@@ -45,6 +55,13 @@ process_t adb_forward(const char *serial, uint16_t local_port, const char *devic
    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }

+process_t adb_forward_remove(const char *serial, uint16_t local_port) {
+    char local[4 + 5 + 1]; // tcp:PORT
+    sprintf(local, "tcp:%" PRIu16, local_port);
+    const char *const adb_cmd[] = {"forward", "--remove", local};
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+}
+
 process_t adb_reverse(const char *serial, const char *device_socket_name, uint16_t local_port) {
    char local[4 + 5 + 1]; // tcp:PORT
    char remote[108 + 14 + 1]; // localabstract:NAME
@@ -71,6 +88,40 @@ process_t adb_remove_path(const char *serial, const char *path) {
    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
 }

+static int adb_execute_get_output(const char *serial, const char *const adb_cmd[], int adb_cmd_len,
+                           char *data, size_t data_len, const char *name) {
+    pipe_t pipe_stdout;
+    process_t proc = adb_execute_redirect(serial, adb_cmd, adb_cmd_len, NULL, &pipe_stdout, NULL);
+    if (!process_check_success(proc, name)) {
+        return -1;
+    }
+    int r = read_pipe(pipe_stdout, data, data_len);
+    close_pipe(pipe_stdout);
+    return r;
+}
+
+static int truncate_first_line(char *data, int len) {
+    data[len - 1] = '\0';
+    char *eol = strpbrk(data, "\r\n");
+    if (eol) {
+        *eol = '\0';
+        len = eol - data;
+    }
+    return len;
+}
+
+int adb_read_serialno(const char *serial, char *data, size_t len) {
+    const char *const adb_cmd[] = {"get-serialno"};
+    int r = adb_execute_get_output(serial, adb_cmd, ARRAY_LEN(adb_cmd), data, len, "get-serialno");
+    return r <= 0 ? r : truncate_first_line(data, r);
+}
+
+int adb_read_model(const char *serial, char *data, size_t len) {
+    const char *const adb_cmd[] = {"shell", "getprop", "ro.product.model"};
+    int r = adb_execute_get_output(serial, adb_cmd, ARRAY_LEN(adb_cmd), data, len, "getprop model");
+    return r <= 0 ? r : truncate_first_line(data, r);
+}
+
 SDL_bool process_check_success(process_t proc, const char *name) {
    if (proc == PROCESS_NONE) {
        LOGE("Could not execute \"%s\"", name);
--- a/app/src/command.h
+++ b/app/src/command.h
@@ -7,12 +7,11 @@

 // <https://stackoverflow.com/a/44383330/1987178>
 #ifdef _WIN32
+# define PRIexitcode "lu"
 # ifdef _WIN64
 #   define PRIsizet PRIu64
-#   define PRIexitcode "lu"
 # else
 #   define PRIsizet PRIu32
-#   define PRIexitcode "u"
 # endif
 #else
 # define PRIsizet "zu"
@@ -25,27 +24,42 @@
 # define PROCESS_NONE NULL
  typedef HANDLE process_t;
  typedef DWORD exit_code_t;
+  typedef HANDLE pipe_t;
 #else
 # include <sys/types.h>
 # define PROCESS_NONE -1
  typedef pid_t process_t;
  typedef int exit_code_t;
+  typedef int pipe_t;
 #endif
 # define NO_EXIT_CODE -1

 process_t cmd_execute(const char *path, const char *const argv[]);
+process_t cmd_execute_redirect(const char *path, const char *const argv[],
+                               pipe_t *pipe_stdin, pipe_t *pipe_stdout, pipe_t *pipe_stderr);
 SDL_bool cmd_terminate(process_t pid);
 SDL_bool cmd_simple_wait(process_t pid, exit_code_t *exit_code);

 process_t adb_execute(const char *serial, const char *const adb_cmd[], int len);
+process_t adb_execute_redirect(const char *serial, const char *const adb_cmd[], int len,
+                               pipe_t *pipe_stdin, pipe_t *pipe_stdout, pipe_t *pipe_stderr);
+
 process_t adb_forward(const char *serial, uint16_t local_port, const char *device_socket_name);
+process_t adb_forward_remove(const char *serial, uint16_t local_port);
 process_t adb_reverse(const char *serial, const char *device_socket_name, uint16_t local_port);
 process_t adb_reverse_remove(const char *serial, const char *device_socket_name);
 process_t adb_push(const char *serial, const char *local, const char *remote);
 process_t adb_remove_path(const char *serial, const char *path);

+// return number of bytes read (-1 on error)
+int adb_read_serialno(const char *serial, char *data, size_t len);
+int adb_read_model(const char *serial, char *data, size_t len);
+
 // convenience function to wait for a successful process execution
 // automatically log process errors with the provided process name
 SDL_bool process_check_success(process_t process, const char *name);

+int read_pipe(pipe_t pipe, char *data, size_t len);
+void close_pipe(pipe_t pipe);
+
 #endif
--- a/app/src/common.h
+++ b/app/src/common.h
@@ -3,6 +3,7 @@

 #include <SDL2/SDL_stdinc.h>

+#define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0]))
 #define MIN(X,Y) (X) < (Y) ? (X) : (Y)
 #define MAX(X,Y) (X) > (Y) ? (X) : (Y)

--- a/app/src/controlevent.c
+++ b/app/src/controlevent.c
@@ -36,11 +36,12 @@ int control_event_serialize(const struct control_event *event, unsigned char *bu
            // write length (1 byte) + date (non nul-terminated)
            size_t len = strlen(event->text_event.text);
            if (len > TEXT_MAX_LENGTH) {
+                // injecting a text takes time, so limit the text length
                len = TEXT_MAX_LENGTH;
            }
-            buf[1] = (Uint8) len;
-            memcpy(&buf[2], &event->text_event.text, len);
-            return 2 + len;
+            write16(&buf[1], (Uint16) len);
+            memcpy(&buf[3], event->text_event.text, len);
+            return 3 + len;
        }
        case CONTROL_EVENT_TYPE_MOUSE:
            buf[1] = event->mouse_event.action;
@@ -61,6 +62,12 @@ int control_event_serialize(const struct control_event *event, unsigned char *bu
    }
 }

+void control_event_destroy(struct control_event *event) {
+    if (event->type == CONTROL_EVENT_TYPE_TEXT) {
+        SDL_free(event->text_event.text);
+    }
+}
+
 SDL_bool control_event_queue_is_empty(const struct control_event_queue *queue) {
    return queue->head == queue->tail;
 }
@@ -77,7 +84,11 @@ SDL_bool control_event_queue_init(struct control_event_queue *queue) {
 }

 void control_event_queue_destroy(struct control_event_queue *queue) {
-    // nothing to do in the current implementation
+    int i = queue->tail;
+    while (i != queue->head) {
+        control_event_destroy(&queue->data[i]);
+        i = (i + 1) % CONTROL_EVENT_QUEUE_SIZE;
+    }
 }

 SDL_bool control_event_queue_push(struct control_event_queue *queue, const struct control_event *event) {
--- a/app/src/controlevent.h
+++ b/app/src/controlevent.h
@@ -9,8 +9,8 @@
 #include "common.h"

 #define CONTROL_EVENT_QUEUE_SIZE 64
-#define SERIALIZED_EVENT_MAX_SIZE 33
-#define TEXT_MAX_LENGTH 31
+#define TEXT_MAX_LENGTH 300
+#define SERIALIZED_EVENT_MAX_SIZE 3 + TEXT_MAX_LENGTH

 enum control_event_type {
    CONTROL_EVENT_TYPE_KEYCODE,
@@ -20,7 +20,7 @@ enum control_event_type {
    CONTROL_EVENT_TYPE_COMMAND,
 };

-#define CONTROL_EVENT_COMMAND_SCREEN_ON 0
+#define CONTROL_EVENT_COMMAND_BACK_OR_SCREEN_ON 0

 struct control_event {
    enum control_event_type type;
@@ -31,7 +31,7 @@ struct control_event {
            enum android_metastate metastate;
        } keycode_event;
        struct {
-            char text[TEXT_MAX_LENGTH + 1]; // nul-terminated string
+            char *text; // owned, to be freed by SDL_free()
        } text_event;
        struct {
            enum android_motionevent_action action;
@@ -68,4 +68,6 @@ SDL_bool control_event_queue_is_full(const struct control_event_queue *queue);
 SDL_bool control_event_queue_push(struct control_event_queue *queue, const struct control_event *event);
 SDL_bool control_event_queue_take(struct control_event_queue *queue, struct control_event *event);

+void control_event_destroy(struct control_event *event);
+
 #endif
--- a/app/src/controller.c
+++ b/app/src/controller.c
@@ -65,7 +65,9 @@ static int run_controller(void *data) {
        }
        struct control_event event;
        while (control_event_queue_take(&controller->queue, &event)) {
-            if (!process_event(controller, &event)) {
+            SDL_bool ok = process_event(controller, &event);
+            control_event_destroy(&event);
+            if (!ok) {
                LOGD("Cannot write event to socket");
                goto end;
            }
--- a/app/src/convert.c
+++ b/app/src/convert.c
@@ -73,6 +73,7 @@ static enum android_metastate convert_meta_state(SDL_Keymod mod) {
 static SDL_bool convert_keycode(SDL_Keycode from, enum android_keycode *to) {
    switch (from) {
        MAP(SDLK_RETURN,       AKEYCODE_ENTER);
+        MAP(SDLK_KP_ENTER,     AKEYCODE_NUMPAD_ENTER);
        MAP(SDLK_ESCAPE,       AKEYCODE_ESCAPE);
        MAP(SDLK_BACKSPACE,    AKEYCODE_DEL);
        MAP(SDLK_TAB,          AKEYCODE_TAB);
@@ -145,8 +146,8 @@ SDL_bool mouse_button_from_sdl_to_android(const SDL_MouseButtonEvent *from,

    to->mouse_event.buttons = convert_mouse_buttons(SDL_BUTTON(from->button));
    to->mouse_event.position.screen_size = screen_size;
-    to->mouse_event.position.point.x = (Uint16) from->x;
-    to->mouse_event.position.point.y = (Uint16) from->y;
+    to->mouse_event.position.point.x = from->x;
+    to->mouse_event.position.point.y = from->y;

    return SDL_TRUE;
 }
@@ -172,7 +173,10 @@ SDL_bool mouse_wheel_from_sdl_to_android(const SDL_MouseWheelEvent *from,
    to->scroll_event.position = position;

    int mul = from->direction == SDL_MOUSEWHEEL_NORMAL ? 1 : -1;
-    to->scroll_event.hscroll = mul * from->x;
+    // SDL behavior seems inconsistent between horizontal and vertical scrolling
+    // so reverse the horizontal
+    // <https://wiki.libsdl.org/SDL_MouseWheelEvent#Remarks>
+    to->scroll_event.hscroll = -mul * from->x;
    to->scroll_event.vscroll = mul * from->y;

    return SDL_TRUE;
--- a/app/src/decoder.c
+++ b/app/src/decoder.c
@@ -40,37 +40,33 @@ static void notify_stopped(void) {

 static int run_decoder(void *data) {
    struct decoder *decoder = data;
-    int ret = 0;

    AVCodec *codec = avcodec_find_decoder(AV_CODEC_ID_H264);
    if (!codec) {
        LOGE("H.264 decoder not found");
-        return -1;
+        goto run_end;
    }

    AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
    if (!codec_ctx) {
        LOGC("Could not allocate decoder context");
-        return -1;
+        goto run_end;
    }

    if (avcodec_open2(codec_ctx, codec, NULL) < 0) {
        LOGE("Could not open H.264 codec");
-        ret = -1;
        goto run_finally_free_codec_ctx;
    }

    AVFormatContext *format_ctx = avformat_alloc_context();
    if (!format_ctx) {
        LOGC("Could not allocate format context");
-        ret = -1;
        goto run_finally_close_codec;
    }

    unsigned char *buffer = av_malloc(BUFSIZE);
    if (!buffer) {
        LOGC("Could not allocate buffer");
-        ret = -1;
        goto run_finally_free_format_ctx;
    }

@@ -80,7 +76,6 @@ static int run_decoder(void *data) {
        // avformat_open_input takes ownership of 'buffer'
        // so only free the buffer before avformat_open_input()
        av_free(buffer);
-        ret = -1;
        goto run_finally_free_format_ctx;
    }

@@ -88,7 +83,6 @@ static int run_decoder(void *data) {

    if (avformat_open_input(&format_ctx, NULL, NULL, NULL) < 0) {
        LOGE("Could not open video stream");
-        ret = -1;
        goto run_finally_free_avio_ctx;
    }

@@ -97,10 +91,25 @@ static int run_decoder(void *data) {
    packet.data = NULL;
    packet.size = 0;

-    while (!av_read_frame(format_ctx, &packet) && !avio_ctx->eof_reached) {
+    while (!av_read_frame(format_ctx, &packet)) {
 // the new decoding/encoding API has been introduced by:
 // <http://git.videolan.org/?p=ffmpeg.git;a=commitdiff;h=7fc329e2dd6226dfecaa4a1d7adf353bf2773726>
-#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(57, 37, 0)
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 37, 0)
+        int ret;
+        if ((ret = avcodec_send_packet(codec_ctx, &packet)) < 0) {
+            LOGE("Could not send video packet: %d", ret);
+            goto run_quit;
+        }
+        ret = avcodec_receive_frame(codec_ctx, decoder->frames->decoding_frame);
+        if (!ret) {
+            // a frame was received
+            push_frame(decoder);
+        } else if (ret != AVERROR(EAGAIN)) {
+            LOGE("Could not receive video frame: %d", ret);
+            av_packet_unref(&packet);
+            goto run_quit;
+        }
+#else
        while (packet.size > 0) {
            int got_picture;
            int len = avcodec_decode_video2(codec_ctx, decoder->frames->decoding_frame, &got_picture, &packet);
@@ -114,19 +123,12 @@ static int run_decoder(void *data) {
            packet.size -= len;
            packet.data += len;
        }
-#else
-        int ret;
-        if ((ret = avcodec_send_packet(codec_ctx, &packet)) < 0) {
-            LOGE("Could not send video packet: %d", ret);
-            goto run_quit;
-        }
-        if ((ret = avcodec_receive_frame(codec_ctx, decoder->frames->decoding_frame)) < 0) {
-            LOGE("Could not receive video frame: %d", ret);
-            goto run_quit;
-        }
-
-        push_frame(decoder);
 #endif
+        av_packet_unref(&packet);
+
+        if (avio_ctx->eof_reached) {
+            break;
+        }
    }

    LOGD("End of frames");
@@ -142,7 +144,8 @@ run_finally_close_codec:
 run_finally_free_codec_ctx:
    avcodec_free_context(&codec_ctx);
    notify_stopped();
-    return ret;
+run_end:
+    return 0;
 }

 void decoder_init(struct decoder *decoder, struct frames *frames, socket_t video_socket) {
--- a/app/src/inputmanager.c
+++ b/app/src/inputmanager.c
@@ -4,10 +4,24 @@
 #include "lockutil.h"
 #include "log.h"

-static struct point get_mouse_point(void) {
+// 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);
    SDL_assert_release(x >= 0 && x < 0x10000 && y >= 0 && y < 0x10000);
    return (struct point) {
        .x = (Uint16) x,
@@ -15,21 +29,13 @@ static struct point get_mouse_point(void) {
    };
 }

-static SDL_bool is_ctrl_down(void) {
-    const Uint8 *state = SDL_GetKeyboardState(NULL);
-    return state[SDL_SCANCODE_LCTRL] || state[SDL_SCANCODE_RCTRL];
-}
-
 static void send_keycode(struct controller *controller, enum android_keycode keycode, const char *name) {
    // send DOWN event
-    struct control_event control_event = {
-        .type = CONTROL_EVENT_TYPE_KEYCODE,
-        .keycode_event = {
-            .action = AKEY_EVENT_ACTION_DOWN,
-            .keycode = keycode,
-            .metastate = 0,
-        },
-    };
+    struct control_event control_event;
+    control_event.type = CONTROL_EVENT_TYPE_KEYCODE;
+    control_event.keycode_event.action = AKEY_EVENT_ACTION_DOWN;
+    control_event.keycode_event.keycode = keycode;
+    control_event.keycode_event.metastate = 0;

    if (!controller_push_event(controller, &control_event)) {
        LOGW("Cannot send %s (DOWN)", name);
@@ -67,13 +73,16 @@ static inline void action_volume_down(struct controller *controller) {
    send_keycode(controller, AKEYCODE_VOLUME_DOWN, "VOLUME_DOWN");
 }

-static void turn_screen_on(struct controller *controller) {
-    struct control_event control_event = {
-        .type = CONTROL_EVENT_TYPE_COMMAND,
-        .command_event = {
-            .action = CONTROL_EVENT_COMMAND_SCREEN_ON,
-        },
-    };
+static inline void action_menu(struct controller *controller) {
+    send_keycode(controller, AKEYCODE_MENU, "MENU");
+}
+
+// turn the screen on if it was off, press BACK otherwise
+static void press_back_or_turn_screen_on(struct controller *controller) {
+    struct control_event control_event;
+    control_event.type = CONTROL_EVENT_TYPE_COMMAND;
+    control_event.command_event.action = CONTROL_EVENT_COMMAND_BACK_OR_SCREEN_ON;
+
    if (!controller_push_event(controller, &control_event)) {
        LOGW("Cannot turn screen on");
    }
@@ -91,24 +100,36 @@ static void switch_fps_counter_state(struct frames *frames) {
    mutex_unlock(frames->mutex);
 }

-void input_manager_process_text_input(struct input_manager *input_manager,
-                                      const SDL_TextInputEvent *event) {
-    if (is_ctrl_down()) {
-        switch (event->text[0]) {
-            case '+':
-                action_volume_up(input_manager->controller);
-                break;
-            case '-':
-                action_volume_down(input_manager->controller);
-                break;
-        }
+static void clipboard_paste(struct controller *controller) {
+    char *text = SDL_GetClipboardText();
+    if (!text) {
+        LOGW("Cannot get clipboard text: %s", SDL_GetError());
+        return;
+    }
+    if (!*text) {
+        // empty text
+        SDL_free(text);
        return;
    }

    struct control_event control_event;
    control_event.type = CONTROL_EVENT_TYPE_TEXT;
-    strncpy(control_event.text_event.text, event->text, TEXT_MAX_LENGTH);
-    control_event.text_event.text[TEXT_MAX_LENGTH] = '\0';
+    control_event.text_event.text = text;
+    if (!controller_push_event(controller, &control_event)) {
+        SDL_free(text);
+        LOGW("Cannot send clipboard paste event");
+    }
+}
+
+void input_manager_process_text_input(struct input_manager *input_manager,
+                                      const SDL_TextInputEvent *event) {
+    struct control_event control_event;
+    control_event.type = CONTROL_EVENT_TYPE_TEXT;
+    control_event.text_event.text = SDL_strdup(event->text);
+    if (!control_event.text_event.text) {
+        LOGW("Cannot strdup input text");
+        return;
+    }
    if (!controller_push_event(input_manager->controller, &control_event)) {
        LOGW("Cannot send text event");
    }
@@ -116,23 +137,24 @@ void input_manager_process_text_input(struct input_manager *input_manager,

 void input_manager_process_key(struct input_manager *input_manager,
                               const SDL_KeyboardEvent *event) {
-    SDL_Keycode keycode = event->keysym.sym;
    SDL_bool ctrl = event->keysym.mod & (KMOD_LCTRL | KMOD_RCTRL);
-    SDL_bool shift = event->keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT);
-    SDL_bool repeat = event->repeat;

    // capture all Ctrl events
    if (ctrl) {
+        SDL_bool repeat = event->repeat;
+
        // only consider keydown events, and ignore repeated events
        if (repeat || event->type != SDL_KEYDOWN) {
            return;
        }

+        SDL_bool shift = event->keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT);
        if (shift) {
            // currently, there is no shortcut implying SHIFT
            return;
        }

+        SDL_Keycode keycode = event->keysym.sym;
        switch (keycode) {
            case SDLK_h:
                action_home(input_manager->controller);
@@ -141,12 +163,24 @@ void input_manager_process_key(struct input_manager *input_manager,
            case SDLK_BACKSPACE:
                action_back(input_manager->controller);
                return;
-            case SDLK_m:
+            case SDLK_s:
                action_app_switch(input_manager->controller);
                return;
+            case SDLK_m:
+                action_menu(input_manager->controller);
+                return;
            case SDLK_p:
                action_power(input_manager->controller);
                return;
+            case SDLK_DOWN:
+                action_volume_down(input_manager->controller);
+                return;
+            case SDLK_UP:
+                action_volume_up(input_manager->controller);
+                return;
+            case SDLK_v:
+                clipboard_paste(input_manager->controller);
+                return;
            case SDLK_f:
                screen_switch_fullscreen(input_manager->screen);
                return;
@@ -188,9 +222,26 @@ void input_manager_process_mouse_motion(struct input_manager *input_manager,

 void input_manager_process_mouse_button(struct input_manager *input_manager,
                                        const SDL_MouseButtonEvent *event) {
-    if (event->button == SDL_BUTTON_RIGHT && event->type == SDL_MOUSEBUTTONDOWN) {
-        turn_screen_on(input_manager->controller);
-        return;
+    if (event->type == SDL_MOUSEBUTTONDOWN) {
+        if (event->button == SDL_BUTTON_RIGHT) {
+            press_back_or_turn_screen_on(input_manager->controller);
+            return;
+        }
+        if (event->button == SDL_BUTTON_MIDDLE) {
+            action_home(input_manager->controller);
+            return;
+        }
+        // double-click on black borders resize to fit the device screen
+        if (event->button == SDL_BUTTON_LEFT && event->clicks == 2) {
+            SDL_bool outside_device_screen =
+                    event->x < 0 || event->x >= input_manager->screen->frame_size.width ||
+                    event->y < 0 || event->y >= input_manager->screen->frame_size.height;
+            if (outside_device_screen) {
+                screen_resize_to_fit(input_manager->screen);
+                return;
+            }
+            // otherwise, send the click event to the device
+        }
    };
    struct control_event control_event;
    if (mouse_button_from_sdl_to_android(event, input_manager->screen->frame_size, &control_event)) {
@@ -204,12 +255,12 @@ void input_manager_process_mouse_wheel(struct input_manager *input_manager,
                                       const SDL_MouseWheelEvent *event) {
    struct position position = {
        .screen_size = input_manager->screen->frame_size,
-        .point = get_mouse_point(),
+        .point = get_mouse_point(input_manager->screen),
    };
    struct control_event control_event;
    if (mouse_wheel_from_sdl_to_android(event, position, &control_event)) {
        if (!controller_push_event(input_manager->controller, &control_event)) {
-            LOGW("Cannot send wheel button event");
+            LOGW("Cannot send mouse wheel event");
        }
    }
 }
--- a/app/src/main.c
+++ b/app/src/main.c
@@ -12,6 +12,10 @@ struct args {
    const char *serial;
    SDL_bool help;
    SDL_bool version;
+    SDL_bool show_touches;
+#ifdef AUDIO_SUPPORT
+    SDL_bool forward_audio;
+#endif
    Uint16 port;
    Uint16 max_size;
    Uint32 bit_rate;
@@ -22,6 +26,12 @@ static void usage(const char *arg0) {
        "Usage: %s [options]\n"
        "\n"
        "Options:\n"
+#ifdef AUDIO_SUPPORT
+        "\n"
+        "    -a, --forward-audio\n"
+        "        Forward audio from the device to the computer over USB\n"
+        "        (experimental).\n"
+#endif
        "\n"
        "    -b, --bit-rate value\n"
        "        Encode the video at the given bit-rate, expressed in bits/s.\n"
@@ -45,6 +55,10 @@ static void usage(const char *arg0) {
        "        The device serial number. Mandatory only if several devices\n"
        "        are connected to adb.\n"
        "\n"
+        "    -t, --show-touches\n"
+        "        Enable \"show touches\" on start, disable on quit.\n"
+        "        It only shows physical touches (not clicks from scrcpy).\n"
+        "\n"
        "    -v, --version\n"
        "        Print the version of scrcpy.\n"
        "\n"
@@ -57,31 +71,40 @@ static void usage(const char *arg0) {
        "        resize window to 1:1 (pixel-perfect)\n"
        "\n"
        "    Ctrl+x\n"
+        "    Double-click on black borders\n"
        "        resize window to remove black borders\n"
        "\n"
        "    Ctrl+h\n"
        "    Home\n"
+        "    Middle-click\n"
        "        click on HOME\n"
        "\n"
        "    Ctrl+b\n"
        "    Ctrl+Backspace\n"
+        "    Right-click (when screen is on)\n"
        "        click on BACK\n"
        "\n"
-        "    Ctrl+m\n"
+        "    Ctrl+s\n"
        "        click on APP_SWITCH\n"
        "\n"
-        "    Ctrl+'+'\n"
+        "    Ctrl+m\n"
+        "        click on MENU\n"
+        "\n"
+        "    Ctrl+Up\n"
        "        click on VOLUME_UP\n"
        "\n"
-        "    Ctrl+'-'\n"
+        "    Ctrl+Down\n"
        "        click on VOLUME_DOWN\n"
        "\n"
        "    Ctrl+p\n"
        "        click on POWER (turn screen on/off)\n"
        "\n"
-        "    Right-click\n"
+        "    Right-click (when screen is off)\n"
        "        turn screen on\n"
        "\n"
+        "    Ctrl+v\n"
+        "        paste computer clipboard to device\n"
+        "\n"
        "    Ctrl+i\n"
        "        enable/disable FPS counter (print frames/second in logs)\n"
        "\n",
@@ -174,47 +197,58 @@ static SDL_bool parse_port(char *optarg, Uint16 *port) {

 static SDL_bool parse_args(struct args *args, int argc, char *argv[]) {
    static const struct option long_options[] = {
-        {"bit-rate", required_argument, NULL, 'b'},
-        {"help",     no_argument,       NULL, 'h'},
-        {"max-size", required_argument, NULL, 'm'},
-        {"port",     required_argument, NULL, 'p'},
-        {"serial",   required_argument, NULL, 's'},
-        {"version",  no_argument,       NULL, 'v'},
-        {NULL,       0,                 NULL, 0  },
+#ifdef AUDIO_SUPPORT
+        {"forward-audio", no_argument,       NULL, 'a'},
+#endif
+        {"bit-rate",      required_argument, NULL, 'b'},
+        {"help",          no_argument,       NULL, 'h'},
+        {"max-size",      required_argument, NULL, 'm'},
+        {"port",          required_argument, NULL, 'p'},
+        {"serial",        required_argument, NULL, 's'},
+        {"show-touches",  no_argument,       NULL, 't'},
+        {"version",       no_argument,       NULL, 'v'},
+        {NULL,            0,                 NULL, 0  },
    };
    int c;
-    while ((c = getopt_long(argc, argv, "b:hm:p:s:v", long_options, NULL)) != -1) {
+#ifdef AUDIO_SUPPORT
+# define AUDIO_SHORT_PARAM "a"
+#else
+# define AUDIO_SHORT_PARAM
+#endif
+    while ((c = getopt_long(argc, argv, AUDIO_SHORT_PARAM "b:hm:p:s:tv", long_options, NULL)) != -1) {
        switch (c) {
-            case 'b': {
+#ifdef AUDIO_SUPPORT
+            case 'a':
+                args->forward_audio = SDL_TRUE;
+                break;
+#endif
+            case 'b':
                if (!parse_bit_rate(optarg, &args->bit_rate)) {
                    return SDL_FALSE;
                }
                break;
-            }
-            case 'h': {
+            case 'h':
                args->help = SDL_TRUE;
                break;
-            }
-            case 'm': {
+            case 'm':
                if (!parse_max_size(optarg, &args->max_size)) {
                    return SDL_FALSE;
                }
                break;
-            }
-            case 'p': {
+            case 'p':
                if (!parse_port(optarg, &args->port)) {
                    return SDL_FALSE;
                }
                break;
-            }
-            case 's': {
+            case 's':
                args->serial = optarg;
                break;
-            }
-            case 'v': {
+            case 't':
+                args->show_touches = SDL_TRUE;
+                break;
+            case 'v':
                args->version = SDL_TRUE;
                break;
-            }
            default:
                // getopt prints the error message on stderr
                return SDL_FALSE;
@@ -230,13 +264,23 @@ static SDL_bool parse_args(struct args *args, int argc, char *argv[]) {
 }

 int main(int argc, char *argv[]) {
+#ifdef __WINDOWS__
+    // disable buffering, we want logs immediately
+    // even line buffering (setvbuf() with mode _IOLBF) is not sufficient
+    setbuf(stdout, NULL);
+    setbuf(stderr, NULL);
+#endif
    struct args args = {
        .serial = NULL,
        .help = SDL_FALSE,
        .version = SDL_FALSE,
+        .show_touches = SDL_FALSE,
        .port = DEFAULT_LOCAL_PORT,
        .max_size = DEFAULT_MAX_SIZE,
        .bit_rate = DEFAULT_BIT_RATE,
+#ifdef AUDIO_SUPPORT
+        .forward_audio = SDL_FALSE,
+#endif
    };
    if (!parse_args(&args, argc, argv)) {
        return 1;
@@ -262,9 +306,21 @@ int main(int argc, char *argv[]) {
    SDL_LogSetAllPriority(SDL_LOG_PRIORITY_DEBUG);
 #endif

-    int res = scrcpy(args.serial, args.port, args.max_size, args.bit_rate) ? 0 : 1;
+    struct scrcpy_options options = {
+        .serial = args.serial,
+        .port = args.port,
+        .max_size = args.max_size,
+        .bit_rate = args.bit_rate,
+        .show_touches = args.show_touches,
+#ifdef AUDIO_SUPPORT
+        .forward_audio = args.forward_audio,
+#endif
+    };
+    int res = scrcpy(&options) ? 0 : 1;

    avformat_network_deinit(); // ignore failure

+    SDL_Quit();
+
    return res;
 }
--- a/app/src/net.c
+++ b/app/src/net.c
@@ -18,6 +18,26 @@
  typedef struct in_addr IN_ADDR;
 #endif

+socket_t net_connect(Uint32 addr, Uint16 port) {
+    socket_t sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (sock == INVALID_SOCKET) {
+        perror("socket");
+        return INVALID_SOCKET;
+    }
+
+    SOCKADDR_IN sin;
+    sin.sin_family = AF_INET;
+    sin.sin_addr.s_addr = htonl(addr);
+    sin.sin_port = htons(port);
+
+    if (connect(sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
+        perror("connect");
+        return INVALID_SOCKET;
+    }
+
+    return sock;
+}
+
 socket_t net_listen(Uint32 addr, Uint16 port, int backlog) {
    socket_t sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock == INVALID_SOCKET) {
@@ -62,11 +82,11 @@ ssize_t net_recv_all(socket_t socket, void *buf, size_t len) {
    return recv(socket, buf, len, MSG_WAITALL);
 }

-ssize_t net_send(socket_t socket, void *buf, size_t len) {
+ssize_t net_send(socket_t socket, const void *buf, size_t len) {
    return send(socket, buf, len, 0);
 }

-ssize_t net_send_all(socket_t socket, void *buf, size_t len) {
+ssize_t net_send_all(socket_t socket, const void *buf, size_t len) {
    ssize_t w;
    while (len > 0) {
        w = send(socket, buf, len, 0);
@@ -74,7 +94,7 @@ ssize_t net_send_all(socket_t socket, void *buf, size_t len) {
            return -1;
        }
        len -= w;
-        buf += w;
+        buf = (char *) buf + w;
    }
    return w;
 }
--- a/app/src/net.h
+++ b/app/src/net.h
@@ -9,8 +9,6 @@
  #define SHUT_RD SD_RECEIVE
  #define SHUT_WR SD_SEND
  #define SHUT_RDWR SD_BOTH
-  typedef SIZE_T size_t;
-  typedef SSIZE_T ssize_t;
  typedef SOCKET socket_t;
 #else
 # include <sys/socket.h>
@@ -21,14 +19,15 @@
 SDL_bool net_init(void);
 void net_cleanup(void);

+socket_t net_connect(Uint32 addr, Uint16 port);
 socket_t net_listen(Uint32 addr, Uint16 port, int backlog);
 socket_t net_accept(socket_t server_socket);

 // the _all versions wait/retry until len bytes have been written/read
 ssize_t net_recv(socket_t socket, void *buf, size_t len);
 ssize_t net_recv_all(socket_t socket, void *buf, size_t len);
-ssize_t net_send(socket_t socket, void *buf, size_t len);
-ssize_t net_send_all(socket_t socket, void *buf, size_t len);
+ssize_t net_send(socket_t socket, const void *buf, size_t len);
+ssize_t net_send_all(socket_t socket, const void *buf, size_t len);
 // how is SHUT_RD (read), SHUT_WR (write) or SHUT_RDWR (both)
 SDL_bool net_shutdown(socket_t socket, int how);
 SDL_bool net_close(socket_t socket);
--- a/app/src/scrcpy.c
+++ b/app/src/scrcpy.c
@@ -7,6 +7,8 @@
 #include <sys/time.h>
 #include <SDL2/SDL.h>

+#include "aoa.h"
+#include "audio.h"
 #include "command.h"
 #include "common.h"
 #include "controller.h"
@@ -29,28 +31,39 @@ static struct frames frames;
 static struct decoder decoder;
 static struct controller controller;

+#ifdef AUDIO_SUPPORT
+static struct audio_player audio_player;
+#endif
+
 static struct input_manager input_manager = {
    .controller = &controller,
    .frames = &frames,
    .screen = &screen,
 };

-static void hidpi_fix_coordinates(Sint32 *x, Sint32 *y) {
-    struct screen_sizes sizes = screen_get_sizes(&screen);
-    Uint16 ww = sizes.window_size.width;
-    Uint16 wh = sizes.window_size.height;
-    Uint16 dw = sizes.drawable_size.width;
-    Uint16 dh = sizes.drawable_size.height;
-    printf("window=%dx%d; drawable=%dx%d\n", (int) ww, (int) wh, (int) dw, (int) dh);
-    if (dw && dw != ww) {
-        *x = ((Sint64) *x) * ww / dw;
-    }
-    if (dh && dh != wh) {
-        *y = ((Sint64) *y) * wh / dh;
+#if defined(__APPLE__) || defined(__WINDOWS__)
+# define CONTINUOUS_RESIZING_WORKAROUND
+#endif
+
+#ifdef CONTINUOUS_RESIZING_WORKAROUND
+// On Windows and MacOS, resizing blocks the event loop, so resizing events are
+// not triggered. As a workaround, handle them in an event handler.
+//
+// <https://bugzilla.libsdl.org/show_bug.cgi?id=2077>
+// <https://stackoverflow.com/a/40693139/1987178>
+static int event_watcher(void *data, SDL_Event *event) {
+    if (event->type == SDL_WINDOWEVENT && event->window.event == SDL_WINDOWEVENT_RESIZED) {
+        // called from another thread, not very safe, but it's a workaround!
+        screen_render(&screen);
    }
+    return 0;
 }
+#endif

 static void event_loop(void) {
+#ifdef CONTINUOUS_RESIZING_WORKAROUND
+    SDL_AddEventWatch(event_watcher, NULL);
+#endif
    SDL_Event event;
    while (SDL_WaitEvent(&event)) {
        switch (event.type) {
@@ -72,58 +85,83 @@ static void event_loop(void) {
                break;
            case SDL_WINDOWEVENT:
                switch (event.window.event) {
-                case SDL_WINDOWEVENT_EXPOSED:
-                case SDL_WINDOWEVENT_SIZE_CHANGED:
-                    screen_render(&screen);
-                    break;
+                    case SDL_WINDOWEVENT_EXPOSED:
+                    case SDL_WINDOWEVENT_SIZE_CHANGED:
+                        screen_render(&screen);
+                        break;
                }
                break;
-            case SDL_TEXTINPUT: {
+            case SDL_TEXTINPUT:
                input_manager_process_text_input(&input_manager, &event.text);
                break;
-            }
            case SDL_KEYDOWN:
            case SDL_KEYUP:
                input_manager_process_key(&input_manager, &event.key);
                break;
            case SDL_MOUSEMOTION:
-                hidpi_fix_coordinates(&event.motion.x, &event.motion.y);
                input_manager_process_mouse_motion(&input_manager, &event.motion);
                break;
-            case SDL_MOUSEWHEEL: {
-                hidpi_fix_coordinates(&event.wheel.x, &event.wheel.y);
+            case SDL_MOUSEWHEEL:
                input_manager_process_mouse_wheel(&input_manager, &event.wheel);
                break;
-            }
            case SDL_MOUSEBUTTONDOWN:
-            case SDL_MOUSEBUTTONUP: {
-                hidpi_fix_coordinates(&event.button.y, &event.button.y);
+            case SDL_MOUSEBUTTONUP:
                input_manager_process_mouse_button(&input_manager, &event.button);
                break;
-            }
        }
    }
 }

-SDL_bool scrcpy(const char *serial, Uint16 local_port, Uint16 max_size, Uint32 bit_rate) {
-    if (!server_start(&server, serial, local_port, max_size, bit_rate)) {
-        return SDL_FALSE;
+static process_t set_show_touches_enabled(const char *serial, SDL_bool enabled) {
+    const char *value = enabled ? "1" : "0";
+    const char *const adb_cmd[] = {
+        "shell", "settings", "put", "system", "show_touches", value
+    };
+    return adb_execute(serial, adb_cmd, ARRAY_LEN(adb_cmd));
+}
+
+static void wait_show_touches(process_t process) {
+    // reap the process, ignore the result
+    process_check_success(process, "show_touches");
+}
+
+SDL_bool scrcpy(const struct scrcpy_options *options) {
+    if (!SDL_SetHint(SDL_HINT_NO_SIGNAL_HANDLERS, "1")) {
+        LOGW("Cannot request to keep default signal handlers");
    }

+    process_t proc_show_touches;
+    SDL_bool show_touches_waited;
+    if (options->show_touches) {
+        LOGI("Enable show_touches");
+        proc_show_touches = set_show_touches_enabled(options->serial, SDL_TRUE);
+        show_touches_waited = SDL_FALSE;
+    }
+
+#ifdef AUDIO_SUPPORT
+    if (options->forward_audio) {
+        if (!audio_forwarding_start(&audio_player, options->serial)) {
+            return SDL_FALSE;
+        }
+    }
+#endif
+
    SDL_bool ret = SDL_TRUE;

-    if (!sdl_init_and_configure()) {
+    if (!server_start(&server, options->serial, options->port,
+                      options->max_size, options->bit_rate)) {
+        ret = SDL_FALSE;
+        goto finally_disable_audio_forwarding;
+    }
+
+    if (!sdl_video_init()) {
        ret = SDL_FALSE;
        goto finally_destroy_server;
    }

-    // SDL initialization replace the signal handler for SIGTERM, so Ctrl+C is
-    // managed by the event loop. This blocking call blocks the event loop, so
-    // timeout the connection not to block indefinitely in case of SIGTERM.
-#define SERVER_CONNECT_TIMEOUT_MS 2000
-    socket_t device_socket = server_connect_to(&server, serial, SERVER_CONNECT_TIMEOUT_MS);
+    socket_t device_socket = server_connect_to(&server);
    if (device_socket == INVALID_SOCKET) {
-        server_stop(&server, serial);
+        server_stop(&server);
        ret = SDL_FALSE;
        goto finally_destroy_server;
    }
@@ -135,13 +173,13 @@ SDL_bool scrcpy(const char *serial, Uint16 local_port, Uint16 max_size, Uint32 b
    // therefore, we transmit the screen size before the video stream, to be able
    // to init the window immediately
    if (!device_read_info(device_socket, device_name, &frame_size)) {
-        server_stop(&server, serial);
+        server_stop(&server);
        ret = SDL_FALSE;
        goto finally_destroy_server;
    }

    if (!frames_init(&frames)) {
-        server_stop(&server, serial);
+        server_stop(&server);
        ret = SDL_FALSE;
        goto finally_destroy_server;
    }
@@ -152,7 +190,7 @@ SDL_bool scrcpy(const char *serial, Uint16 local_port, Uint16 max_size, Uint32 b
    // start the decoder
    if (!decoder_start(&decoder)) {
        ret = SDL_FALSE;
-        server_stop(&server, serial);
+        server_stop(&server);
        goto finally_destroy_frames;
    }

@@ -171,10 +209,16 @@ SDL_bool scrcpy(const char *serial, Uint16 local_port, Uint16 max_size, Uint32 b
        goto finally_stop_and_join_controller;
    }

-    event_loop();
+    if (options->show_touches) {
+        wait_show_touches(proc_show_touches);
+        show_touches_waited = SDL_TRUE;
+    }

+    event_loop();
    LOGD("quit...");
+
    screen_destroy(&screen);
+
 finally_stop_and_join_controller:
    controller_stop(&controller);
    controller_join(&controller);
@@ -183,12 +227,28 @@ finally_destroy_controller:
 finally_stop_decoder:
    decoder_stop(&decoder);
    // stop the server before decoder_join() to wake up the decoder
-    server_stop(&server, serial);
+    server_stop(&server);
    decoder_join(&decoder);
 finally_destroy_frames:
    frames_destroy(&frames);
 finally_destroy_server:
+    if (options->show_touches) {
+        if (!show_touches_waited) {
+            // wait the process which enabled "show touches"
+            wait_show_touches(proc_show_touches);
+        }
+        LOGI("Disable show_touches");
+        proc_show_touches = set_show_touches_enabled(options->serial, SDL_FALSE);
+        wait_show_touches(proc_show_touches);
+    }
+
    server_destroy(&server);
+finally_disable_audio_forwarding:
+#ifdef AUDIO_SUPPORT
+    if (options->forward_audio) {
+        audio_forwarding_stop(&audio_player);
+    }
+#endif

    return ret;
 }
--- a/app/src/scrcpy.h
+++ b/app/src/scrcpy.h
@@ -2,7 +2,19 @@
 #define SCRCPY_H

 #include <SDL2/SDL_stdinc.h>
+#include "config.h"

-SDL_bool scrcpy(const char *serial, Uint16 local_port, Uint16 max_size, Uint32 bit_rate);
+struct scrcpy_options {
+    const char *serial;
+    Uint16 port;
+    Uint16 max_size;
+    Uint32 bit_rate;
+    SDL_bool show_touches;
+#ifdef AUDIO_SUPPORT
+    SDL_bool forward_audio;
+#endif
+};
+
+SDL_bool scrcpy(const struct scrcpy_options *options);

 #endif
--- a/app/src/screen.c
+++ b/app/src/screen.c
@@ -10,16 +10,14 @@

 #define DISPLAY_MARGINS 96

-SDL_bool sdl_init_and_configure(void) {
-    if (SDL_Init(SDL_INIT_VIDEO)) {
-        LOGC("Could not initialize SDL: %s", SDL_GetError());
+SDL_bool sdl_video_init(void) {
+    if (SDL_InitSubSystem(SDL_INIT_VIDEO)) {
+        LOGC("Could not initialize SDL video: %s", SDL_GetError());
        return SDL_FALSE;
    }

-    atexit(SDL_Quit);
-
-    // Bilinear resizing
-    if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1")) {
+    // Use the best available scale quality
+    if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "2")) {
        LOGW("Could not enable bilinear filtering");
    }

@@ -45,27 +43,6 @@ static struct size get_native_window_size(SDL_Window *window) {
    return size;
 }

-// get the size of the window underlying drawable in pixels
-// may differ from get_native_window_size() if hi-dpi is enabled
-static struct size get_native_drawable_size(SDL_Window *window) {
-    int width;
-    int height;
-    SDL_GL_GetDrawableSize(window, &width, &height);
-
-    struct size size;
-    size.width = width;
-    size.height = height;
-    return size;
-}
-
-// return both the native window size and native drawable size
-struct screen_sizes screen_get_sizes(const struct screen *screen) {
-    struct screen_sizes sizes;
-    sizes.window_size = get_native_window_size(screen->window);
-    sizes.drawable_size = get_native_drawable_size(screen->window);
-    return sizes;
-}
-
 // get the windowed window size
 static struct size get_window_size(const struct screen *screen) {
    if (screen->fullscreen) {
@@ -157,13 +134,21 @@ void screen_init(struct screen *screen) {
    *screen = (struct screen) SCREEN_INITIALIZER;
 }

+static inline SDL_Texture *create_texture(SDL_Renderer *renderer, struct size frame_size) {
+    return SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING,
+                             frame_size.width, frame_size.height);
+}
+
 SDL_bool screen_init_rendering(struct screen *screen, const char *device_name, struct size frame_size) {
    screen->frame_size = frame_size;

    struct size window_size = get_initial_optimal_size(frame_size);
+    Uint32 window_flags = SDL_WINDOW_HIDDEN | SDL_WINDOW_RESIZABLE;
+#ifdef HIDPI_SUPPORT
+    window_flags |= SDL_WINDOW_ALLOW_HIGHDPI;
+#endif
    screen->window = SDL_CreateWindow(device_name, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
-                                      window_size.width, window_size.height,
-                                      SDL_WINDOW_HIDDEN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
+                                      window_size.width, window_size.height, window_flags);
    if (!screen->window) {
        LOGC("Could not create window: %s", SDL_GetError());
        return SDL_FALSE;
@@ -192,8 +177,7 @@ SDL_bool screen_init_rendering(struct screen *screen, const char *device_name, s
    SDL_FreeSurface(icon);

    LOGI("Initial texture: %" PRIu16 "x%" PRIu16, frame_size.width, frame_size.height);
-    screen->texture = SDL_CreateTexture(screen->renderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING,
-                                        frame_size.width, frame_size.height);
+    screen->texture = create_texture(screen->renderer, frame_size);
    if (!screen->texture) {
        LOGC("Could not create texture: %s", SDL_GetError());
        screen_destroy(screen);
@@ -242,8 +226,7 @@ static SDL_bool prepare_for_frame(struct screen *screen, struct size new_frame_s

        LOGD("New texture: %" PRIu16 "x%" PRIu16,
                     screen->frame_size.width, screen->frame_size.height);
-        screen->texture = SDL_CreateTexture(screen->renderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING,
-                                            new_frame_size.width, new_frame_size.height);
+        screen->texture = create_texture(screen->renderer, new_frame_size);
        if (!screen->texture) {
            LOGC("Could not create texture: %s", SDL_GetError());
            return SDL_FALSE;
--- a/app/src/screen.h
+++ b/app/src/screen.h
@@ -34,17 +34,8 @@ struct screen {
    .fullscreen = SDL_FALSE,  \
 }

-// the window and drawable size may differ if hi-dpi is enabled
-struct screen_sizes {
-    // the size of the window client area, as reported by SDL_GetWindowSize()
-    struct size window_size;
-    // the size of the window underlying drawable, as reported by
-    // SDL_GL_GetDrawableSize()
-    struct size drawable_size;
-};
-
 // init SDL and set appropriate hints
-SDL_bool sdl_init_and_configure(void);
+SDL_bool sdl_video_init(void);

 // initialize default values
 void screen_init(struct screen *screen);
@@ -75,6 +66,4 @@ void screen_resize_to_fit(struct screen *screen);
 // resize window to 1:1 (pixel-perfect)
 void screen_resize_to_pixel_perfect(struct screen *screen);

-struct screen_sizes screen_get_sizes(const struct screen *screen);
-
 #endif
--- a/app/src/server.c
+++ b/app/src/server.c
@@ -4,6 +4,7 @@
 #include <inttypes.h>
 #include <stdint.h>
 #include <SDL2/SDL_assert.h>
+#include <SDL2/SDL_timer.h>

 #include "config.h"
 #include "log.h"
@@ -37,17 +38,45 @@ static SDL_bool remove_server(const char *serial) {
    return process_check_success(process, "adb shell rm");
 }

-static SDL_bool enable_tunnel(const char *serial, Uint16 local_port) {
+static SDL_bool enable_tunnel_reverse(const char *serial, Uint16 local_port) {
    process_t process = adb_reverse(serial, SOCKET_NAME, local_port);
    return process_check_success(process, "adb reverse");
 }

-static SDL_bool disable_tunnel(const char *serial) {
+static SDL_bool disable_tunnel_reverse(const char *serial) {
    process_t process = adb_reverse_remove(serial, SOCKET_NAME);
    return process_check_success(process, "adb reverse --remove");
 }

-static process_t execute_server(const char *serial, Uint16 max_size, Uint32 bit_rate) {
+static SDL_bool enable_tunnel_forward(const char *serial, Uint16 local_port) {
+    process_t process = adb_forward(serial, local_port, SOCKET_NAME);
+    return process_check_success(process, "adb forward");
+}
+
+static SDL_bool disable_tunnel_forward(const char *serial, Uint16 local_port) {
+    process_t process = adb_forward_remove(serial, local_port);
+    return process_check_success(process, "adb forward --remove");
+}
+
+static SDL_bool enable_tunnel(struct server *server) {
+    if (enable_tunnel_reverse(server->serial, server->local_port)) {
+        return SDL_TRUE;
+    }
+
+    LOGW("'adb reverse' failed, fallback to 'adb forward'");
+    server->tunnel_forward = SDL_TRUE;
+    return enable_tunnel_forward(server->serial, server->local_port);
+}
+
+static SDL_bool disable_tunnel(struct server *server) {
+    if (server->tunnel_forward) {
+        return disable_tunnel_forward(server->serial, server->local_port);
+    }
+    return disable_tunnel_reverse(server->serial);
+}
+
+static process_t execute_server(const char *serial,
+                                Uint16 max_size, Uint32 bit_rate, SDL_bool tunnel_forward) {
    char max_size_string[6];
    char bit_rate_string[11];
    sprintf(max_size_string, "%"PRIu16, max_size);
@@ -60,17 +89,51 @@ static process_t execute_server(const char *serial, Uint16 max_size, Uint32 bit_
        "com.genymobile.scrcpy.Server",
        max_size_string,
        bit_rate_string,
+        tunnel_forward ? "true" : "false",
    };
    return adb_execute(serial, cmd, sizeof(cmd) / sizeof(cmd[0]));
 }

-static socket_t listen_on_port(Uint16 port) {
 #define IPV4_LOCALHOST 0x7F000001
+
+static socket_t listen_on_port(Uint16 port) {
    return net_listen(IPV4_LOCALHOST, port, 1);
 }

+static socket_t connect_and_read_byte(Uint16 port) {
+    socket_t socket = net_connect(IPV4_LOCALHOST, port);
+    if (socket == INVALID_SOCKET) {
+        return INVALID_SOCKET;
+    }
+
+    char byte;
+    // the connection may succeed even if the server behind the "adb tunnel"
+    // is not listening, so read one byte to detect a working connection
+    if (net_recv_all(socket, &byte, 1) != 1) {
+        // the server is not listening yet behind the adb tunnel
+        return INVALID_SOCKET;
+    }
+    return socket;
+}
+
+static socket_t connect_to_server(Uint16 port, Uint32 attempts, Uint32 delay) {
+    do {
+        LOGD("Remaining connection attempts: %d", (int) attempts);
+        socket_t socket = connect_and_read_byte(port);
+        if (socket != INVALID_SOCKET) {
+            // it worked!
+            return socket;
+        }
+        if (attempts) {
+            SDL_Delay(delay);
+        }
+    } while (--attempts > 0);
+    return INVALID_SOCKET;
+}
+
 static void close_socket(socket_t *socket) {
    SDL_assert(*socket != INVALID_SOCKET);
+    net_shutdown(*socket, SHUT_RDWR);
    if (!net_close(*socket)) {
        LOGW("Cannot close socket");
        return;
@@ -84,63 +147,84 @@ void server_init(struct server *server) {

 SDL_bool server_start(struct server *server, const char *serial, Uint16 local_port,
                      Uint16 max_size, Uint32 bit_rate) {
+    server->local_port = local_port;
+
+    if (serial) {
+        server->serial = SDL_strdup(serial);
+    }
+
    if (!push_server(serial)) {
        return SDL_FALSE;
    }

    server->server_copied_to_device = SDL_TRUE;

-    if (!enable_tunnel(serial, local_port)) {
+    if (!enable_tunnel(server)) {
        return SDL_FALSE;
    }

-    // At the application level, the device part is "the server" because it
-    // serves video stream and control. However, at the network level, the
-    // client listens and the server connects to the client. That way, the
-    // client can listen before starting the server app, so there is no need to
-    // try to connect until the server socket is listening on the device.
+    // if "adb reverse" does not work (e.g. over "adb connect"), it fallbacks to
+    // "adb forward", so the app socket is the client
+    if (!server->tunnel_forward) {
+        // At the application level, the device part is "the server" because it
+        // serves video stream and control. However, at the network level, the
+        // client listens and the server connects to the client. That way, the
+        // client can listen before starting the server app, so there is no need to
+        // try to connect until the server socket is listening on the device.

-    server->server_socket = listen_on_port(local_port);
-    if (server->server_socket == INVALID_SOCKET) {
-        LOGE("Could not listen on port %" PRIu16, local_port);
-        disable_tunnel(serial);
-        return SDL_FALSE;
+        server->server_socket = listen_on_port(local_port);
+        if (server->server_socket == INVALID_SOCKET) {
+            LOGE("Could not listen on port %" PRIu16, local_port);
+            disable_tunnel(server);
+            return SDL_FALSE;
+        }
    }

    // server will connect to our server socket
-    server->process = execute_server(serial, max_size, bit_rate);
+    server->process = execute_server(serial, max_size, bit_rate, server->tunnel_forward);
    if (server->process == PROCESS_NONE) {
-        close_socket(&server->server_socket);
-        disable_tunnel(serial);
+        if (!server->tunnel_forward) {
+            close_socket(&server->server_socket);
+        }
+        disable_tunnel(server);
        return SDL_FALSE;
    }

-    server->adb_reverse_enabled = SDL_TRUE;
+    server->tunnel_enabled = SDL_TRUE;

    return SDL_TRUE;
 }

-socket_t server_connect_to(struct server *server, const char *serial, Uint32 timeout_ms) {
-    server->device_socket = net_accept(server->server_socket);
+socket_t server_connect_to(struct server *server) {
+    if (!server->tunnel_forward) {
+        server->device_socket = net_accept(server->server_socket);
+    } else {
+        Uint32 attempts = 50;
+        Uint32 delay = 100; // ms
+        server->device_socket = connect_to_server(server->local_port, attempts, delay);
+    }
+
    if (server->device_socket == INVALID_SOCKET) {
        return INVALID_SOCKET;
    }

-    // we don't need the server socket anymore
-    close_socket(&server->server_socket);
+    if (!server->tunnel_forward) {
+        // we don't need the server socket anymore
+        close_socket(&server->server_socket);
+    }

    // the server is started, we can clean up the jar from the temporary folder
-    remove_server(serial); // ignore failure
+    remove_server(server->serial); // ignore failure
    server->server_copied_to_device = SDL_FALSE;

    // we don't need the adb tunnel anymore
-    disable_tunnel(serial); // ignore failure
-    server->adb_reverse_enabled = SDL_FALSE;
+    disable_tunnel(server); // ignore failure
+    server->tunnel_enabled = SDL_FALSE;

    return server->device_socket;
 }

-void server_stop(struct server *server, const char *serial) {
+void server_stop(struct server *server) {
    SDL_assert(server->process != PROCESS_NONE);

    if (!cmd_terminate(server->process)) {
@@ -150,13 +234,13 @@ void server_stop(struct server *server, const char *serial) {
    cmd_simple_wait(server->process, NULL); // ignore exit code
    LOGD("Server terminated");

-    if (server->adb_reverse_enabled) {
+    if (server->tunnel_enabled) {
        // ignore failure
-        disable_tunnel(serial);
+        disable_tunnel(server);
    }

    if (server->server_copied_to_device) {
-        remove_server(serial); // ignore failure
+        remove_server(server->serial); // ignore failure
    }
 }

@@ -167,4 +251,5 @@ void server_destroy(struct server *server) {
    if (server->device_socket != INVALID_SOCKET) {
        close_socket(&server->device_socket);
    }
+    SDL_free((void *) server->serial);
 }
--- a/app/src/server.h
+++ b/app/src/server.h
@@ -5,18 +5,24 @@
 #include "net.h"

 struct server {
+    const char *serial;
    process_t process;
-    socket_t server_socket;
+    socket_t server_socket; // only used if !tunnel_forward
    socket_t device_socket;
-    SDL_bool adb_reverse_enabled;
+    Uint16 local_port;
+    SDL_bool tunnel_enabled;
+    SDL_bool tunnel_forward; // use "adb forward" instead of "adb reverse"
    SDL_bool server_copied_to_device;
 };

 #define SERVER_INITIALIZER {              \
+    .serial = NULL,                       \
    .process = PROCESS_NONE,              \
    .server_socket = INVALID_SOCKET,      \
    .device_socket = INVALID_SOCKET,      \
-    .adb_reverse_enabled = SDL_FALSE,     \
+    .local_port = 0,                      \
+    .tunnel_enabled = SDL_FALSE,          \
+    .tunnel_forward = SDL_FALSE,          \
    .server_copied_to_device = SDL_FALSE, \
 }

@@ -28,10 +34,10 @@ SDL_bool server_start(struct server *server, const char *serial, Uint16 local_po
                      Uint16 max_size, Uint32 bit_rate);

 // block until the communication with the server is established
-socket_t server_connect_to(struct server *server, const char *serial, Uint32 timeout_ms);
+socket_t server_connect_to(struct server *server);

 // disconnect and kill the server process
-void server_stop(struct server *server, const char *serial);
+void server_stop(struct server *server);

 // close and release sockets
 void server_destroy(struct server *server);
--- a/app/src/sys/unix/command.c
+++ b/app/src/sys/unix/command.c
@@ -1,4 +1,4 @@
-#include "../../command.h"
+#include "command.h"

 #include <signal.h>
 #include <sys/types.h>
@@ -19,6 +19,93 @@ pid_t cmd_execute(const char *path, const char *const argv[]) {
    return pid;
 }

+pid_t cmd_execute_redirect(const char *path, const char *const argv[],
+                           int *pipe_stdin, int *pipe_stdout, int *pipe_stderr) {
+    int in[2];
+    int out[2];
+    int err[2];
+    if (pipe_stdin) {
+        if (pipe(in) == -1) {
+            perror("pipe");
+            return -1;
+        }
+    }
+    if (pipe_stdout) {
+        if (pipe(out) == -1) {
+            perror("pipe");
+            // clean up
+            if (pipe_stdin) {
+                close(in[0]);
+                close(in[1]);
+            }
+            return -1;
+        }
+    }
+    if (pipe_stderr) {
+        if (pipe(err) == -1) {
+            perror("pipe");
+            // clean up
+            if (pipe_stdout) {
+                close(out[0]);
+                close(out[1]);
+            }
+            if (pipe_stdin) {
+                close(in[0]);
+                close(in[1]);
+            }
+            return -1;
+        }
+    }
+
+    pid_t pid = fork();
+    if (pid == -1) {
+        perror("fork");
+        return -1;
+    }
+
+    if (pid == 0) {
+        if (pipe_stdin) {
+            if (in[0] != STDIN_FILENO) {
+                dup2(in[0], STDIN_FILENO);
+                close(in[0]);
+            }
+            close(in[1]);
+        }
+        if (pipe_stdout) {
+            if (out[1] != STDOUT_FILENO) {
+                dup2(out[1], STDOUT_FILENO);
+                close(out[1]);
+            }
+            close(out[0]);
+        }
+        if (pipe_stderr) {
+            if (err[1] != STDERR_FILENO) {
+                dup2(err[1], STDERR_FILENO);
+                close(err[1]);
+            }
+            close(err[0]);
+        }
+        execvp(path, (char *const *)argv);
+        perror("exec");
+        _exit(1);
+    }
+
+    if (pipe_stdin) {
+        close(in[0]);
+        *pipe_stdin = in[1];
+    }
+    if (pipe_stdout) {
+        *pipe_stdout = out[0];
+        close(out[1]);
+    }
+    if (pipe_stderr) {
+        *pipe_stderr = err[0];
+        close(err[1]);
+    }
+
+    return pid;
+}
+
 SDL_bool cmd_terminate(pid_t pid) {
    return kill(pid, SIGTERM) != -1;
 }
@@ -37,3 +124,13 @@ SDL_bool cmd_simple_wait(pid_t pid, int *exit_code) {
    }
    return !code;
 }
+
+int read_pipe(int pipe, char *data, size_t len) {
+    return read(pipe, data, len);
+}
+
+void close_pipe(int pipe) {
+    if (close(pipe)) {
+        perror("close pipe");
+    }
+}
--- a/app/src/sys/unix/net.c
+++ b/app/src/sys/unix/net.c
@@ -1,4 +1,4 @@
-#include "../../net.h"
+#include "net.h"

 # include <unistd.h>

--- a/app/src/sys/win/command.c
+++ b/app/src/sys/win/command.c
@@ -1,7 +1,20 @@
-#include "../../command.h"
+#include "command.h"

-#include "../../log.h"
-#include "../../strutil.h"
+#include "log.h"
+#include "strutil.h"
+
+static int build_cmd(char *cmd, size_t len, const char *const argv[]) {
+    // Windows command-line parsing is WTF:
+    // <http://daviddeley.com/autohotkey/parameters/parameters.htm#WINPASS>
+    // only make it work for this very specific program
+    // (don't handle escaping nor quotes)
+    size_t ret = xstrjoin(cmd, argv, ' ', len);
+    if (ret >= len) {
+        LOGE("Command too long (%" PRIsizet " chars)", len - 1);
+        return -1;
+    }
+    return 0;
+}

 HANDLE cmd_execute(const char *path, const char *const argv[]) {
    STARTUPINFO si;
@@ -9,14 +22,8 @@ HANDLE cmd_execute(const char *path, const char *const argv[]) {
    memset(&si, 0, sizeof(si));
    si.cb = sizeof(si);

-    // Windows command-line parsing is WTF:
-    // <http://daviddeley.com/autohotkey/parameters/parameters.htm#WINPASS>
-    // only make it work for this very specific program
-    // (don't handle escaping nor quotes)
    char cmd[256];
-    size_t ret = xstrjoin(cmd, argv, ' ', sizeof(cmd));
-    if (ret >= sizeof(cmd)) {
-        LOGE("Command too long (%" PRIsizet " chars)", sizeof(cmd) - 1);
+    if (build_cmd(cmd, sizeof(cmd), argv)) {
        return NULL;
    }

@@ -27,6 +34,75 @@ HANDLE cmd_execute(const char *path, const char *const argv[]) {
    return pi.hProcess;
 }

+HANDLE cmd_execute_redirect(const char *path, const char *const argv[],
+                            HANDLE *pipe_stdin, HANDLE *pipe_stdout, HANDLE *pipe_stderr) {
+    SECURITY_ATTRIBUTES sa;
+    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
+    sa.lpSecurityDescriptor = NULL;
+    sa.bInheritHandle = TRUE;
+
+    HANDLE stdin_read_handle;
+    HANDLE stdout_write_handle;
+    HANDLE stderr_write_handle;
+    if (pipe_stdin) {
+        if (!CreatePipe(&stdin_read_handle, pipe_stdin, &sa, 0)) {
+             perror("pipe");
+             return NULL;
+        }
+    }
+    if (pipe_stdout) {
+        if (!CreatePipe(pipe_stdout, &stdout_write_handle, &sa, 0)) {
+             perror("pipe");
+             // clean up
+             if (pipe_stdin) {
+                CloseHandle(&stdin_read_handle);
+                CloseHandle(pipe_stdin);
+             }
+             return NULL;
+        }
+    }
+    if (pipe_stderr) {
+        if (!CreatePipe(pipe_stderr, &stderr_write_handle, &sa, 0)) {
+            perror("pipe");
+            // clean up
+             if (pipe_stdin) {
+                CloseHandle(&stdin_read_handle);
+                CloseHandle(pipe_stdin);
+             }
+            if (pipe_stdout) {
+                CloseHandle(pipe_stdout);
+                CloseHandle(&stdout_write_handle);
+            }
+        }
+    }
+
+    STARTUPINFO si;
+    PROCESS_INFORMATION pi;
+    memset(&si, 0, sizeof(si));
+    si.cb = sizeof(si);
+    si.dwFlags = STARTF_USESTDHANDLES;
+    if (pipe_stdin) {
+        si.hStdInput = stdin_read_handle;
+    }
+    if (pipe_stdout) {
+        si.hStdOutput = stdout_write_handle;
+    }
+    if (pipe_stderr) {
+        si.hStdError = stderr_write_handle;
+    }
+
+    char cmd[256];
+    if (build_cmd(cmd, sizeof(cmd), argv)) {
+        return NULL;
+    }
+
+    if (!CreateProcess(NULL, cmd, NULL, NULL, TRUE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi)) {
+        return NULL;
+    }
+
+    return pi.hProcess;
+}
+
 SDL_bool cmd_terminate(HANDLE handle) {
    return TerminateProcess(handle, 1) && CloseHandle(handle);
 }
@@ -42,3 +118,17 @@ SDL_bool cmd_simple_wait(HANDLE handle, DWORD *exit_code) {
    }
    return !code;
 }
+
+int read_pipe(HANDLE pipe, char *data, size_t len) {
+    DWORD r;
+    if (!ReadFile(pipe, data, len, &r, NULL)) {
+        return -1;
+    }
+    return r;
+}
+
+void close_pipe(HANDLE pipe) {
+    if (!CloseHandle(pipe)) {
+        LOGW("Cannot close pipe");
+    }
+}
--- a/app/src/sys/win/net.c
+++ b/app/src/sys/win/net.c
@@ -1,6 +1,6 @@
-#include "../../net.h"
+#include "net.h"

-#include "../../log.h"
+#include "log.h"

 SDL_bool net_init(void) {
    WSADATA wsa;
--- a/app/tests/test_control_event_serialize.c
+++ b/app/tests/test_control_event_serialize.c
@@ -35,16 +35,36 @@ static void test_serialize_text_event() {

    unsigned char buf[SERIALIZED_EVENT_MAX_SIZE];
    int size = control_event_serialize(&event, buf);
-    assert(size == 15);
+    assert(size == 16);

    const unsigned char expected[] = {
        0x01, // CONTROL_EVENT_TYPE_KEYCODE
-        0x0d, // text length
+        0x00, 0x0d, // text length
        'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', // text
    };
    assert(!memcmp(buf, expected, sizeof(expected)));
 }

+static void test_serialize_long_text_event() {
+    struct control_event event;
+    event.type = CONTROL_EVENT_TYPE_TEXT;
+    char text[TEXT_MAX_LENGTH];
+    memset(text, 'a', sizeof(text));
+    event.text_event.text = text;
+
+    unsigned char buf[SERIALIZED_EVENT_MAX_SIZE];
+    int size = control_event_serialize(&event, buf);
+    assert(size == 3 + sizeof(text));
+
+    unsigned char expected[3 + TEXT_MAX_LENGTH];
+    expected[0] = 0x01; // CONTROL_EVENT_TYPE_KEYCODE
+    expected[1] = 0x01;
+    expected[2] = 0x2c; // text length (16 bits)
+    memset(&expected[3], 'a', TEXT_MAX_LENGTH);
+
+    assert(!memcmp(buf, expected, sizeof(expected)));
+}
+
 static void test_serialize_mouse_event() {
    struct control_event event = {
        .type = CONTROL_EVENT_TYPE_MOUSE,
@@ -114,6 +134,7 @@ static void test_serialize_scroll_event() {
 int main() {
    test_serialize_keycode_event();
    test_serialize_text_event();
+    test_serialize_long_text_event();
    test_serialize_mouse_event();
    test_serialize_scroll_event();
    return 0;
--- a/assets/screenshot-debian-600.jpg
+++ b/assets/screenshot-debian-600.jpg
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -3,3 +3,5 @@ option('build_server', type: 'boolean', value: true, description: 'Build the ser
 option('prebuilt_server', type: 'string', description: 'Path of the prebuilt server')
 option('override_server_path', type: 'string', description: 'Hardcoded path to find the server at runtime')
 option('skip_frames', type: 'boolean', value: true, description: 'Always display the most recent frame')
+option('hidpi_support', type: 'boolean', value: true, description: 'Enable High DPI support')
+option('audio_support', type: 'boolean', value: true, description: 'Enable audio support')
--- a/server/build.gradle
+++ b/server/build.gradle
@@ -6,8 +6,8 @@ android {
        applicationId "com.genymobile.scrcpy"
        minSdkVersion 21
        targetSdkVersion 27
-        versionCode 1
-        versionName "1.0"
+        versionCode 2
+        versionName "1.1"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
--- a/server/src/main/java/com/genymobile/scrcpy/ControlEvent.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ControlEvent.java
@@ -11,7 +11,7 @@ public final class ControlEvent {
    public static final int TYPE_SCROLL = 3;
    public static final int TYPE_COMMAND = 4;

-    public static final int COMMAND_SCREEN_ON = 0;
+    public static final int COMMAND_BACK_OR_SCREEN_ON = 0;

    private int type;
    private String text;
--- a/server/src/main/java/com/genymobile/scrcpy/ControlEventReader.java
+++ b/server/src/main/java/com/genymobile/scrcpy/ControlEventReader.java
@@ -13,12 +13,12 @@ public class ControlEventReader {
    private static final int SCROLL_PAYLOAD_LENGTH = 16;
    private static final int COMMAND_PAYLOAD_LENGTH = 1;

-    private static final int MAX_TEXT_LENGTH = 32;
-    private static final int RAW_BUFFER_SIZE = 128;
+    public static final int TEXT_MAX_LENGTH = 300;
+    private static final int RAW_BUFFER_SIZE = 1024;

    private final byte[] rawBuffer = new byte[RAW_BUFFER_SIZE];
    private final ByteBuffer buffer = ByteBuffer.wrap(rawBuffer);
-    private final byte[] textBuffer = new byte[MAX_TEXT_LENGTH];
+    private final byte[] textBuffer = new byte[TEXT_MAX_LENGTH];

    public ControlEventReader() {
        // invariant: the buffer is always in "get" mode
@@ -94,7 +94,7 @@ public class ControlEventReader {
        if (buffer.remaining() < 1) {
            return null;
        }
-        int len = toUnsigned(buffer.get());
+        int len = toUnsigned(buffer.getShort());
        if (buffer.remaining() < len) {
            return null;
        }
--- a/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java
+++ b/server/src/main/java/com/genymobile/scrcpy/DesktopConnection.java
@@ -1,5 +1,6 @@
 package com.genymobile.scrcpy;

+import android.net.LocalServerSocket;
 import android.net.LocalSocket;
 import android.net.LocalSocketAddress;

@@ -33,8 +34,24 @@ public final class DesktopConnection implements Closeable {
        return localSocket;
    }

-    public static DesktopConnection open(Device device) throws IOException {
-        LocalSocket socket = connect(SOCKET_NAME);
+    private static LocalSocket listenAndAccept(String abstractName) throws IOException {
+        LocalServerSocket localServerSocket = new LocalServerSocket(abstractName);
+        try {
+            return localServerSocket.accept();
+        } finally {
+            localServerSocket.close();
+        }
+    }
+
+    public static DesktopConnection open(Device device, boolean tunnelForward) throws IOException {
+        LocalSocket socket;
+        if (tunnelForward) {
+            socket = listenAndAccept(SOCKET_NAME);
+            // send one byte so the client may read() to detect a connection error
+            socket.getOutputStream().write(0);
+        } else {
+            socket = connect(SOCKET_NAME);
+        }

        DesktopConnection connection = new DesktopConnection(socket);
        Size videoSize = device.getScreenInfo().getVideoSize();
--- a/server/src/main/java/com/genymobile/scrcpy/Device.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Device.java
@@ -50,8 +50,8 @@ public final class Device {
        DisplayInfo displayInfo = serviceManager.getDisplayManager().getDisplayInfo();
        boolean rotated = (displayInfo.getRotation() & 1) != 0;
        Size deviceSize = displayInfo.getSize();
-        int w = deviceSize.getWidth();
-        int h = deviceSize.getHeight();
+        int w = deviceSize.getWidth() & ~7; // in case it's not a multiple of 8
+        int h = deviceSize.getHeight() & ~7;
        if (maxSize > 0) {
            if (BuildConfig.DEBUG && maxSize % 8 != 0) {
                throw new AssertionError("Max size must be a multiple of 8");
--- a/server/src/main/java/com/genymobile/scrcpy/EventController.java
+++ b/server/src/main/java/com/genymobile/scrcpy/EventController.java
@@ -39,10 +39,6 @@ public class EventController {
        coords.orientation = 0;
        coords.pressure = 1;
        coords.size = 1;
-        coords.toolMajor = 1;
-        coords.toolMinor = 1;
-        coords.touchMajor = 1;
-        coords.touchMinor = 1;
    }

    private void setPointerCoords(Point point) {
@@ -93,14 +89,12 @@ public class EventController {
        return injectKeyEvent(action, keycode, 0, metaState);
    }

-    private boolean injectText(String text) {
-        return injectText(text, true);
-    }
-
-    private boolean injectText(String text, boolean decomposeOnFailure) {
-        KeyEvent[] events = charMap.getEvents(text.toCharArray());
+    private boolean injectChar(char c) {
+        String decomposed = KeyComposition.decompose(c);
+        char[] chars = decomposed != null ? decomposed.toCharArray() : new char[] {c};
+        KeyEvent[] events = charMap.getEvents(chars);
        if (events == null) {
-            return decomposeOnFailure ? injectDecomposition(text) : false;
+            return false;
        }
        for (KeyEvent event : events) {
            if (!injectEvent(event)) {
@@ -110,10 +104,9 @@ public class EventController {
        return true;
    }

-    private boolean injectDecomposition(String text) {
+    private boolean injectText(String text) {
        for (char c : text.toCharArray()) {
-            String composedText = KeyComposition.decompose(c);
-            if (composedText == null || !injectText(composedText, false)) {
+            if (!injectChar(c)) {
                return false;
            }
        }
@@ -170,10 +163,15 @@ public class EventController {
        return device.isScreenOn() || injectKeycode(KeyEvent.KEYCODE_POWER);
    }

+    private boolean pressBackOrTurnScreenOn() {
+        int keycode = device.isScreenOn() ? KeyEvent.KEYCODE_BACK : KeyEvent.KEYCODE_POWER;
+        return injectKeycode(keycode);
+    }
+
    private boolean executeCommand(int action) {
        switch (action) {
-            case ControlEvent.COMMAND_SCREEN_ON:
-                return turnScreenOn();
+            case ControlEvent.COMMAND_BACK_OR_SCREEN_ON:
+                return pressBackOrTurnScreenOn();
            default:
                Ln.w("Unsupported command: " + action);
        }
--- a/server/src/main/java/com/genymobile/scrcpy/KeyComposition.java
+++ b/server/src/main/java/com/genymobile/scrcpy/KeyComposition.java
@@ -11,7 +11,7 @@ import java.util.Map;
 * This is useful for injecting key events to generate the expected character ({@link android.view.KeyCharacterMap#getEvents(char[])}
 * KeyCharacterMap.getEvents()} returns {@code null} with input {@code "é"} but works with input {@code "\u0301e"}).
 * <p>
- * See <a href="https://source.android.com/devices/input/key-character-map-files#key-declarations">diacritical dead key characters</a>.
+ * See <a href="https://source.android.com/devices/input/key-character-map-files#behaviors">diacritical dead key characters</a>.
 */
 public final class KeyComposition {

--- 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;
 public class Options {
    private int maxSize;
    private int bitRate;
+    private boolean tunnelForward;

    public int getMaxSize() {
        return maxSize;
@@ -19,4 +20,12 @@ public class Options {
    public void setBitRate(int bitRate) {
        this.bitRate = bitRate;
    }
+
+    public boolean isTunnelForward() {
+        return tunnelForward;
+    }
+
+    public void setTunnelForward(boolean tunnelForward) {
+        this.tunnelForward = tunnelForward;
+    }
 }
--- a/server/src/main/java/com/genymobile/scrcpy/Server.java
+++ b/server/src/main/java/com/genymobile/scrcpy/Server.java
@@ -10,7 +10,8 @@ public final class Server {

    private static void scrcpy(Options options) throws IOException {
        final Device device = new Device(options);
-        try (DesktopConnection connection = DesktopConnection.open(device)) {
+        boolean tunnelForward = options.isTunnelForward();
+        try (DesktopConnection connection = DesktopConnection.open(device, tunnelForward)) {
            ScreenEncoder screenEncoder = new ScreenEncoder(options.getBitRate());

            // asynchronous
@@ -55,6 +56,13 @@ public final class Server {
        int bitRate = Integer.parseInt(args[1]);
        options.setBitRate(bitRate);

+        if (args.length < 3) {
+            return options;
+        }
+        // use "adb forward" instead of "adb tunnel"? (so the server must listen)
+        boolean tunnelForward = Boolean.parseBoolean(args[2]);
+        options.setTunnelForward(tunnelForward);
+
        return options;
    }

--- a/server/src/test/java/com/genymobile/scrcpy/ControlEventReaderTest.java
+++ b/server/src/test/java/com/genymobile/scrcpy/ControlEventReaderTest.java
@@ -11,6 +11,8 @@ import java.io.ByteArrayOutputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+

 public class ControlEventReaderTest {

@@ -43,8 +45,8 @@ public class ControlEventReaderTest {
        DataOutputStream dos = new DataOutputStream(bos);
        dos.writeByte(ControlEvent.TYPE_TEXT);
        byte[] text = "testé".getBytes(StandardCharsets.UTF_8);
-        dos.writeByte(text.length);
-        dos.write("testé".getBytes(StandardCharsets.UTF_8));
+        dos.writeShort(text.length);
+        dos.write(text);
        byte[] packet = bos.toByteArray();

        reader.readFrom(new ByteArrayInputStream(packet));
@@ -54,6 +56,26 @@ public class ControlEventReaderTest {
        Assert.assertEquals("testé", event.getText());
    }

+    @Test
+    public void testParseLongTextEvent() throws IOException {
+        ControlEventReader reader = new ControlEventReader();
+
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        DataOutputStream dos = new DataOutputStream(bos);
+        dos.writeByte(ControlEvent.TYPE_TEXT);
+        byte[] text = new byte[ControlEventReader.TEXT_MAX_LENGTH];
+        Arrays.fill(text, (byte) 'a');
+        dos.writeShort(text.length);
+        dos.write(text);
+        byte[] packet = bos.toByteArray();
+
+        reader.readFrom(new ByteArrayInputStream(packet));
+        ControlEvent event = reader.next();
+
+        Assert.assertEquals(ControlEvent.TYPE_TEXT, event.getType());
+        Assert.assertEquals(new String(text, StandardCharsets.US_ASCII), event.getText());
+    }
+
    @Test
    public void testParseMouseEvent() throws IOException {
        ControlEventReader reader = new ControlEventReader();