Support Android API 19

Since "adb forward" fallback has been implemented, it is easy to support
API 19.

Replace the incompatible calls related to MediaCodec to use
minSdkVersion 19 instead of 21.

FAQ.md

@@ -15,6 +15,17 @@ When run in `cmd.exe`, the application does not print anything. Even `scrcpy
 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
 
@@ -34,27 +45,6 @@ If you still encounter problems, please see [issue 9].
 [issue 9]: https://github.com/Genymobile/scrcpy/issues/9
 
 
-### The application does not work over `adb connect`
-
-If the device is connected using `adb connect`, then you'll get this error:
-
-    error: more than one device/emulator
-    ERROR: "adb reverse" returned with value 1
-
-We plan to support it in future versions. See [issue 5].
-
-[issue 5]: https://github.com/Genymobile/scrcpy/issues/5
-
-
-### Mouse clicks do not work
-
-On many LG devices, [mouse clicks do not work][issue 18]. We're [working][pr27]
-on it.
-
-[issue 18]: https://github.com/Genymobile/scrcpy/issues/18
-[pr27]: https://github.com/Genymobile/scrcpy/pull/27
-
-
 ### I get a black screen for some applications like Silence
 
 This is expected, they requested to protect the screen.
@@ -68,6 +58,13 @@ 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

README.md

@@ -9,27 +9,28 @@ and _MacOS_.
 
 ## Requirements
 
-The Android part requires at least API 21 (Android 5.0).
+The Android part requires at least API 19 (Android 4.4).
 
-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] and [LibSDL2].
+
 [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
 
 ## Build and install
 
@@ -82,10 +83,10 @@ Two [AUR] packages have been created by users:
 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: bc4bf32600e8548cdce490f94bed5dcba0006cdd38aff95748972e5d9877dd62)_
+ - [`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.0/scrcpy-windows-with-deps-v1.0.zip
+[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.)_
 
@@ -124,16 +125,23 @@ Use [Homebrew] to install the packages:
 brew install sdl2 ffmpeg
 
 # client build dependencies
-brew install gcc pkg-config meson
+brew install pkg-config meson
 ```
 
-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`:
+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
 
 Install the [Android SDK] (_Android Studio_), and set `ANDROID_HOME` to
@@ -145,7 +153,14 @@ its directory. For example:
 export ANDROID_HOME=~/android/sdk
 ```
 
-Then, build `scrcpy`:
+Clone the project:
+
+```bash
+git clone https://github.com/Genymobile/scrcpy
+cd scrcpy
+```
+
+Then, build:
 
 ```bash
 meson x --buildtype release --strip -Db_lto=true
@@ -179,10 +194,10 @@ 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-v1.0.jar`][direct-scrcpy-server].  
-   _(SHA-256: b573b06a6072476b85b6308e3ad189f2665ad5be4f8ca3a6b9ec81d64df20558)_
+ - [`scrcpy-server-v1.1.jar`][direct-scrcpy-server].  
+   _(SHA-256: 14826512bf38447ec94adf3b531676ce038d19e7e06757fb4e537882b17e77b3)_
 
-[direct-scrcpy-server]: https://github.com/Genymobile/scrcpy/releases/download/v1.0/scrcpy-server-v1.0.jar
+[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.
 
@@ -232,6 +247,12 @@ If several devices are listed in `adb devices`, you must specify the _serial_:
 scrcpy -s 0123456789abcdef
 ```
 
+To show physical touches while scrcpy is running:
+
+```bash
+scrcpy -t
+```
+
 To run without installing:
 
 ```bash
@@ -250,11 +271,12 @@ To run without installing:
  | 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`+`m`                    |
+ | click on `APP_SWITCH`                  | `Ctrl`+`s`                    |
+ | click on `MENU`                        | `Ctrl`+`m`                    |
  | click on `VOLUME_UP`                   | `Ctrl`+`+`                    |
  | click on `VOLUME_DOWN`                 | `Ctrl`+`-`                    |
  | click on `POWER`                       | `Ctrl`+`p`                    |
- | turn screen on                         | _Right-click¹_                |
+ | turn screen on                         | _Right-click²_                |
  | paste computer clipboard to device     | `Ctrl`+`v`                    |
  | enable/disable FPS counter (on stdout) | `Ctrl`+`i`                    |
 
@@ -300,6 +322,7 @@ Read the [developers page].
     See the License for the specific language governing permissions and
     limitations under the License.
 
-## Article
+## 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/)

app/meson.build

@@ -85,7 +85,8 @@ conf.set('HIDPI_SUPPORT', get_option('hidpi_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
@@ -96,8 +97,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)

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() {

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"

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)
 

app/src/convert.c

@@ -145,8 +145,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;
 }

app/src/decoder.c

@@ -91,7 +91,7 @@ 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)
@@ -125,6 +125,10 @@ static int run_decoder(void *data) {
         }
 #endif
         av_packet_unref(&packet);
+
+        if (avio_ctx->eof_reached) {
+            break;
+        }
     }
 
     LOGD("End of frames");

app/src/inputmanager.c

@@ -78,6 +78,10 @@ static inline void action_volume_down(struct controller *controller) {
     send_keycode(controller, AKEYCODE_VOLUME_DOWN, "VOLUME_DOWN");
 }
 
+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;
@@ -176,9 +180,12 @@ 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;
@@ -240,10 +247,11 @@ void input_manager_process_mouse_button(struct input_manager *input_manager,
             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;
+            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;
@@ -263,7 +271,7 @@ void input_manager_process_mouse_wheel(struct input_manager *input_manager,
     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");
         }
     }
 }

app/src/main.c

@@ -12,6 +12,7 @@ struct args {
     const char *serial;
     SDL_bool help;
     SDL_bool version;
+    SDL_bool show_touches;
     Uint16 port;
     Uint16 max_size;
     Uint32 bit_rate;
@@ -45,6 +46,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"
@@ -70,9 +75,12 @@ static void usage(const char *arg0) {
         "    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+m\n"
+        "        click on MENU\n"
+        "\n"
         "    Ctrl+'+'\n"
         "        click on VOLUME_UP\n"
         "\n"
@@ -180,47 +188,45 @@ 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  },
+        {"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) {
+    while ((c = getopt_long(argc, argv, "b:hm:p:s:tv", long_options, NULL)) != -1) {
         switch (c) {
-            case 'b': {
+            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;
@@ -246,6 +252,7 @@ int main(int argc, char *argv[]) {
         .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,
@@ -274,7 +281,14 @@ 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,
+    };
+    int res = scrcpy(&options) ? 0 : 1;
 
     avformat_network_deinit(); // ignore failure
 

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>

app/src/scrcpy.c

@@ -79,16 +79,15 @@ 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);
@@ -96,36 +95,56 @@ static void event_loop(void) {
             case SDL_MOUSEMOTION:
                 input_manager_process_mouse_motion(&input_manager, &event.motion);
                 break;
-            case SDL_MOUSEWHEEL: {
+            case SDL_MOUSEWHEEL:
                 input_manager_process_mouse_wheel(&input_manager, &event.wheel);
                 break;
-            }
             case SDL_MOUSEBUTTONDOWN:
-            case SDL_MOUSEBUTTONUP: {
+            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)) {
+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 (!server_start(&server, options->serial, options->port,
+                      options->max_size, options->bit_rate)) {
         return SDL_FALSE;
     }
 
+    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;
+    }
+
     SDL_bool ret = SDL_TRUE;
 
+    if (!SDL_SetHint(SDL_HINT_NO_SIGNAL_HANDLERS, "1")) {
+        LOGW("Cannot request to keep default signal handlers");
+    }
+
     if (!sdl_init_and_configure()) {
         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, SERVER_CONNECT_TIMEOUT_MS);
+    socket_t device_socket = server_connect_to(&server);
     if (device_socket == INVALID_SOCKET) {
         server_stop(&server);
         ret = SDL_FALSE;
@@ -175,10 +194,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);
@@ -192,6 +217,16 @@ finally_stop_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);
 
     return ret;

app/src/scrcpy.h

@@ -3,6 +3,14 @@
 
 #include <SDL2/SDL_stdinc.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;
+};
+
+SDL_bool scrcpy(const struct scrcpy_options *options);
 
 #endif

app/src/screen.c

@@ -136,6 +136,11 @@ 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;
 
@@ -174,8 +179,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);
@@ -224,8 +228,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;

app/src/server.c

@@ -195,11 +195,11 @@ SDL_bool server_start(struct server *server, const char *serial, Uint16 local_po
     return SDL_TRUE;
 }
 
-socket_t server_connect_to(struct server *server, Uint32 timeout_ms) {
+socket_t server_connect_to(struct server *server) {
     if (!server->tunnel_forward) {
         server->device_socket = net_accept(server->server_socket);
     } else {
-        Uint32 attempts = 10;
+        Uint32 attempts = 50;
         Uint32 delay = 100; // ms
         server->device_socket = connect_to_server(server->local_port, attempts, delay);
     }

app/src/server.h

@@ -34,7 +34,7 @@ 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, Uint32 timeout_ms);
+socket_t server_connect_to(struct server *server);
 
 // disconnect and kill the server process
 void server_stop(struct server *server);

app/src/sys/unix/command.c

@@ -1,4 +1,4 @@
-#include "../../command.h"
+#include "command.h"
 
 #include <signal.h>
 #include <sys/types.h>

app/src/sys/unix/net.c

@@ -1,4 +1,4 @@
-#include "../../net.h"
+#include "net.h"
 
 # include <unistd.h>
 

app/src/sys/win/command.c

@@ -1,7 +1,7 @@
-#include "../../command.h"
+#include "command.h"
 
-#include "../../log.h"
-#include "../../strutil.h"
+#include "log.h"
+#include "strutil.h"
 
 HANDLE cmd_execute(const char *path, const char *const argv[]) {
     STARTUPINFO si;

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;

server/build.gradle

@@ -4,7 +4,7 @@ android {
     compileSdkVersion 27
     defaultConfig {
         applicationId "com.genymobile.scrcpy"
-        minSdkVersion 21
+        minSdkVersion 19
         targetSdkVersion 27
         versionCode 2
         versionName "1.1"

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

@@ -6,6 +6,7 @@ import android.graphics.Rect;
 import android.media.MediaCodec;
 import android.media.MediaCodecInfo;
 import android.media.MediaFormat;
+import android.os.Build;
 import android.os.IBinder;
 import android.view.Surface;
 
@@ -77,11 +78,17 @@ public class ScreenEncoder implements Device.RotationListener {
         }
     }
 
+    @SuppressWarnings("deprecation") // Android API 19 requires to call deprecated methods
     private boolean encode(MediaCodec codec, OutputStream outputStream) throws IOException {
         @SuppressWarnings("checkstyle:MagicNumber")
         byte[] buf = new byte[bitRate / 8]; // may contain up to 1 second of video
         boolean eof = false;
         MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
+
+        ByteBuffer[] outputBuffers = null;
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+            outputBuffers = codec.getOutputBuffers();
+        }
         while (!consumeRotationChange() && !eof) {
             int outputBufferId = codec.dequeueOutputBuffer(bufferInfo, -1);
             eof = (bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0;
@@ -91,7 +98,12 @@ public class ScreenEncoder implements Device.RotationListener {
                     break;
                 }
                 if (outputBufferId >= 0) {
-                    ByteBuffer outputBuffer = codec.getOutputBuffer(outputBufferId);
+                    ByteBuffer outputBuffer;
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+                        outputBuffer = codec.getOutputBuffer(outputBufferId);
+                    } else {
+                        outputBuffer = outputBuffers[outputBufferId];
+                    }
                     while (outputBuffer.hasRemaining()) {
                         int remaining = outputBuffer.remaining();
                         int len = Math.min(buf.length, remaining);
@@ -100,6 +112,8 @@ public class ScreenEncoder implements Device.RotationListener {
                         outputBuffer.get(buf, 0, len);
                         outputStream.write(buf, 0, len);
                     }
+                } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP && outputBufferId == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
+                    outputBuffers = codec.getOutputBuffers();
                 }
             } finally {
                 if (outputBufferId >= 0) {