Skip to content

Display and control your Android device

Add OTG mode

Romain Vimont91418c79ab3b
diff --git a/app/meson.build b/app/meson.build
index 5497281a..80a0d9d2 100644
--- a/app/meson.build
+++ b/app/meson.build
@@ -78,6 +78,8 @@ if usb_support
'src/usb/aoa_hid.c',
'src/usb/hid_keyboard.c',
'src/usb/hid_mouse.c',
+ 'src/usb/scrcpy_otg.c',
+ 'src/usb/screen_otg.c',
'src/usb/usb.c',
]
endif
diff --git a/app/scrcpy.1 b/app/scrcpy.1
index 37431a91..e8e74f98 100644
--- a/app/scrcpy.1
+++ b/app/scrcpy.1
@@ -162,6 +162,18 @@ Do not forward repeated key events when a key is held down.
.B \-\-no\-mipmaps
If the renderer is OpenGL 3.0+ or OpenGL ES 2.0+, then mipmaps are automatically generated to improve downscaling quality. This option disables the generation of mipmaps.
+.TP
+.B \-\-otg
+Run in OTG mode: simulate physical keyboard and mouse, as if the computer keyboard and mouse were plugged directly to the device via an OTG cable.
+
+In this mode, adb (USB debugging) is not necessary, and mirroring is disabled.
+
+LAlt, LSuper or RSuper toggle the mouse capture mode, to give control of the mouse back to the computer.
+
+It may only work over USB, and is currently only supported on Linux.
+
+See \fB\-\-hid\-keyboard\fR and \fB\-\-hid\-mouse\fR.
+
.TP
.BI "\-p, \-\-port " port[:port]
Set the TCP port (range) used by the client to listen.
diff --git a/app/src/cli.c b/app/src/cli.c
index 34c3103a..28462efd 100644
--- a/app/src/cli.c
+++ b/app/src/cli.c
@@ -53,6 +53,7 @@
#define OPT_TCPIP 1033
#define OPT_RAW_KEY_EVENTS 1034
#define OPT_NO_DOWNSIZE_ON_ERROR 1035
+#define OPT_OTG 1036
struct sc_option {
char shortopt;
@@ -276,6 +277,20 @@ static const struct sc_option options[] = {
"mipmaps are automatically generated to improve downscaling "
"quality. This option disables the generation of mipmaps.",
},
+ {
+ .longopt_id = OPT_OTG,
+ .longopt = "otg",
+ .text = "Run in OTG mode: simulate physical keyboard and mouse, "
+ "as if the computer keyboard and mouse were plugged directly "
+ "to the device via an OTG cable.\n"
+ "In this mode, adb (USB debugging) is not necessary, and "
+ "mirroring is disabled.\n"
+ "LAlt, LSuper or RSuper toggle the mouse capture mode, to give "
+ "control of the mouse back to the computer.\n"
+ "It may only work over USB, and is currently only supported "
+ "on Linux.\n"
+ "See --hid-keyboard and --hid-mouse.",
+ },
{
.shortopt = 'p',
.longopt = "port",
@@ -1500,6 +1515,15 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
case OPT_NO_DOWNSIZE_ON_ERROR:
opts->downsize_on_error = false;
break;
+ case OPT_OTG:
+#ifdef HAVE_USB
+ opts->otg = true;
+ break;
+#else
+ LOGE("OTG mode (--otg) is not supported on this platform. It "
+ "is only available on Linux.");
+ return false;
+#endif
case OPT_V4L2_SINK:
#ifdef HAVE_V4L2
opts->v4l2_device = optarg;
@@ -1610,6 +1634,43 @@ parse_args_with_getopt(struct scrcpy_cli_args *args, int argc, char *argv[],
}
}
+#ifdef HAVE_USB
+ if (opts->otg) {
+ // OTG mode is compatible with only very few options.
+ // Only report obvious errors.
+ if (opts->record_filename) {
+ LOGE("OTG mode: could not record");
+ return false;
+ }
+ if (opts->turn_screen_off) {
+ LOGE("OTG mode: could not turn screen off");
+ return false;
+ }
+ if (opts->stay_awake) {
+ LOGE("OTG mode: could not stay awake");
+ return false;
+ }
+ if (opts->show_touches) {
+ LOGE("OTG mode: could not request to show touches");
+ return false;
+ }
+ if (opts->power_off_on_close) {
+ LOGE("OTG mode: could not request power off on close");
+ return false;
+ }
+ if (opts->display_id) {
+ LOGE("OTG mode: could not select display");
+ return false;
+ }
+#ifdef HAVE_V4L2
+ if (opts->v4l2_device) {
+ LOGE("OTG mode: could not sink to V4L2 device");
+ return false;
+ }
+#endif
+ }
+#endif
+
return true;
}
diff --git a/app/src/events.h b/app/src/events.h
index abe1a72c..3c14f96e 100644
--- a/app/src/events.h
+++ b/app/src/events.h
@@ -2,3 +2,4 @@
#define EVENT_STREAM_STOPPED (SDL_USEREVENT + 1)
#define EVENT_SERVER_CONNECTION_FAILED (SDL_USEREVENT + 2)
#define EVENT_SERVER_CONNECTED (SDL_USEREVENT + 3)
+#define EVENT_USB_DEVICE_DISCONNECTED (SDL_USEREVENT + 4)
diff --git a/app/src/main.c b/app/src/main.c
index cbcef4a7..8a8c029c 100644
--- a/app/src/main.c
+++ b/app/src/main.c
@@ -13,6 +13,7 @@
#include "cli.h"
#include "options.h"
#include "scrcpy.h"
+#include "usb/scrcpy_otg.h"
#include "util/log.h"
static void
@@ -88,9 +89,14 @@ main(int argc, char *argv[]) {
return 1;
}
- int res = scrcpy(&args.opts) ? 0 : 1;
+#ifdef HAVE_USB
+ bool ok = args.opts.otg ? scrcpy_otg(&args.opts)
+ : scrcpy(&args.opts);
+#else
+ bool ok = scrcpy(&args.opts);
+#endif
avformat_network_deinit(); // ignore failure
- return res;
+ return ok ? 0 : 1;
}
diff --git a/app/src/options.c b/app/src/options.c
index b8560406..c94f798d 100644
--- a/app/src/options.c
+++ b/app/src/options.c
@@ -37,6 +37,9 @@ const struct scrcpy_options scrcpy_options_default = {
.display_id = 0,
.display_buffer = 0,
.v4l2_buffer = 0,
+#ifdef HAVE_USB
+ .otg = false,
+#endif
.show_touches = false,
.fullscreen = false,
.always_on_top = false,
diff --git a/app/src/options.h b/app/src/options.h
index 99f03d40..1591a065 100644
--- a/app/src/options.h
+++ b/app/src/options.h
@@ -112,6 +112,9 @@ struct scrcpy_options {
uint32_t display_id;
sc_tick display_buffer;
sc_tick v4l2_buffer;
+#ifdef HAVE_USB
+ bool otg;
+#endif
bool show_touches;
bool fullscreen;
bool always_on_top;
diff --git a/app/src/usb/scrcpy_otg.c b/app/src/usb/scrcpy_otg.c
new file mode 100644
index 00000000..0a28eda4
--- /dev/null
+++ b/app/src/usb/scrcpy_otg.c
@@ -0,0 +1,213 @@
+#include "scrcpy_otg.h"
+
+#include <SDL2/SDL.h>
+
+#include "events.h"
+#include "screen_otg.h"
+#include "util/log.h"
+
+struct scrcpy_otg {
+ struct sc_usb usb;
+ struct sc_aoa aoa;
+ struct sc_hid_keyboard keyboard;
+ struct sc_hid_mouse mouse;
+
+ struct sc_screen_otg screen_otg;
+};
+
+static void
+sc_usb_on_disconnected(struct sc_usb *usb, void *userdata) {
+ (void) usb;
+ (void) userdata;
+
+ SDL_Event event;
+ event.type = EVENT_USB_DEVICE_DISCONNECTED;
+ int ret = SDL_PushEvent(&event);
+ if (ret < 0) {
+ LOGE("Could not post USB disconnection event: %s", SDL_GetError());
+ }
+}
+
+static bool
+event_loop(struct scrcpy_otg *s) {
+ SDL_Event event;
+ while (SDL_WaitEvent(&event)) {
+ switch (event.type) {
+ case EVENT_USB_DEVICE_DISCONNECTED:
+ LOGW("Device disconnected");
+ return false;
+ case SDL_QUIT:
+ LOGD("User requested to quit");
+ return true;
+ default:
+ sc_screen_otg_handle_event(&s->screen_otg, &event);
+ break;
+ }
+ }
+ return false;
+}
+
+bool
+scrcpy_otg(struct scrcpy_options *options) {
+ static struct scrcpy_otg scrcpy_otg;
+ struct scrcpy_otg *s = &scrcpy_otg;
+
+ const char *serial = options->serial;
+
+ // Minimal SDL initialization
+ if (SDL_Init(SDL_INIT_EVENTS)) {
+ LOGC("Could not initialize SDL: %s", SDL_GetError());
+ return false;
+ }
+
+ atexit(SDL_Quit);
+
+ bool ret = false;
+
+ struct sc_hid_keyboard *keyboard = NULL;
+ struct sc_hid_mouse *mouse = NULL;
+ bool usb_device_initialized = false;
+ bool usb_connected = false;
+ bool aoa_started = false;
+ bool aoa_initialized = false;
+
+ static const struct sc_usb_callbacks cbs = {
+ .on_disconnected = sc_usb_on_disconnected,
+ };
+ bool ok = sc_usb_init(&s->usb);
+ if (!ok) {
+ return false;
+ }
+
+ struct sc_usb_device usb_devices[16];
+ ssize_t count = sc_usb_find_devices(&s->usb, serial, usb_devices,
+ ARRAY_LEN(usb_devices));
+ if (count < 0) {
+ LOGE("Could not list USB devices");
+ goto end;
+ }
+
+ if (count == 0) {
+ if (serial) {
+ LOGE("Could not find USB device %s", serial);
+ } else {
+ LOGE("Could not find any USB device");
+ }
+ goto end;
+ }
+
+ if (count > 1) {
+ if (serial) {
+ LOGE("Multiple (%d) USB devices with serial %s:", (int) count,
+ serial);
+ } else {
+ LOGE("Multiple (%d) USB devices:", (int) count);
+ }
+ for (size_t i = 0; i < (size_t) count; ++i) {
+ struct sc_usb_device *d = &usb_devices[i];
+ LOGE(" %-18s (%04" PRIx16 ":%04" PRIx16 ") %s %s",
+ d->serial, d->vid, d->pid, d->manufacturer, d->product);
+ }
+ if (!serial) {
+ LOGE("Specify the device via -s or --serial");
+ }
+ sc_usb_device_destroy_all(usb_devices, count);
+ goto end;
+ }
+ usb_device_initialized = true;
+
+ struct sc_usb_device *usb_device = &usb_devices[0];
+
+ LOGI("USB device: %s (%04" PRIx16 ":%04" PRIx16 ") %s %s",
+ usb_device->serial, usb_device->vid, usb_device->pid,
+ usb_device->manufacturer, usb_device->product);
+
+ ok = sc_usb_connect(&s->usb, usb_device->device, &cbs, NULL);
+ if (!ok) {
+ goto end;
+ }
+ usb_connected = true;
+
+ ok = sc_aoa_init(&s->aoa, &s->usb, NULL);
+ if (!ok) {
+ goto end;
+ }
+ aoa_initialized = true;
+
+ ok = sc_hid_keyboard_init(&s->keyboard, &s->aoa);
+ if (!ok) {
+ goto end;
+ }
+ keyboard = &s->keyboard;
+
+ ok = sc_hid_mouse_init(&s->mouse, &s->aoa);
+ if (!ok) {
+ goto end;
+ }
+ mouse = &s->mouse;
+
+ ok = sc_aoa_start(&s->aoa);
+ if (!ok) {
+ goto end;
+ }
+ aoa_started = true;
+
+ const char *window_title = options->window_title;
+ if (!window_title) {
+ window_title = usb_device->product ? usb_device->product : "scrcpy";
+ }
+
+ struct sc_screen_otg_params params = {
+ .keyboard = keyboard,
+ .mouse = mouse,
+ .window_title = window_title,
+ .always_on_top = options->always_on_top,
+ .window_x = options->window_x,
+ .window_y = options->window_y,
+ .window_borderless = options->window_borderless,
+ };
+
+ ok = sc_screen_otg_init(&s->screen_otg, &params);
+ if (!ok) {
+ goto end;
+ }
+
+ // usb_device not needed anymore
+ sc_usb_device_destroy(usb_device);
+ usb_device_initialized = false;
+
+ ret = event_loop(s);
+ LOGD("quit...");
+
+end:
+ if (aoa_started) {
+ sc_aoa_stop(&s->aoa);
+ }
+ sc_usb_stop(&s->usb);
+
+ if (mouse) {
+ sc_hid_mouse_destroy(&s->mouse);
+ }
+ if (keyboard) {
+ sc_hid_keyboard_destroy(&s->keyboard);
+ }
+
+ if (aoa_initialized) {
+ sc_aoa_join(&s->aoa);
+ sc_aoa_destroy(&s->aoa);
+ }
+
+ sc_usb_join(&s->usb);
+
+ if (usb_connected) {
+ sc_usb_disconnect(&s->usb);
+ }
+
+ if (usb_device_initialized) {
+ sc_usb_device_destroy(usb_device);
+ }
+
+ sc_usb_destroy(&s->usb);
+
+ return ret;
+}
diff --git a/app/src/usb/scrcpy_otg.h b/app/src/usb/scrcpy_otg.h
new file mode 100644
index 00000000..24b9cde8
--- /dev/null
+++ b/app/src/usb/scrcpy_otg.h
@@ -0,0 +1,12 @@
+#ifndef SCRCPY_OTG_H
+#define SCRCPY_OTG_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include "options.h"
+
+bool
+scrcpy_otg(struct scrcpy_options *options);
+
+#endif
diff --git a/app/src/usb/screen_otg.c b/app/src/usb/screen_otg.c
new file mode 100644
index 00000000..a4b37264
--- /dev/null
+++ b/app/src/usb/screen_otg.c
@@ -0,0 +1,254 @@
+#include "screen_otg.h"
+
+#include "icon.h"
+#include "options.h"
+#include "util/log.h"
+
+static void
+sc_screen_otg_capture_mouse(struct sc_screen_otg *screen, bool capture) {
+ if (SDL_SetRelativeMouseMode(capture)) {
+ LOGE("Could not set relative mouse mode to %s: %s",
+ capture ? "true" : "false", SDL_GetError());
+ return;
+ }
+
+ screen->mouse_captured = capture;
+}
+
+static void
+sc_screen_otg_render(struct sc_screen_otg *screen) {
+ SDL_RenderClear(screen->renderer);
+ if (screen->texture) {
+ SDL_RenderCopy(screen->renderer, screen->texture, NULL, NULL);
+ }
+ SDL_RenderPresent(screen->renderer);
+}
+
+bool
+sc_screen_otg_init(struct sc_screen_otg *screen,
+ const struct sc_screen_otg_params *params) {
+ screen->keyboard = params->keyboard;
+ screen->mouse = params->mouse;
+
+ screen->mouse_captured = false;
+ screen->mouse_capture_key_pressed = 0;
+
+ const char *title = params->window_title;
+ assert(title);
+
+ int x = params->window_x != SC_WINDOW_POSITION_UNDEFINED
+ ? params->window_x : (int) SDL_WINDOWPOS_UNDEFINED;
+ int y = params->window_y != SC_WINDOW_POSITION_UNDEFINED
+ ? params->window_y : (int) SDL_WINDOWPOS_UNDEFINED;
+ int width = 256;
+ int height = 256;
+
+ uint32_t window_flags = 0;
+ if (params->always_on_top) {
+ window_flags |= SDL_WINDOW_ALWAYS_ON_TOP;
+ }
+ if (params->window_borderless) {
+ window_flags |= SDL_WINDOW_BORDERLESS;
+ }
+
+ screen->window = SDL_CreateWindow(title, x, y, width, height, window_flags);
+ if (!screen->window) {
+ LOGE("Could not create window: %s", SDL_GetError());
+ return false;
+ }
+
+ screen->renderer = SDL_CreateRenderer(screen->window, -1, 0);
+ if (!screen->renderer) {
+ LOGE("Could not create renderer: %s", SDL_GetError());
+ goto error_destroy_window;
+ }
+
+ SDL_Surface *icon = scrcpy_icon_load();
+
+ if (icon) {
+ SDL_SetWindowIcon(screen->window, icon);
+
+ screen->texture = SDL_CreateTextureFromSurface(screen->renderer, icon);
+ scrcpy_icon_destroy(icon);
+ if (!screen->texture) {
+ goto error_destroy_renderer;
+ }
+ } else {
+ screen->texture = NULL;
+ LOGW("Could not load icon");
+ }
+
+ // Capture mouse on start
+ sc_screen_otg_capture_mouse(screen, true);
+
+ return true;
+
+error_destroy_window:
+ SDL_DestroyWindow(screen->window);
+error_destroy_renderer:
+ SDL_DestroyRenderer(screen->renderer);
+
+ return false;
+}
+
+void
+sc_screen_otg_destroy(struct sc_screen_otg *screen) {
+ if (screen->texture) {
+ SDL_DestroyTexture(screen->texture);
+ }
+ SDL_DestroyRenderer(screen->renderer);
+ SDL_DestroyWindow(screen->window);
+}
+
+static inline bool
+sc_screen_otg_is_mouse_capture_key(SDL_Keycode key) {
+ return key == SDLK_LALT || key == SDLK_LGUI || key == SDLK_RGUI;
+}
+
+static void
+sc_screen_otg_process_key(struct sc_screen_otg *screen,
+ const SDL_KeyboardEvent *event) {
+ assert(screen->keyboard);
+ struct sc_key_processor *kp = &screen->keyboard->key_processor;
+
+ struct sc_key_event evt = {
+ .action = sc_action_from_sdl_keyboard_type(event->type),
+ .keycode = sc_keycode_from_sdl(event->keysym.sym),
+ .scancode = sc_scancode_from_sdl(event->keysym.scancode),
+ .repeat = event->repeat,
+ .mods_state = sc_mods_state_from_sdl(event->keysym.mod),
+ };
+
+ assert(kp->ops->process_key);
+ kp->ops->process_key(kp, &evt, SC_SEQUENCE_INVALID);
+}
+
+static void
+sc_screen_otg_process_mouse_motion(struct sc_screen_otg *screen,
+ const SDL_MouseMotionEvent *event) {
+ assert(screen->mouse);
+ struct sc_mouse_processor *mp = &screen->mouse->mouse_processor;
+
+ struct sc_mouse_motion_event evt = {
+ // .position not used for HID events
+ .xrel = event->xrel,
+ .yrel = event->yrel,
+ .buttons_state = sc_mouse_buttons_state_from_sdl(event->state, true),
+ };
+
+ assert(mp->ops->process_mouse_motion);
+ mp->ops->process_mouse_motion(mp, &evt);
+}
+
+static void
+sc_screen_otg_process_mouse_button(struct sc_screen_otg *screen,
+ const SDL_MouseButtonEvent *event) {
+ assert(screen->mouse);
+ struct sc_mouse_processor *mp = &screen->mouse->mouse_processor;
+
+ uint32_t sdl_buttons_state = SDL_GetMouseState(NULL, NULL);
+
+ struct sc_mouse_click_event evt = {
+ // .position not used for HID events
+ .action = sc_action_from_sdl_mousebutton_type(event->type),
+ .button = sc_mouse_button_from_sdl(event->button),
+ .buttons_state =
+ sc_mouse_buttons_state_from_sdl(sdl_buttons_state, true),
+ };
+
+ assert(mp->ops->process_mouse_click);
+ mp->ops->process_mouse_click(mp, &evt);
+}
+
+static void
+sc_screen_otg_process_mouse_wheel(struct sc_screen_otg *screen,
+ const SDL_MouseWheelEvent *event) {
+ assert(screen->mouse);
+ struct sc_mouse_processor *mp = &screen->mouse->mouse_processor;
+
+ uint32_t sdl_buttons_state = SDL_GetMouseState(NULL, NULL);
+
+ struct sc_mouse_scroll_event evt = {
+ // .position not used for HID events
+ .hscroll = event->x,
+ .vscroll = event->y,
+ .buttons_state =
+ sc_mouse_buttons_state_from_sdl(sdl_buttons_state, true),
+ };
+
+ assert(mp->ops->process_mouse_scroll);
+ mp->ops->process_mouse_scroll(mp, &evt);
+}
+
+void
+sc_screen_otg_handle_event(struct sc_screen_otg *screen, SDL_Event *event) {
+ switch (event->type) {
+ case SDL_WINDOWEVENT:
+ switch (event->window.event) {
+ case SDL_WINDOWEVENT_EXPOSED:
+ sc_screen_otg_render(screen);
+ break;
+ case SDL_WINDOWEVENT_FOCUS_LOST:
+ sc_screen_otg_capture_mouse(screen, false);
+ break;
+ }
+ return;
+ case SDL_KEYDOWN: {
+ SDL_Keycode key = event->key.keysym.sym;
+ if (sc_screen_otg_is_mouse_capture_key(key)) {
+ if (!screen->mouse_capture_key_pressed) {
+ screen->mouse_capture_key_pressed = key;
+ } else {
+ // Another mouse capture key has been pressed, cancel mouse
+ // (un)capture
+ screen->mouse_capture_key_pressed = 0;
+ }
+ // Mouse capture keys are never forwarded to the device
+ return;
+ }
+
+ sc_screen_otg_process_key(screen, &event->key);
+ break;
+ }
+ case SDL_KEYUP: {
+ SDL_Keycode key = event->key.keysym.sym;
+ SDL_Keycode cap = screen->mouse_capture_key_pressed;
+ screen->mouse_capture_key_pressed = 0;
+ if (sc_screen_otg_is_mouse_capture_key(key)) {
+ if (key == cap) {
+ // A mouse capture key has been pressed then released:
+ // toggle the capture mouse mode
+ sc_screen_otg_capture_mouse(screen,
+ !screen->mouse_captured);
+ }
+ // Mouse capture keys are never forwarded to the device
+ return;
+ }
+
+ sc_screen_otg_process_key(screen, &event->key);
+ break;
+ }
+ case SDL_MOUSEMOTION:
+ if (screen->mouse_captured) {
+ sc_screen_otg_process_mouse_motion(screen, &event->motion);
+ }
+ break;
+ case SDL_MOUSEBUTTONDOWN:
+ if (screen->mouse_captured) {
+ sc_screen_otg_process_mouse_button(screen, &event->button);
+ }
+ break;
+ case SDL_MOUSEBUTTONUP:
+ if (screen->mouse_captured) {
+ sc_screen_otg_process_mouse_button(screen, &event->button);
+ } else {
+ sc_screen_otg_capture_mouse(screen, true);
+ }
+ break;
+ case SDL_MOUSEWHEEL:
+ if (screen->mouse_captured) {
+ sc_screen_otg_process_mouse_wheel(screen, &event->wheel);
+ }
+ break;
+ }
+}
diff --git a/app/src/usb/screen_otg.h b/app/src/usb/screen_otg.h
new file mode 100644
index 00000000..3fa1c4ad
--- /dev/null
+++ b/app/src/usb/screen_otg.h
@@ -0,0 +1,46 @@
+#ifndef SC_SCREEN_OTG_H
+#define SC_SCREEN_OTG_H
+
+#include "common.h"
+
+#include <stdbool.h>
+#include <SDL2/SDL.h>
+
+#include "hid_keyboard.h"
+#include "hid_mouse.h"
+
+struct sc_screen_otg {
+ struct sc_hid_keyboard *keyboard;
+ struct sc_hid_mouse *mouse;
+
+ SDL_Window *window;
+ SDL_Renderer *renderer;
+ SDL_Texture *texture;
+
+ // See equivalent mechanism in screen.h
+ bool mouse_captured;
+ SDL_Keycode mouse_capture_key_pressed;
+};
+
+struct sc_screen_otg_params {
+ struct sc_hid_keyboard *keyboard;
+ struct sc_hid_mouse *mouse;
+
+ const char *window_title;
+ bool always_on_top;
+ int16_t window_x; // accepts SC_WINDOW_POSITION_UNDEFINED
+ int16_t window_y; // accepts SC_WINDOW_POSITION_UNDEFINED
+ bool window_borderless;
+};
+
+bool
+sc_screen_otg_init(struct sc_screen_otg *screen,
+ const struct sc_screen_otg_params *params);
+
+void
+sc_screen_otg_destroy(struct sc_screen_otg *screen);
+
+void
+sc_screen_otg_handle_event(struct sc_screen_otg *screen, SDL_Event *event);
+
+#endif