Add developer documentation

And update README.

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

README.md

@@ -50,8 +50,15 @@ Install the required packages from your package manager (here, for Debian):
 
 #### 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.0.zip`][direct-windows-with-deps].  
+   _(SHA-256: TODO)_
+
+[direct-windows-with-deps]: https://github.com/Genymobile/scrcpy/releases/download/v1.0/scrcpy-windows-with-deps-v1.0.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:
@@ -128,7 +135,12 @@ 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.0.jar`][direct-scrcpy-server].  
+   _(SHA-256: TODO)_
+
+[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.0/scrcpy-server-v1.0.jar
 
 In that case, the build does not require Java or the Android SDK.
 
@@ -182,6 +194,7 @@ If several devices are listed in `adb devices`, you must specify the _serial_:
  | click on `VOLUME_DOWN`                 | `Ctrl`+`-`    |
  | 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`    |
 
 

app/meson.build

@@ -42,7 +42,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.0')
 
 # the prefix used during configuration (meson --prefix=PREFIX)
 conf.set_quoted('PREFIX', get_option('prefix'))
@@ -80,6 +80,9 @@ 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'))
+
 configure_file(configuration: conf, output: 'config.h')
 
 executable('scrcpy', src, dependencies: dependencies, install: true)

app/src/controlevent.c

@@ -36,10 +36,11 @@ 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);
+            memcpy(&buf[2], event->text_event.text, len);
             return 2 + len;
         }
         case CONTROL_EVENT_TYPE_MOUSE:
@@ -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) {

app/src/controlevent.h

@@ -10,7 +10,7 @@
 
 #define CONTROL_EVENT_QUEUE_SIZE 64
 #define SERIALIZED_EVENT_MAX_SIZE 33
-#define TEXT_MAX_LENGTH 31
+#define TEXT_MAX_LENGTH 256
 
 enum control_event_type {
     CONTROL_EVENT_TYPE_KEYCODE,
@@ -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

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;
             }

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;
     }
 
@@ -100,7 +94,21 @@ static int run_decoder(void *data) {
     while (!av_read_frame(format_ctx, &packet) && !avio_ctx->eof_reached) {
 // 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);
+            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,18 +122,6 @@ 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
     }
 
@@ -142,7 +138,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) {

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,
@@ -22,14 +36,11 @@ static SDL_bool is_ctrl_down(void) {
 
 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);
@@ -68,12 +79,10 @@ static inline void action_volume_down(struct controller *controller) {
 }
 
 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,
-        },
-    };
+    struct control_event control_event;
+    control_event.type = CONTROL_EVENT_TYPE_COMMAND;
+    control_event.command_event.action = CONTROL_EVENT_COMMAND_SCREEN_ON;
+
     if (!controller_push_event(controller, &control_event)) {
         LOGW("Cannot turn screen on");
     }
@@ -91,6 +100,27 @@ static void switch_fps_counter_state(struct frames *frames) {
     mutex_unlock(frames->mutex);
 }
 
+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;
+    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) {
     if (is_ctrl_down()) {
@@ -107,8 +137,11 @@ void input_manager_process_text_input(struct input_manager *input_manager,
 
     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 = 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 +149,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);
@@ -147,6 +181,9 @@ void input_manager_process_key(struct input_manager *input_manager,
             case SDLK_p:
                 action_power(input_manager->controller);
                 return;
+            case SDLK_v:
+                clipboard_paste(input_manager->controller);
+                return;
             case SDLK_f:
                 screen_switch_fullscreen(input_manager->screen);
                 return;
@@ -204,7 +241,7 @@ 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)) {

app/src/main.c

@@ -82,6 +82,9 @@ static void usage(const char *arg0) {
         "    Right-click\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",

app/src/scrcpy.c

@@ -35,21 +35,6 @@ static struct input_manager input_manager = {
     .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;
-    }
-}
-
 static void event_loop(void) {
     SDL_Event event;
     while (SDL_WaitEvent(&event)) {
@@ -87,17 +72,14 @@ static void event_loop(void) {
                 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);
                 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);
                 input_manager_process_mouse_button(&input_manager, &event.button);
                 break;
             }

app/src/screen.c

@@ -45,27 +45,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) {
@@ -161,9 +140,12 @@ SDL_bool screen_init_rendering(struct screen *screen, const char *device_name, s
     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;

app/src/screen.h

@@ -34,15 +34,6 @@ 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);
 
@@ -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

app/src/server.c

@@ -71,6 +71,7 @@ static socket_t listen_on_port(Uint16 port) {
 
 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;

meson_options.txt

@@ -3,3 +3,4 @@ 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')

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 TEXT_MAX_LENGTH = 256;
     private static final int RAW_BUFFER_SIZE = 128;
 
     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

server/src/main/java/com/genymobile/scrcpy/EventController.java

@@ -93,14 +93,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 +108,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;
             }
         }

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 {