Android/scrcpy
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity
scrcpy/app/src/screen.c

686 lines
22 KiB
C
Raw Normal View History

Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
#include "screen.h"
Replace SDL_assert() by assert() SDL_assert() open a dialog on assertion failure. There is no reason not to use assert() directly.
2019-11-28 04:11:40 +08:00
#include <assert.h>
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
#include <string.h>
Replace SDL types by C99 standard types Scrcpy is a C11 project. Use the C99 standard types instead of the SDL-specific types: SDL_bool -> bool SintXX -> intXX_t UintXX -> uintXX_t
2019-03-03 06:52:22 +08:00
#include <SDL2/SDL.h>
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
Handle screen-related events from screen.c
2021-02-16 01:44:53 +08:00
#include "events.h"
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
#include "icon.xpm"
Make scrcpy.h independant of other headers The header scrcpy.h is intended to be the "public" API. It should not depend on other internal headers. Therefore, declare all required structs in this header and adapt internal code.
2020-06-20 04:04:06 +08:00
#include "scrcpy.h"
Separate multi-words filenames by '_' Rename foobar.ext to foo_bar.ext. <https://github.com/Genymobile/scrcpy/pull/226#discussion_r209454865>
2018-08-15 23:01:54 +08:00
#include "tiny_xpm.h"
Rename "frames" to "video_buffer" It better describes the purpose of the structure.
2019-03-02 22:16:55 +08:00
#include "video_buffer.h"
Move utilities to util/
2019-11-24 18:53:00 +08:00
#include "util/log.h"
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
#define DISPLAY_MARGINS 96
Add shortcuts to rotate display Add Ctrl+Left and Ctrl+Right shortcuts to rotate the display (the content of the scrcpy window). Contrary to --lock-video-orientation, the rotation has no impact on recording, and can be changed dynamically (and immediately). Fixes #218 <https://github.com/Genymobile/scrcpy/issues/218>
2020-04-08 05:03:23 +08:00
static inline struct size
get_rotated_size(struct size size, int rotation) {
struct size rotated_size;
if (rotation & 1) {
rotated_size.width = size.height;
rotated_size.height = size.width;
} else {
rotated_size.width = size.width;
rotated_size.height = size.height;
}
return rotated_size;
}
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
// get the window size in a struct size
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
static struct size
Simplify size changes in fullscreen or maximized If the content size changes (due to rotation for example) while the window is maximized or fullscreen, the resize must be applied once fullscreen and maximized are disabled. The previous strategy consisted in storing the windowed size, computing the target size on rotation, and applying it on window restoration. But tracking the windowed size (while ignoring the non-windowed size) was tricky, due to unspecified order of SDL events (e.g. size changes can be notified before "maximized" events), race conditions when reading window flags, different behaviors on different platforms... To simplify the whole resize management, store the old content size (the frame size, possibly rotated) when it changes while the window is maximized or fullscreen, so that the new optimal size can be computed on window restoration.
2020-05-11 09:11:13 +08:00
get_window_size(const struct screen *screen) {
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
int width;
int height;
Simplify size changes in fullscreen or maximized If the content size changes (due to rotation for example) while the window is maximized or fullscreen, the resize must be applied once fullscreen and maximized are disabled. The previous strategy consisted in storing the windowed size, computing the target size on rotation, and applying it on window restoration. But tracking the windowed size (while ignoring the non-windowed size) was tricky, due to unspecified order of SDL events (e.g. size changes can be notified before "maximized" events), race conditions when reading window flags, different behaviors on different platforms... To simplify the whole resize management, store the old content size (the frame size, possibly rotated) when it changes while the window is maximized or fullscreen, so that the new optimal size can be computed on window restoration.
2020-05-11 09:11:13 +08:00
SDL_GetWindowSize(screen->window, &width, &height);
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
struct size size;
size.width = width;
size.height = height;
return size;
}
// set the window size to be applied when fullscreen is disabled
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
static void
set_window_size(struct screen *screen, struct size new_size) {
Simplify size changes in fullscreen or maximized If the content size changes (due to rotation for example) while the window is maximized or fullscreen, the resize must be applied once fullscreen and maximized are disabled. The previous strategy consisted in storing the windowed size, computing the target size on rotation, and applying it on window restoration. But tracking the windowed size (while ignoring the non-windowed size) was tricky, due to unspecified order of SDL events (e.g. size changes can be notified before "maximized" events), race conditions when reading window flags, different behaviors on different platforms... To simplify the whole resize management, store the old content size (the frame size, possibly rotated) when it changes while the window is maximized or fullscreen, so that the new optimal size can be computed on window restoration.
2020-05-11 09:11:13 +08:00
assert(!screen->fullscreen);
assert(!screen->maximized);
SDL_SetWindowSize(screen->window, new_size.width, new_size.height);
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
// get the preferred display bounds (i.e. the screen bounds with some margins)
Replace SDL types by C99 standard types Scrcpy is a C11 project. Use the C99 standard types instead of the SDL-specific types: SDL_bool -> bool SintXX -> intXX_t UintXX -> uintXX_t
2019-03-03 06:52:22 +08:00
static bool
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
get_preferred_display_bounds(struct size *bounds) {
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
SDL_Rect rect;
Move all compat ifdefs definitions to compat.h This allows to give a proper name to features requirements.
2019-02-16 22:04:32 +08:00
#ifdef SCRCPY_SDL_HAS_GET_DISPLAY_USABLE_BOUNDS
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
# define GET_DISPLAY_BOUNDS(i, r) SDL_GetDisplayUsableBounds((i), (r))
#else
# define GET_DISPLAY_BOUNDS(i, r) SDL_GetDisplayBounds((i), (r))
#endif
if (GET_DISPLAY_BOUNDS(0, &rect)) {
Define macros wrappers for logs Use macros to wrap SDL_Log* functions with the "application" category.
2018-02-13 17:10:18 +08:00
LOGW("Could not get display usable bounds: %s", SDL_GetError());
Replace SDL types by C99 standard types Scrcpy is a C11 project. Use the C99 standard types instead of the SDL-specific types: SDL_bool -> bool SintXX -> intXX_t UintXX -> uintXX_t
2019-03-03 06:52:22 +08:00
return false;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
bounds->width = MAX(0, rect.w - DISPLAY_MARGINS);
bounds->height = MAX(0, rect.h - DISPLAY_MARGINS);
Replace SDL types by C99 standard types Scrcpy is a C11 project. Use the C99 standard types instead of the SDL-specific types: SDL_bool -> bool SintXX -> intXX_t UintXX -> uintXX_t
2019-03-03 06:52:22 +08:00
return true;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
Extract optimal window size detection Extract the computation to detect whether the current size of the window is already optimal. This will allow to reuse it for rendering.
2020-04-25 06:19:44 +08:00
static bool
is_optimal_size(struct size current_size, struct size content_size) {
// The size is optimal if we can recompute one dimension of the current
// size from the other
return current_size.height == current_size.width * content_size.height
/ content_size.width
|| current_size.width == current_size.height * content_size.width
/ content_size.height;
}
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
// return the optimal size of the window, with the following constraints:
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
// - it attempts to keep at least one dimension of the current_size (i.e. it
// crops the black borders)
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
// - it keeps the aspect ratio
// - it scales down to make it fit in the display_size
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
static struct size
Add shortcuts to rotate display Add Ctrl+Left and Ctrl+Right shortcuts to rotate the display (the content of the scrcpy window). Contrary to --lock-video-orientation, the rotation has no impact on recording, and can be changed dynamically (and immediately). Fixes #218 <https://github.com/Genymobile/scrcpy/issues/218>
2020-04-08 05:03:23 +08:00
get_optimal_size(struct size current_size, struct size content_size) {
if (content_size.width == 0 || content_size.height == 0) {
Avoid division by 0 If the frame_size width or height is 0, just return the current size to avoid calculations involving divison by 0.
2018-02-16 06:50:38 +08:00
// avoid division by 0
return current_size;
}
Extract optimal window size detection Extract the computation to detect whether the current size of the window is already optimal. This will allow to reuse it for rendering.
2020-04-25 06:19:44 +08:00
struct size window_size;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
Extract optimal window size detection Extract the computation to detect whether the current size of the window is already optimal. This will allow to reuse it for rendering.
2020-04-25 06:19:44 +08:00
struct size display_size;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
if (!get_preferred_display_bounds(&display_size)) {
Replace "cannot" by "could not"
2019-06-24 02:49:38 +08:00
// could not get display bounds, do not constraint the size
Extract optimal window size detection Extract the computation to detect whether the current size of the window is already optimal. This will allow to reuse it for rendering.
2020-04-25 06:19:44 +08:00
window_size.width = current_size.width;
window_size.height = current_size.height;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
} else {
Extract optimal window size detection Extract the computation to detect whether the current size of the window is already optimal. This will allow to reuse it for rendering.
2020-04-25 06:19:44 +08:00
window_size.width = MIN(current_size.width, display_size.width);
window_size.height = MIN(current_size.height, display_size.height);
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
Extract optimal window size detection Extract the computation to detect whether the current size of the window is already optimal. This will allow to reuse it for rendering.
2020-04-25 06:19:44 +08:00
if (is_optimal_size(window_size, content_size)) {
return window_size;
Stabilize auto-resize The window dimensions are integers, so resizing to fit the content may not be exact. When computing the optimal size, it could cause to reduce alternatively the width and height by few pixels, making the "optimal size" unstable. To avoid this problem, check if the optimal size is already correct either by keeping the width or the height.
2020-04-25 04:52:02 +08:00
}
Extract optimal window size detection Extract the computation to detect whether the current size of the window is already optimal. This will allow to reuse it for rendering.
2020-04-25 06:19:44 +08:00
bool keep_width = content_size.width * window_size.height
> content_size.height * window_size.width;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
if (keep_width) {
// remove black borders on top and bottom
Extract optimal window size detection Extract the computation to detect whether the current size of the window is already optimal. This will allow to reuse it for rendering.
2020-04-25 06:19:44 +08:00
window_size.height = content_size.height * window_size.width
/ content_size.width;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
} else {
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
// remove black borders on left and right (or none at all if it already
// fits)
Extract optimal window size detection Extract the computation to detect whether the current size of the window is already optimal. This will allow to reuse it for rendering.
2020-04-25 06:19:44 +08:00
window_size.width = content_size.width * window_size.height
/ content_size.height;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
Extract optimal window size detection Extract the computation to detect whether the current size of the window is already optimal. This will allow to reuse it for rendering.
2020-04-25 06:19:44 +08:00
return window_size;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
// same as get_optimal_size(), but read the current size from the window
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
static inline struct size
Add shortcuts to rotate display Add Ctrl+Left and Ctrl+Right shortcuts to rotate the display (the content of the scrcpy window). Contrary to --lock-video-orientation, the rotation has no impact on recording, and can be changed dynamically (and immediately). Fixes #218 <https://github.com/Genymobile/scrcpy/issues/218>
2020-04-08 05:03:23 +08:00
get_optimal_window_size(const struct screen *screen, struct size content_size) {
Simplify size changes in fullscreen or maximized If the content size changes (due to rotation for example) while the window is maximized or fullscreen, the resize must be applied once fullscreen and maximized are disabled. The previous strategy consisted in storing the windowed size, computing the target size on rotation, and applying it on window restoration. But tracking the windowed size (while ignoring the non-windowed size) was tricky, due to unspecified order of SDL events (e.g. size changes can be notified before "maximized" events), race conditions when reading window flags, different behaviors on different platforms... To simplify the whole resize management, store the old content size (the frame size, possibly rotated) when it changes while the window is maximized or fullscreen, so that the new optimal size can be computed on window restoration.
2020-05-11 09:11:13 +08:00
struct size window_size = get_window_size(screen);
return get_optimal_size(window_size, content_size);
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
// initially, there is no current size, so use the frame size as current size
Add option to specify the initial window size Add --window-width and --window-height parameters. If only one is provided, the other is computed so that the aspect ratio is preserved.
2019-11-04 01:00:11 +08:00
// req_width and req_height, if not 0, are the sizes requested by the user
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
static inline struct size
Add shortcuts to rotate display Add Ctrl+Left and Ctrl+Right shortcuts to rotate the display (the content of the scrcpy window). Contrary to --lock-video-orientation, the rotation has no impact on recording, and can be changed dynamically (and immediately). Fixes #218 <https://github.com/Genymobile/scrcpy/issues/218>
2020-04-08 05:03:23 +08:00
get_initial_optimal_size(struct size content_size, uint16_t req_width,
Add option to specify the initial window size Add --window-width and --window-height parameters. If only one is provided, the other is computed so that the aspect ratio is preserved.
2019-11-04 01:00:11 +08:00
uint16_t req_height) {
struct size window_size;
if (!req_width && !req_height) {
Add shortcuts to rotate display Add Ctrl+Left and Ctrl+Right shortcuts to rotate the display (the content of the scrcpy window). Contrary to --lock-video-orientation, the rotation has no impact on recording, and can be changed dynamically (and immediately). Fixes #218 <https://github.com/Genymobile/scrcpy/issues/218>
2020-04-08 05:03:23 +08:00
window_size = get_optimal_size(content_size, content_size);
Add option to specify the initial window size Add --window-width and --window-height parameters. If only one is provided, the other is computed so that the aspect ratio is preserved.
2019-11-04 01:00:11 +08:00
} else {
if (req_width) {
window_size.width = req_width;
} else {
// compute from the requested height
Add shortcuts to rotate display Add Ctrl+Left and Ctrl+Right shortcuts to rotate the display (the content of the scrcpy window). Contrary to --lock-video-orientation, the rotation has no impact on recording, and can be changed dynamically (and immediately). Fixes #218 <https://github.com/Genymobile/scrcpy/issues/218>
2020-04-08 05:03:23 +08:00
window_size.width = (uint32_t) req_height * content_size.width
/ content_size.height;
Add option to specify the initial window size Add --window-width and --window-height parameters. If only one is provided, the other is computed so that the aspect ratio is preserved.
2019-11-04 01:00:11 +08:00
}
if (req_height) {
window_size.height = req_height;
} else {
// compute from the requested width
Add shortcuts to rotate display Add Ctrl+Left and Ctrl+Right shortcuts to rotate the display (the content of the scrcpy window). Contrary to --lock-video-orientation, the rotation has no impact on recording, and can be changed dynamically (and immediately). Fixes #218 <https://github.com/Genymobile/scrcpy/issues/218>
2020-04-08 05:03:23 +08:00
window_size.height = (uint32_t) req_width * content_size.height
/ content_size.width;
Add option to specify the initial window size Add --window-width and --window-height parameters. If only one is provided, the other is computed so that the aspect ratio is preserved.
2019-11-04 01:00:11 +08:00
}
}
return window_size;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
Manually position and scale the content Position and scale the content "manually" instead of relying on the renderer "logical size". This avoids possible rounding differences between the computed window size and the content size, causing one row or column of black pixels on the bottom or on the right. This also avoids HiDPI scale issues, by computing the scaling manually. This will also enable to draw items at their expected size on the screen (unscaled). Fixes #15 <https://github.com/Genymobile/scrcpy/issues/15>
2020-04-18 00:44:24 +08:00
static void
screen_update_content_rect(struct screen *screen) {
int dw;
int dh;
SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
struct size content_size = screen->content_size;
// The drawable size is the window size * the HiDPI scale
struct size drawable_size = {dw, dh};
SDL_Rect *rect = &screen->rect;
if (is_optimal_size(drawable_size, content_size)) {
rect->x = 0;
rect->y = 0;
rect->w = drawable_size.width;
rect->h = drawable_size.height;
return;
}
bool keep_width = content_size.width * drawable_size.height
> content_size.height * drawable_size.width;
if (keep_width) {
rect->x = 0;
rect->w = drawable_size.width;
rect->h = drawable_size.width * content_size.height
/ content_size.width;
rect->y = (drawable_size.height - rect->h) / 2;
} else {
rect->y = 0;
rect->h = drawable_size.height;
rect->w = drawable_size.height * content_size.width
/ content_size.height;
rect->x = (drawable_size.width - rect->w) / 2;
}
}
Use a callback to notify a new frame Make the decoder independant of the SDL even mechanism, by making the consumer register a callback on the video_buffer.
2021-02-20 05:02:36 +08:00
static void
on_frame_available(struct video_buffer *vb, void *userdata) {
(void) vb;
(void) userdata;
static SDL_Event new_frame_event = {
.type = EVENT_NEW_FRAME,
};
// Post the event on the UI thread
SDL_PushEvent(&new_frame_event);
}
Use a callback to notify frame skip A skipped frame is detected when the producer offers a frame while the current pending frame has not been consumed. However, the producer (in practice the decoder) is not interested in the fact that a frame has been skipped, only the consumer (the renderer) is. Therefore, notify frame skip via a consumer callback. This allows to manage the skipped and rendered frames count at the same place, and remove fps_counter from decoder.
2021-02-24 02:59:43 +08:00
static void
on_frame_skipped(struct video_buffer *vb, void *userdata) {
(void) vb;
struct screen *screen = userdata;
fps_counter_add_skipped_frame(screen->fps_counter);
}
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
void
Move fps counter out of video buffer In order to make video buffer more generic, move out its specific responsibility to count the fps between the decoder and the renderer.
2021-02-20 03:56:09 +08:00
screen_init(struct screen *screen, struct video_buffer *vb,
struct fps_counter *fps_counter) {
Reference video buffer from screen This paves the way to handle EVENT_NEW_FRAME from screen.c, by allowing to call screen_update_frame() without an explicit video_buffer instance.
2021-02-16 01:28:41 +08:00
screen->vb = vb;
Move fps counter out of video buffer In order to make video buffer more generic, move out its specific responsibility to count the fps between the decoder and the renderer.
2021-02-20 03:56:09 +08:00
screen->fps_counter = fps_counter;
Use a callback to notify a new frame Make the decoder independant of the SDL even mechanism, by making the consumer register a callback on the video_buffer.
2021-02-20 05:02:36 +08:00
Remove screen static initializer Most of the fields are initialized dynamically.
2021-02-22 04:47:55 +08:00
screen->resize_pending = false;
screen->has_frame = false;
screen->fullscreen = false;
screen->maximized = false;
Use a callback to notify a new frame Make the decoder independant of the SDL even mechanism, by making the consumer register a callback on the video_buffer.
2021-02-20 05:02:36 +08:00
static const struct video_buffer_callbacks cbs = {
.on_frame_available = on_frame_available,
Use a callback to notify frame skip A skipped frame is detected when the producer offers a frame while the current pending frame has not been consumed. However, the producer (in practice the decoder) is not interested in the fact that a frame has been skipped, only the consumer (the renderer) is. Therefore, notify frame skip via a consumer callback. This allows to manage the skipped and rendered frames count at the same place, and remove fps_counter from decoder.
2021-02-24 02:59:43 +08:00
.on_frame_skipped = on_frame_skipped,
Use a callback to notify a new frame Make the decoder independant of the SDL even mechanism, by making the consumer register a callback on the video_buffer.
2021-02-20 05:02:36 +08:00
};
Use a callback to notify frame skip A skipped frame is detected when the producer offers a frame while the current pending frame has not been consumed. However, the producer (in practice the decoder) is not interested in the fact that a frame has been skipped, only the consumer (the renderer) is. Therefore, notify frame skip via a consumer callback. This allows to manage the skipped and rendered frames count at the same place, and remove fps_counter from decoder.
2021-02-24 02:59:43 +08:00
video_buffer_set_consumer_callbacks(vb, &cbs, screen);
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
static inline SDL_Texture *
Enable trilinear filtering for OpenGL Improve downscaling quality if mipmapping is available. Suggested-by: Giumo Clanjor (哆啦比猫/兰威举) <cjxgm2@gmail.com> Fixes #40 <https://github.com/Genymobile/scrcpy/issues/40> Ref: <https://github.com/Genymobile/scrcpy/issues/40#issuecomment-591917787>
2020-04-11 22:08:23 +08:00
create_texture(struct screen *screen) {
SDL_Renderer *renderer = screen->renderer;
struct size size = screen->frame_size;
SDL_Texture *texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_YV12,
SDL_TEXTUREACCESS_STREAMING,
size.width, size.height);
if (!texture) {
return NULL;
}
if (screen->mipmaps) {
struct sc_opengl *gl = &screen->gl;
SDL_GL_BindTexture(texture, NULL, NULL);
// Enable trilinear filtering for downscaling
gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_LINEAR);
Increase LOD bias for mipmapping Mipmapping caused too much blurring. Using a LOD bias of -1 instead of -0.5 seems a better compromise to avoid low-quality downscaling while keeping sharp edges in any case. Refs <https://github.com/Genymobile/scrcpy/issues/1394> Refs <https://github.com/Genymobile/scrcpy/issues/40#issuecomment-591917787>
2020-05-23 20:32:16 +08:00
gl->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -1.f);
Enable trilinear filtering for OpenGL Improve downscaling quality if mipmapping is available. Suggested-by: Giumo Clanjor (哆啦比猫/兰威举) <cjxgm2@gmail.com> Fixes #40 <https://github.com/Genymobile/scrcpy/issues/40> Ref: <https://github.com/Genymobile/scrcpy/issues/40#issuecomment-591917787>
2020-04-11 22:08:23 +08:00
SDL_GL_UnbindTexture(texture);
}
return texture;
Factorize texture creation SDL_CreateTexture() is called both during initialization and on frame size change. To avoid inconsistent changes to arguments value, factorize them to a single function create_texture().
2018-03-27 17:01:40 +08:00
}
Replace SDL types by C99 standard types Scrcpy is a C11 project. Use the C99 standard types instead of the SDL-specific types: SDL_bool -> bool SintXX -> intXX_t UintXX -> uintXX_t
2019-03-03 06:52:22 +08:00
bool
Add option --window-title Add an option to set a custom window title. Signed-off-by: Romain Vimont <rom@rom1v.com>
2019-06-24 01:02:34 +08:00
screen_init_rendering(struct screen *screen, const char *window_title,
Add option to specify the initial window position Add --window-x and --window-y parameters. Signed-off-by: Romain Vimont <rom@rom1v.com>
2019-08-29 13:25:17 +08:00
struct size frame_size, bool always_on_top,
Add option to specify the initial window size Add --window-width and --window-height parameters. If only one is provided, the other is computed so that the aspect ratio is preserved.
2019-11-04 01:00:11 +08:00
int16_t window_x, int16_t window_y, uint16_t window_width,
Add --rotation command-line option In addition to Ctrl+Left and Ctrl+Right shortcuts, add a command-line parameter to set the initial rotation.
2020-04-08 16:17:12 +08:00
uint16_t window_height, bool window_borderless,
Add option --no-mipmaps Add an option to disable trilinear filtering even if mipmapping is available.
2020-04-12 05:55:29 +08:00
uint8_t rotation, bool mipmaps) {
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
screen->frame_size = frame_size;
Add --rotation command-line option In addition to Ctrl+Left and Ctrl+Right shortcuts, add a command-line parameter to set the initial rotation.
2020-04-08 16:17:12 +08:00
screen->rotation = rotation;
if (rotation) {
LOGI("Initial display rotation set to %u", rotation);
}
Store rotated content size This avoids to compute it every time from the frame size.
2020-04-08 20:11:23 +08:00
struct size content_size = get_rotated_size(frame_size, screen->rotation);
screen->content_size = content_size;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
Add option to specify the initial window size Add --window-width and --window-height parameters. If only one is provided, the other is computed so that the aspect ratio is preserved.
2019-11-04 01:00:11 +08:00
struct size window_size =
Add shortcuts to rotate display Add Ctrl+Left and Ctrl+Right shortcuts to rotate the display (the content of the scrcpy window). Contrary to --lock-video-orientation, the rotation has no impact on recording, and can be changed dynamically (and immediately). Fixes #218 <https://github.com/Genymobile/scrcpy/issues/218>
2020-04-08 05:03:23 +08:00
get_initial_optimal_size(content_size, window_width, window_height);
Replace SDL types by C99 standard types Scrcpy is a C11 project. Use the C99 standard types instead of the SDL-specific types: SDL_bool -> bool SintXX -> intXX_t UintXX -> uintXX_t
2019-03-03 06:52:22 +08:00
uint32_t window_flags = SDL_WINDOW_HIDDEN | SDL_WINDOW_RESIZABLE;
Expose High DPI support configuration flag The High DPI support is enabled by default, so that the renderer use the full definition of High DPI screens. However, there are still mouse coordinates problems on some MacOS having High DPI support (but not all), so expose a way to disable it.
2018-03-07 17:53:39 +08:00
#ifdef HIDPI_SUPPORT
window_flags |= SDL_WINDOW_ALLOW_HIGHDPI;
#endif
app: add always_on_top It is very convenient when I play mobile game and watch video at the same time. Tested on Linux mint Cinnamon as well as Windows 10. Signed-off-by: Yu-Chen Lin <npes87184@gmail.com>
2019-01-27 19:04:22 +08:00
if (always_on_top) {
Use "always on top" only for SDL >= 2.0.5 The flag SDL_WINDOW_ALWAYS_ON_TOP is available since SDL 2.0.5. Do not use it if SDL is older, to fix compilation failure. Fixes <https://github.com/Genymobile/scrcpy/issues/432>
2019-02-16 22:21:14 +08:00
#ifdef SCRCPY_SDL_HAS_WINDOW_ALWAYS_ON_TOP
app: add always_on_top It is very convenient when I play mobile game and watch video at the same time. Tested on Linux mint Cinnamon as well as Windows 10. Signed-off-by: Yu-Chen Lin <npes87184@gmail.com>
2019-01-27 19:04:22 +08:00
window_flags |= SDL_WINDOW_ALWAYS_ON_TOP;
Use "always on top" only for SDL >= 2.0.5 The flag SDL_WINDOW_ALWAYS_ON_TOP is available since SDL 2.0.5. Do not use it if SDL is older, to fix compilation failure. Fixes <https://github.com/Genymobile/scrcpy/issues/432>
2019-02-16 22:21:14 +08:00
#else
LOGW("The 'always on top' flag is not available "
"(compile with SDL >= 2.0.5 to enable it)");
#endif
app: add always_on_top It is very convenient when I play mobile game and watch video at the same time. Tested on Linux mint Cinnamon as well as Windows 10. Signed-off-by: Yu-Chen Lin <npes87184@gmail.com>
2019-01-27 19:04:22 +08:00
}
Add option to disable window decoration Add --window-borderless parameter. Signed-off-by: Romain Vimont <rom@rom1v.com>
2019-08-29 13:25:17 +08:00
if (window_borderless) {
window_flags |= SDL_WINDOW_BORDERLESS;
}
app: add always_on_top It is very convenient when I play mobile game and watch video at the same time. Tested on Linux mint Cinnamon as well as Windows 10. Signed-off-by: Yu-Chen Lin <npes87184@gmail.com>
2019-01-27 19:04:22 +08:00
Make scrcpy.h independant of other headers The header scrcpy.h is intended to be the "public" API. It should not depend on other internal headers. Therefore, declare all required structs in this header and adapt internal code.
2020-06-20 04:04:06 +08:00
int x = window_x != SC_WINDOW_POSITION_UNDEFINED
Accept negative window position It seems to work on some window managers. Fixes #1242 <https://github.com/Genymobile/scrcpy/issues/1242>
2020-03-27 00:54:06 +08:00
? window_x : (int) SDL_WINDOWPOS_UNDEFINED;
Make scrcpy.h independant of other headers The header scrcpy.h is intended to be the "public" API. It should not depend on other internal headers. Therefore, declare all required structs in this header and adapt internal code.
2020-06-20 04:04:06 +08:00
int y = window_y != SC_WINDOW_POSITION_UNDEFINED
Accept negative window position It seems to work on some window managers. Fixes #1242 <https://github.com/Genymobile/scrcpy/issues/1242>
2020-03-27 00:54:06 +08:00
? window_y : (int) SDL_WINDOWPOS_UNDEFINED;
Add option to specify the initial window position Add --window-x and --window-y parameters. Signed-off-by: Romain Vimont <rom@rom1v.com>
2019-08-29 13:25:17 +08:00
screen->window = SDL_CreateWindow(window_title, x, y,
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
window_size.width, window_size.height,
window_flags);
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
if (!screen->window) {
Define macros wrappers for logs Use macros to wrap SDL_Log* functions with the "application" category.
2018-02-13 17:10:18 +08:00
LOGC("Could not create window: %s", SDL_GetError());
Replace SDL types by C99 standard types Scrcpy is a C11 project. Use the C99 standard types instead of the SDL-specific types: SDL_bool -> bool SintXX -> intXX_t UintXX -> uintXX_t
2019-03-03 06:52:22 +08:00
return false;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
screen->renderer = SDL_CreateRenderer(screen->window, -1,
SDL_RENDERER_ACCELERATED);
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
if (!screen->renderer) {
Define macros wrappers for logs Use macros to wrap SDL_Log* functions with the "application" category.
2018-02-13 17:10:18 +08:00
LOGC("Could not create renderer: %s", SDL_GetError());
Improve error handling in screen initialization After the struct screen is initialized, the window, the renderer and the texture are necessarily valid, so there is no need to check in screen_destroy().
2021-02-13 21:40:00 +08:00
SDL_DestroyWindow(screen->window);
Replace SDL types by C99 standard types Scrcpy is a C11 project. Use the C99 standard types instead of the SDL-specific types: SDL_bool -> bool SintXX -> intXX_t UintXX -> uintXX_t
2019-03-03 06:52:22 +08:00
return false;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
Add --render-driver command-line option Add an option to set a render driver hint (SDL_HINT_RENDER_DRIVER).
2020-04-11 20:34:41 +08:00
SDL_RendererInfo renderer_info;
int r = SDL_GetRendererInfo(screen->renderer, &renderer_info);
const char *renderer_name = r ? NULL : renderer_info.name;
LOGI("Renderer: %s", renderer_name ? renderer_name : "(unknown)");
Remove screen static initializer Most of the fields are initialized dynamically.
2021-02-22 04:47:55 +08:00
screen->mipmaps = false;
Fix typo in comments
2020-04-25 05:01:58 +08:00
// starts with "opengl"
Make use_opengl local The flag is used only locally, there is no need to store it in the screen structure.
2021-02-08 02:12:14 +08:00
bool use_opengl = renderer_name && !strncmp(renderer_name, "opengl", 6);
if (use_opengl) {
Enable trilinear filtering for OpenGL Improve downscaling quality if mipmapping is available. Suggested-by: Giumo Clanjor (哆啦比猫/兰威举) <cjxgm2@gmail.com> Fixes #40 <https://github.com/Genymobile/scrcpy/issues/40> Ref: <https://github.com/Genymobile/scrcpy/issues/40#issuecomment-591917787>
2020-04-11 22:08:23 +08:00
struct sc_opengl *gl = &screen->gl;
sc_opengl_init(gl);
LOGI("OpenGL version: %s", gl->version);
Add option --no-mipmaps Add an option to disable trilinear filtering even if mipmapping is available.
2020-04-12 05:55:29 +08:00
if (mipmaps) {
bool supports_mipmaps =
sc_opengl_version_at_least(gl, 3, 0, /* OpenGL 3.0+ */
2, 0 /* OpenGL ES 2.0+ */);
if (supports_mipmaps) {
LOGI("Trilinear filtering enabled");
screen->mipmaps = true;
} else {
LOGW("Trilinear filtering disabled "
"(OpenGL 3.0+ or ES 2.0+ required)");
}
Enable trilinear filtering for OpenGL Improve downscaling quality if mipmapping is available. Suggested-by: Giumo Clanjor (哆啦比猫/兰威举) <cjxgm2@gmail.com> Fixes #40 <https://github.com/Genymobile/scrcpy/issues/40> Ref: <https://github.com/Genymobile/scrcpy/issues/40#issuecomment-591917787>
2020-04-11 22:08:23 +08:00
} else {
Add option --no-mipmaps Add an option to disable trilinear filtering even if mipmapping is available.
2020-04-12 05:55:29 +08:00
LOGI("Trilinear filtering disabled");
Enable trilinear filtering for OpenGL Improve downscaling quality if mipmapping is available. Suggested-by: Giumo Clanjor (哆啦比猫/兰威举) <cjxgm2@gmail.com> Fixes #40 <https://github.com/Genymobile/scrcpy/issues/40> Ref: <https://github.com/Genymobile/scrcpy/issues/40#issuecomment-591917787>
2020-04-11 22:08:23 +08:00
}
Log mipmaps error only if mipmaps are enabled
2021-02-13 21:32:24 +08:00
} else if (mipmaps) {
Remove warning when renderer is not OpenGL Trilinear filtering can currently only be enabled for OpenGL renderers. Do not print a warning if the renderer is not OpenGL, as it can confuses users, while nothing is wrong.
2020-05-23 20:23:30 +08:00
LOGD("Trilinear filtering disabled (not an OpenGL renderer)");
Enable trilinear filtering for OpenGL Improve downscaling quality if mipmapping is available. Suggested-by: Giumo Clanjor (哆啦比猫/兰威举) <cjxgm2@gmail.com> Fixes #40 <https://github.com/Genymobile/scrcpy/issues/40> Ref: <https://github.com/Genymobile/scrcpy/issues/40#issuecomment-591917787>
2020-04-11 22:08:23 +08:00
}
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
SDL_Surface *icon = read_xpm(icon_xpm);
Continue on icon loading failure If loading the icon from xpm fails, launch scrcpy without window icon. <https://github.com/Genymobile/scrcpy/issues/539>
2019-05-24 02:58:08 +08:00
if (icon) {
SDL_SetWindowIcon(screen->window, icon);
SDL_FreeSurface(icon);
} else {
LOGW("Could not load icon");
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
LOGI("Initial texture: %" PRIu16 "x%" PRIu16, frame_size.width,
frame_size.height);
Enable trilinear filtering for OpenGL Improve downscaling quality if mipmapping is available. Suggested-by: Giumo Clanjor (哆啦比猫/兰威举) <cjxgm2@gmail.com> Fixes #40 <https://github.com/Genymobile/scrcpy/issues/40> Ref: <https://github.com/Genymobile/scrcpy/issues/40#issuecomment-591917787>
2020-04-11 22:08:23 +08:00
screen->texture = create_texture(screen);
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
if (!screen->texture) {
Define macros wrappers for logs Use macros to wrap SDL_Log* functions with the "application" category.
2018-02-13 17:10:18 +08:00
LOGC("Could not create texture: %s", SDL_GetError());
Improve error handling in screen initialization After the struct screen is initialized, the window, the renderer and the texture are necessarily valid, so there is no need to check in screen_destroy().
2021-02-13 21:40:00 +08:00
SDL_DestroyRenderer(screen->renderer);
SDL_DestroyWindow(screen->window);
Replace SDL types by C99 standard types Scrcpy is a C11 project. Use the C99 standard types instead of the SDL-specific types: SDL_bool -> bool SintXX -> intXX_t UintXX -> uintXX_t
2019-03-03 06:52:22 +08:00
return false;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
Reset window size on initialization On macOS with renderer "metal", HiDPI scaling may be incorrect on initialization when several displays are connected. Resetting the window size fixes the problem. Refs #15 <https://github.com/Genymobile/scrcpy/issues/15>
2020-05-18 23:56:22 +08:00
// Reset the window size to trigger a SIZE_CHANGED event, to workaround
// HiDPI issues with some SDL renderers when several displays having
// different HiDPI scaling are connected
SDL_SetWindowSize(screen->window, window_size.width, window_size.height);
Manually position and scale the content Position and scale the content "manually" instead of relying on the renderer "logical size". This avoids possible rounding differences between the computed window size and the content size, causing one row or column of black pixels on the bottom or on the right. This also avoids HiDPI scale issues, by computing the scaling manually. This will also enable to draw items at their expected size on the screen (unscaled). Fixes #15 <https://github.com/Genymobile/scrcpy/issues/15>
2020-04-18 00:44:24 +08:00
screen_update_content_rect(screen);
Replace SDL types by C99 standard types Scrcpy is a C11 project. Use the C99 standard types instead of the SDL-specific types: SDL_bool -> bool SintXX -> intXX_t UintXX -> uintXX_t
2019-03-03 06:52:22 +08:00
return true;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
void
screen_show_window(struct screen *screen) {
Improve startup time On startup, the client has to: 1. listen on a port 2. push and start the server to the device 3. wait for the server to connect (accept) 4. read device name and size 5. initialize SDL 6. initialize the window and renderer 7. show the window From the execution of the app_process command to start the server on the device, to the execution of the java main method, it takes ~800ms. As a consequence, step 3 also takes ~800ms on the client. Once complete, the client initializes SDL, which takes ~500ms. These two expensive actions are executed sequentially: HOST DEVICE listen on port | | push/start the server |----------------->|| app_process loads the jar accept the connection . ^ || . | || . | WASTE || . | OF || . | TIME || . | || . | || . v X execution of our java main connection accepted |<-----------------| connect to the host init SDL || | || ,----------------| send frames || |,---------------| || ||,--------------| || |||,-------------| || ||||,------------| init window/renderer | |||||,-----------| display frames |<++++++-----------| (many frames skipped) The rationale for step 3 occuring before step 5 is that initializing SDL replaces the SIGTERM handler to receive the event in the event loop, so pressing Ctrl+C during step 5 would not work (since it blocks the event loop). But this is not so important; let's parallelize the SDL initialization with the app_process execution (we'll just add a timeout to the connection): HOST DEVICE listen on port | | push/start the server |----------------->||app_process loads the jar init SDL || || || || || || || || || || || || accept the connection . || . X execution of our java main connection accepted |<-----------------| connect to the host init window/renderer | | display frames |<-----------------| send frames |<-----------------| In addition, show the window only once the first frame is available to avoid flickering (opening a black window for 100~200ms). Note: the window and renderer are initialized after the connection is accepted because they use the device information received from the device.
2018-02-09 20:50:54 +08:00
SDL_ShowWindow(screen->window);
}
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
void
screen_destroy(struct screen *screen) {
Improve error handling in screen initialization After the struct screen is initialized, the window, the renderer and the texture are necessarily valid, so there is no need to check in screen_destroy().
2021-02-13 21:40:00 +08:00
SDL_DestroyTexture(screen->texture);
SDL_DestroyRenderer(screen->renderer);
SDL_DestroyWindow(screen->window);
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
Factorize window resize When the content size changes, either on frame size or client rotation changes, the window must be resized. Factorize for both cases.
2020-05-11 08:00:46 +08:00
static void
Simplify size changes in fullscreen or maximized If the content size changes (due to rotation for example) while the window is maximized or fullscreen, the resize must be applied once fullscreen and maximized are disabled. The previous strategy consisted in storing the windowed size, computing the target size on rotation, and applying it on window restoration. But tracking the windowed size (while ignoring the non-windowed size) was tricky, due to unspecified order of SDL events (e.g. size changes can be notified before "maximized" events), race conditions when reading window flags, different behaviors on different platforms... To simplify the whole resize management, store the old content size (the frame size, possibly rotated) when it changes while the window is maximized or fullscreen, so that the new optimal size can be computed on window restoration.
2020-05-11 09:11:13 +08:00
resize_for_content(struct screen *screen, struct size old_content_size,
struct size new_content_size) {
struct size window_size = get_window_size(screen);
Factorize window resize When the content size changes, either on frame size or client rotation changes, the window must be resized. Factorize for both cases.
2020-05-11 08:00:46 +08:00
struct size target_size = {
Simplify size changes in fullscreen or maximized If the content size changes (due to rotation for example) while the window is maximized or fullscreen, the resize must be applied once fullscreen and maximized are disabled. The previous strategy consisted in storing the windowed size, computing the target size on rotation, and applying it on window restoration. But tracking the windowed size (while ignoring the non-windowed size) was tricky, due to unspecified order of SDL events (e.g. size changes can be notified before "maximized" events), race conditions when reading window flags, different behaviors on different platforms... To simplify the whole resize management, store the old content size (the frame size, possibly rotated) when it changes while the window is maximized or fullscreen, so that the new optimal size can be computed on window restoration.
2020-05-11 09:11:13 +08:00
.width = (uint32_t) window_size.width * new_content_size.width
Factorize window resize When the content size changes, either on frame size or client rotation changes, the window must be resized. Factorize for both cases.
2020-05-11 08:00:46 +08:00
/ old_content_size.width,
Simplify size changes in fullscreen or maximized If the content size changes (due to rotation for example) while the window is maximized or fullscreen, the resize must be applied once fullscreen and maximized are disabled. The previous strategy consisted in storing the windowed size, computing the target size on rotation, and applying it on window restoration. But tracking the windowed size (while ignoring the non-windowed size) was tricky, due to unspecified order of SDL events (e.g. size changes can be notified before "maximized" events), race conditions when reading window flags, different behaviors on different platforms... To simplify the whole resize management, store the old content size (the frame size, possibly rotated) when it changes while the window is maximized or fullscreen, so that the new optimal size can be computed on window restoration.
2020-05-11 09:11:13 +08:00
.height = (uint32_t) window_size.height * new_content_size.height
Factorize window resize When the content size changes, either on frame size or client rotation changes, the window must be resized. Factorize for both cases.
2020-05-11 08:00:46 +08:00
/ old_content_size.height,
};
target_size = get_optimal_size(target_size, new_content_size);
set_window_size(screen, target_size);
Simplify size changes in fullscreen or maximized If the content size changes (due to rotation for example) while the window is maximized or fullscreen, the resize must be applied once fullscreen and maximized are disabled. The previous strategy consisted in storing the windowed size, computing the target size on rotation, and applying it on window restoration. But tracking the windowed size (while ignoring the non-windowed size) was tricky, due to unspecified order of SDL events (e.g. size changes can be notified before "maximized" events), race conditions when reading window flags, different behaviors on different platforms... To simplify the whole resize management, store the old content size (the frame size, possibly rotated) when it changes while the window is maximized or fullscreen, so that the new optimal size can be computed on window restoration.
2020-05-11 09:11:13 +08:00
}
static void
set_content_size(struct screen *screen, struct size new_content_size) {
if (!screen->fullscreen && !screen->maximized) {
resize_for_content(screen, screen->content_size, new_content_size);
} else if (!screen->resize_pending) {
// Store the windowed size to be able to compute the optimal size once
// fullscreen and maximized are disabled
screen->windowed_content_size = screen->content_size;
screen->resize_pending = true;
}
Factorize window resize When the content size changes, either on frame size or client rotation changes, the window must be resized. Factorize for both cases.
2020-05-11 08:00:46 +08:00
screen->content_size = new_content_size;
}
Simplify size changes in fullscreen or maximized If the content size changes (due to rotation for example) while the window is maximized or fullscreen, the resize must be applied once fullscreen and maximized are disabled. The previous strategy consisted in storing the windowed size, computing the target size on rotation, and applying it on window restoration. But tracking the windowed size (while ignoring the non-windowed size) was tricky, due to unspecified order of SDL events (e.g. size changes can be notified before "maximized" events), race conditions when reading window flags, different behaviors on different platforms... To simplify the whole resize management, store the old content size (the frame size, possibly rotated) when it changes while the window is maximized or fullscreen, so that the new optimal size can be computed on window restoration.
2020-05-11 09:11:13 +08:00
static void
apply_pending_resize(struct screen *screen) {
assert(!screen->fullscreen);
assert(!screen->maximized);
if (screen->resize_pending) {
resize_for_content(screen, screen->windowed_content_size,
screen->content_size);
screen->resize_pending = false;
}
}
Add shortcuts to rotate display Add Ctrl+Left and Ctrl+Right shortcuts to rotate the display (the content of the scrcpy window). Contrary to --lock-video-orientation, the rotation has no impact on recording, and can be changed dynamically (and immediately). Fixes #218 <https://github.com/Genymobile/scrcpy/issues/218>
2020-04-08 05:03:23 +08:00
void
screen_set_rotation(struct screen *screen, unsigned rotation) {
assert(rotation < 4);
if (rotation == screen->rotation) {
return;
}
struct size new_content_size =
get_rotated_size(screen->frame_size, rotation);
Factorize window resize When the content size changes, either on frame size or client rotation changes, the window must be resized. Factorize for both cases.
2020-05-11 08:00:46 +08:00
set_content_size(screen, new_content_size);
Manually position and scale the content Position and scale the content "manually" instead of relying on the renderer "logical size". This avoids possible rounding differences between the computed window size and the content size, causing one row or column of black pixels on the bottom or on the right. This also avoids HiDPI scale issues, by computing the scaling manually. This will also enable to draw items at their expected size on the screen (unscaled). Fixes #15 <https://github.com/Genymobile/scrcpy/issues/15>
2020-04-18 00:44:24 +08:00
Add shortcuts to rotate display Add Ctrl+Left and Ctrl+Right shortcuts to rotate the display (the content of the scrcpy window). Contrary to --lock-video-orientation, the rotation has no impact on recording, and can be changed dynamically (and immediately). Fixes #218 <https://github.com/Genymobile/scrcpy/issues/218>
2020-04-08 05:03:23 +08:00
screen->rotation = rotation;
LOGI("Display rotation set to %u", rotation);
Manually position and scale the content Position and scale the content "manually" instead of relying on the renderer "logical size". This avoids possible rounding differences between the computed window size and the content size, causing one row or column of black pixels on the bottom or on the right. This also avoids HiDPI scale issues, by computing the scaling manually. This will also enable to draw items at their expected size on the screen (unscaled). Fixes #15 <https://github.com/Genymobile/scrcpy/issues/15>
2020-04-18 00:44:24 +08:00
screen_render(screen, true);
Add shortcuts to rotate display Add Ctrl+Left and Ctrl+Right shortcuts to rotate the display (the content of the scrcpy window). Contrary to --lock-video-orientation, the rotation has no impact on recording, and can be changed dynamically (and immediately). Fixes #218 <https://github.com/Genymobile/scrcpy/issues/218>
2020-04-08 05:03:23 +08:00
}
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
// recreate the texture and resize the window if the frame size has changed
Replace SDL types by C99 standard types Scrcpy is a C11 project. Use the C99 standard types instead of the SDL-specific types: SDL_bool -> bool SintXX -> intXX_t UintXX -> uintXX_t
2019-03-03 06:52:22 +08:00
static bool
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
prepare_for_frame(struct screen *screen, struct size new_frame_size) {
if (screen->frame_size.width != new_frame_size.width
|| screen->frame_size.height != new_frame_size.height) {
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
// frame dimension changed, destroy texture
SDL_DestroyTexture(screen->texture);
screen->frame_size = new_frame_size;
Manually position and scale the content Position and scale the content "manually" instead of relying on the renderer "logical size". This avoids possible rounding differences between the computed window size and the content size, causing one row or column of black pixels on the bottom or on the right. This also avoids HiDPI scale issues, by computing the scaling manually. This will also enable to draw items at their expected size on the screen (unscaled). Fixes #15 <https://github.com/Genymobile/scrcpy/issues/15>
2020-04-18 00:44:24 +08:00
struct size new_content_size =
get_rotated_size(new_frame_size, screen->rotation);
set_content_size(screen, new_content_size);
screen_update_content_rect(screen);
Log "new texture" at INFO level The "initial texture" is logged at INFO level. For consistency, log "new texture" at the same level.
2019-03-08 03:17:09 +08:00
LOGI("New texture: %" PRIu16 "x%" PRIu16,
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
screen->frame_size.width, screen->frame_size.height);
Enable trilinear filtering for OpenGL Improve downscaling quality if mipmapping is available. Suggested-by: Giumo Clanjor (哆啦比猫/兰威举) <cjxgm2@gmail.com> Fixes #40 <https://github.com/Genymobile/scrcpy/issues/40> Ref: <https://github.com/Genymobile/scrcpy/issues/40#issuecomment-591917787>
2020-04-11 22:08:23 +08:00
screen->texture = create_texture(screen);
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
if (!screen->texture) {
Define macros wrappers for logs Use macros to wrap SDL_Log* functions with the "application" category.
2018-02-13 17:10:18 +08:00
LOGC("Could not create texture: %s", SDL_GetError());
Replace SDL types by C99 standard types Scrcpy is a C11 project. Use the C99 standard types instead of the SDL-specific types: SDL_bool -> bool SintXX -> intXX_t UintXX -> uintXX_t
2019-03-03 06:52:22 +08:00
return false;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
}
Replace SDL types by C99 standard types Scrcpy is a C11 project. Use the C99 standard types instead of the SDL-specific types: SDL_bool -> bool SintXX -> intXX_t UintXX -> uintXX_t
2019-03-03 06:52:22 +08:00
return true;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
// write the frame into the texture
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
static void
update_texture(struct screen *screen, const AVFrame *frame) {
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
SDL_UpdateYUVTexture(screen->texture, NULL,
frame->data[0], frame->linesize[0],
frame->data[1], frame->linesize[1],
frame->data[2], frame->linesize[2]);
Enable trilinear filtering for OpenGL Improve downscaling quality if mipmapping is available. Suggested-by: Giumo Clanjor (哆啦比猫/兰威举) <cjxgm2@gmail.com> Fixes #40 <https://github.com/Genymobile/scrcpy/issues/40> Ref: <https://github.com/Genymobile/scrcpy/issues/40#issuecomment-591917787>
2020-04-11 22:08:23 +08:00
if (screen->mipmaps) {
SDL_GL_BindTexture(screen->texture, NULL, NULL);
screen->gl.GenerateMipmap(GL_TEXTURE_2D);
SDL_GL_UnbindTexture(screen->texture);
}
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
Handle screen-related events from screen.c
2021-02-16 01:44:53 +08:00
static bool
Reference video buffer from screen This paves the way to handle EVENT_NEW_FRAME from screen.c, by allowing to call screen_update_frame() without an explicit video_buffer instance.
2021-02-16 01:28:41 +08:00
screen_update_frame(struct screen *screen) {
Make video buffer more generic Video buffer is a tool between a frame producer and a frame consumer. For now, it is used between a decoder and a renderer, but in the future another instance might be used to swscale decoded frames.
2021-02-20 04:16:57 +08:00
const AVFrame *frame = video_buffer_consumer_take_frame(screen->vb);
Move fps counter out of video buffer In order to make video buffer more generic, move out its specific responsibility to count the fps between the decoder and the renderer.
2021-02-20 03:56:09 +08:00
fps_counter_add_rendered_frame(screen->fps_counter);
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
struct size new_frame_size = {frame->width, frame->height};
if (!prepare_for_frame(screen, new_frame_size)) {
Replace SDL types by C99 standard types Scrcpy is a C11 project. Use the C99 standard types instead of the SDL-specific types: SDL_bool -> bool SintXX -> intXX_t UintXX -> uintXX_t
2019-03-03 06:52:22 +08:00
return false;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
update_texture(screen, frame);
Move frame updating to screen.c Replace screen_update() by a higher-level screen_update_frame() handling the whole frame updating, so that scrcpy.c just call it without managing implementation details.
2018-02-09 18:14:47 +08:00
Manually position and scale the content Position and scale the content "manually" instead of relying on the renderer "logical size". This avoids possible rounding differences between the computed window size and the content size, causing one row or column of black pixels on the bottom or on the right. This also avoids HiDPI scale issues, by computing the scaling manually. This will also enable to draw items at their expected size on the screen (unscaled). Fixes #15 <https://github.com/Genymobile/scrcpy/issues/15>
2020-04-18 00:44:24 +08:00
screen_render(screen, false);
Replace SDL types by C99 standard types Scrcpy is a C11 project. Use the C99 standard types instead of the SDL-specific types: SDL_bool -> bool SintXX -> intXX_t UintXX -> uintXX_t
2019-03-03 06:52:22 +08:00
return true;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
void
Manually position and scale the content Position and scale the content "manually" instead of relying on the renderer "logical size". This avoids possible rounding differences between the computed window size and the content size, causing one row or column of black pixels on the bottom or on the right. This also avoids HiDPI scale issues, by computing the scaling manually. This will also enable to draw items at their expected size on the screen (unscaled). Fixes #15 <https://github.com/Genymobile/scrcpy/issues/15>
2020-04-18 00:44:24 +08:00
screen_render(struct screen *screen, bool update_content_rect) {
if (update_content_rect) {
screen_update_content_rect(screen);
}
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
SDL_RenderClear(screen->renderer);
Add shortcuts to rotate display Add Ctrl+Left and Ctrl+Right shortcuts to rotate the display (the content of the scrcpy window). Contrary to --lock-video-orientation, the rotation has no impact on recording, and can be changed dynamically (and immediately). Fixes #218 <https://github.com/Genymobile/scrcpy/issues/218>
2020-04-08 05:03:23 +08:00
if (screen->rotation == 0) {
Manually position and scale the content Position and scale the content "manually" instead of relying on the renderer "logical size". This avoids possible rounding differences between the computed window size and the content size, causing one row or column of black pixels on the bottom or on the right. This also avoids HiDPI scale issues, by computing the scaling manually. This will also enable to draw items at their expected size on the screen (unscaled). Fixes #15 <https://github.com/Genymobile/scrcpy/issues/15>
2020-04-18 00:44:24 +08:00
SDL_RenderCopy(screen->renderer, screen->texture, NULL, &screen->rect);
Add shortcuts to rotate display Add Ctrl+Left and Ctrl+Right shortcuts to rotate the display (the content of the scrcpy window). Contrary to --lock-video-orientation, the rotation has no impact on recording, and can be changed dynamically (and immediately). Fixes #218 <https://github.com/Genymobile/scrcpy/issues/218>
2020-04-08 05:03:23 +08:00
} else {
// rotation in RenderCopyEx() is clockwise, while screen->rotation is
// counterclockwise (to be consistent with --lock-video-orientation)
int cw_rotation = (4 - screen->rotation) % 4;
double angle = 90 * cw_rotation;
SDL_Rect *dstrect = NULL;
SDL_Rect rect;
if (screen->rotation & 1) {
Manually position and scale the content Position and scale the content "manually" instead of relying on the renderer "logical size". This avoids possible rounding differences between the computed window size and the content size, causing one row or column of black pixels on the bottom or on the right. This also avoids HiDPI scale issues, by computing the scaling manually. This will also enable to draw items at their expected size on the screen (unscaled). Fixes #15 <https://github.com/Genymobile/scrcpy/issues/15>
2020-04-18 00:44:24 +08:00
rect.x = screen->rect.x + (screen->rect.w - screen->rect.h) / 2;
rect.y = screen->rect.y + (screen->rect.h - screen->rect.w) / 2;
rect.w = screen->rect.h;
rect.h = screen->rect.w;
Add shortcuts to rotate display Add Ctrl+Left and Ctrl+Right shortcuts to rotate the display (the content of the scrcpy window). Contrary to --lock-video-orientation, the rotation has no impact on recording, and can be changed dynamically (and immediately). Fixes #218 <https://github.com/Genymobile/scrcpy/issues/218>
2020-04-08 05:03:23 +08:00
dstrect = &rect;
Manually position and scale the content Position and scale the content "manually" instead of relying on the renderer "logical size". This avoids possible rounding differences between the computed window size and the content size, causing one row or column of black pixels on the bottom or on the right. This also avoids HiDPI scale issues, by computing the scaling manually. This will also enable to draw items at their expected size on the screen (unscaled). Fixes #15 <https://github.com/Genymobile/scrcpy/issues/15>
2020-04-18 00:44:24 +08:00
} else {
assert(screen->rotation == 2);
dstrect = &screen->rect;
Add shortcuts to rotate display Add Ctrl+Left and Ctrl+Right shortcuts to rotate the display (the content of the scrcpy window). Contrary to --lock-video-orientation, the rotation has no impact on recording, and can be changed dynamically (and immediately). Fixes #218 <https://github.com/Genymobile/scrcpy/issues/218>
2020-04-08 05:03:23 +08:00
}
SDL_RenderCopyEx(screen->renderer, screen->texture, NULL, dstrect,
angle, NULL, 0);
}
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
SDL_RenderPresent(screen->renderer);
}
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
void
screen_switch_fullscreen(struct screen *screen) {
Replace SDL types by C99 standard types Scrcpy is a C11 project. Use the C99 standard types instead of the SDL-specific types: SDL_bool -> bool SintXX -> intXX_t UintXX -> uintXX_t
2019-03-03 06:52:22 +08:00
uint32_t new_mode = screen->fullscreen ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
if (SDL_SetWindowFullscreen(screen->window, new_mode)) {
Define macros wrappers for logs Use macros to wrap SDL_Log* functions with the "application" category.
2018-02-13 17:10:18 +08:00
LOGW("Could not switch fullscreen mode: %s", SDL_GetError());
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
return;
}
screen->fullscreen = !screen->fullscreen;
Simplify size changes in fullscreen or maximized If the content size changes (due to rotation for example) while the window is maximized or fullscreen, the resize must be applied once fullscreen and maximized are disabled. The previous strategy consisted in storing the windowed size, computing the target size on rotation, and applying it on window restoration. But tracking the windowed size (while ignoring the non-windowed size) was tricky, due to unspecified order of SDL events (e.g. size changes can be notified before "maximized" events), race conditions when reading window flags, different behaviors on different platforms... To simplify the whole resize management, store the old content size (the frame size, possibly rotated) when it changes while the window is maximized or fullscreen, so that the new optimal size can be computed on window restoration.
2020-05-11 09:11:13 +08:00
if (!screen->fullscreen && !screen->maximized) {
apply_pending_resize(screen);
}
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
Define macros wrappers for logs Use macros to wrap SDL_Log* functions with the "application" category.
2018-02-13 17:10:18 +08:00
LOGD("Switched to %s mode", screen->fullscreen ? "fullscreen" : "windowed");
Manually position and scale the content Position and scale the content "manually" instead of relying on the renderer "logical size". This avoids possible rounding differences between the computed window size and the content size, causing one row or column of black pixels on the bottom or on the right. This also avoids HiDPI scale issues, by computing the scaling manually. This will also enable to draw items at their expected size on the screen (unscaled). Fixes #15 <https://github.com/Genymobile/scrcpy/issues/15>
2020-04-18 00:44:24 +08:00
screen_render(screen, true);
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
void
screen_resize_to_fit(struct screen *screen) {
Disable "resize to fit" in maximized state In maximized state (but not fullscreen), it was possible to resize to fit the device screen (with Ctrl+x or double-clicking on black borders). This caused problems on macOS with the "expand to fullscreen" feature, which behaves like a fullscreen mode but is seen as maximized by SDL. In that state, resizing to fit causes unexpected results. To keep the behavior consistent on all platforms, just disable "resize to fit" when the window is maximized.
2020-05-16 00:53:43 +08:00
if (screen->fullscreen || screen->maximized) {
Accept resize shortcuts on maximized window Allow "resize to fit" and "resize to pixel-perfect" on maximized window: restore the window to normal size then resize.
2019-11-12 04:44:27 +08:00
return;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
Accept resize shortcuts on maximized window Allow "resize to fit" and "resize to pixel-perfect" on maximized window: restore the window to normal size then resize.
2019-11-12 04:44:27 +08:00
struct size optimal_size =
Store rotated content size This avoids to compute it every time from the frame size.
2020-04-08 20:11:23 +08:00
get_optimal_window_size(screen, screen->content_size);
Accept resize shortcuts on maximized window Allow "resize to fit" and "resize to pixel-perfect" on maximized window: restore the window to normal size then resize.
2019-11-12 04:44:27 +08:00
SDL_SetWindowSize(screen->window, optimal_size.width, optimal_size.height);
Log new size on auto-resize request On "resize to fit" and "resize to pixel-perfect", log the new size.
2020-04-18 06:31:31 +08:00
LOGD("Resized to optimal size: %ux%u", optimal_size.width,
optimal_size.height);
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
Update code style Limit source code to 80 chars, and declare functions return type and modifiers on a separate line. This allows to avoid very long lines, and all function names are aligned. (We do this on VLC, and I like it.)
2019-03-03 03:09:56 +08:00
void
screen_resize_to_pixel_perfect(struct screen *screen) {
Accept resize shortcuts on maximized window Allow "resize to fit" and "resize to pixel-perfect" on maximized window: restore the window to normal size then resize.
2019-11-12 04:44:27 +08:00
if (screen->fullscreen) {
return;
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
Accept resize shortcuts on maximized window Allow "resize to fit" and "resize to pixel-perfect" on maximized window: restore the window to normal size then resize.
2019-11-12 04:44:27 +08:00
if (screen->maximized) {
SDL_RestoreWindow(screen->window);
screen->maximized = false;
}
Store rotated content size This avoids to compute it every time from the frame size.
2020-04-08 20:11:23 +08:00
struct size content_size = screen->content_size;
Add shortcuts to rotate display Add Ctrl+Left and Ctrl+Right shortcuts to rotate the display (the content of the scrcpy window). Contrary to --lock-video-orientation, the rotation has no impact on recording, and can be changed dynamically (and immediately). Fixes #218 <https://github.com/Genymobile/scrcpy/issues/218>
2020-04-08 05:03:23 +08:00
SDL_SetWindowSize(screen->window, content_size.width, content_size.height);
Log new size on auto-resize request On "resize to fit" and "resize to pixel-perfect", log the new size.
2020-04-18 06:31:31 +08:00
LOGD("Resized to pixel-perfect: %ux%u", content_size.width,
content_size.height);
Move screen-related code to screen.c The file scrcpy.c contains too many different things in addition to the main logic, so move the screen code to a separate file, screen.c.
2018-02-08 18:14:13 +08:00
}
Handle window events from screen.c Only the screen knows what to do on window events. This paves the way to handle more window events.
2019-10-20 21:32:33 +08:00
Handle screen-related events from screen.c
2021-02-16 01:44:53 +08:00
bool
screen_handle_event(struct screen *screen, SDL_Event *event) {
switch (event->type) {
case EVENT_NEW_FRAME:
if (!screen->has_frame) {
screen->has_frame = true;
// this is the very first frame, show the window
screen_show_window(screen);
}
bool ok = screen_update_frame(screen);
if (!ok) {
LOGW("Frame update failed\n");
}
return true;
case SDL_WINDOWEVENT:
if (!screen->has_frame) {
// Do nothing
return true;
}
Inline window events handling Now that all screen-related events are handled from screen.c, there is no need for a separate method for window events.
2021-02-16 01:47:17 +08:00
switch (event->window.event) {
case SDL_WINDOWEVENT_EXPOSED:
screen_render(screen, true);
break;
case SDL_WINDOWEVENT_SIZE_CHANGED:
screen_render(screen, true);
break;
case SDL_WINDOWEVENT_MAXIMIZED:
screen->maximized = true;
break;
case SDL_WINDOWEVENT_RESTORED:
if (screen->fullscreen) {
// On Windows, in maximized+fullscreen, disabling
// fullscreen mode unexpectedly triggers the "restored"
// then "maximized" events, leaving the window in a
// weird state (maximized according to the events, but
// not maximized visually).
break;
}
screen->maximized = false;
apply_pending_resize(screen);
break;
}
Handle screen-related events from screen.c
2021-02-16 01:44:53 +08:00
return true;
}
return false;
}
Move rotation coordinates to screen Move the window-to-frame coordinates conversion from the input manager to the screen. This will allow to apply more screen-related transformations without impacting the input manager.
2020-04-18 00:43:29 +08:00
struct point
Fix touch events HiDPI-scaling Touch events were HiDPI-scaled twice: - once because the position (provided as floats between 0 and 1) were converted in pixels using the drawable size (not the window size) - once due to screen_convert_to_frame_coords() One possible fix could be to compute the position in pixels from the window size instead, but this would unnecessarily round the event position to the nearest window coordinates (instead of drawable coordinates). Instead, expose two separate functions to convert to frame coordinates from either window or drawable coordinates. Fixes #1536 <https://github.com/Genymobile/scrcpy/issues/1536> Refs #15 <https://github.com/Genymobile/scrcpy/issues/15> Refs e40532a3761da8b3aef484f1d435ef5f50d94574
2020-06-25 14:54:40 +08:00
screen_convert_drawable_to_frame_coords(struct screen *screen,
int32_t x, int32_t y) {
Move rotation coordinates to screen Move the window-to-frame coordinates conversion from the input manager to the screen. This will allow to apply more screen-related transformations without impacting the input manager.
2020-04-18 00:43:29 +08:00
unsigned rotation = screen->rotation;
assert(rotation < 4);
int32_t w = screen->content_size.width;
int32_t h = screen->content_size.height;
Manually position and scale the content Position and scale the content "manually" instead of relying on the renderer "logical size". This avoids possible rounding differences between the computed window size and the content size, causing one row or column of black pixels on the bottom or on the right. This also avoids HiDPI scale issues, by computing the scaling manually. This will also enable to draw items at their expected size on the screen (unscaled). Fixes #15 <https://github.com/Genymobile/scrcpy/issues/15>
2020-04-18 00:44:24 +08:00
x = (int64_t) (x - screen->rect.x) * w / screen->rect.w;
y = (int64_t) (y - screen->rect.y) * h / screen->rect.h;
// rotate
Move rotation coordinates to screen Move the window-to-frame coordinates conversion from the input manager to the screen. This will allow to apply more screen-related transformations without impacting the input manager.
2020-04-18 00:43:29 +08:00
struct point result;
switch (rotation) {
case 0:
result.x = x;
result.y = y;
break;
case 1:
result.x = h - y;
result.y = x;
break;
case 2:
result.x = w - x;
result.y = h - y;
break;
default:
assert(rotation == 3);
result.x = y;
result.y = w - x;
break;
}
return result;
}
Manually position and scale the content Position and scale the content "manually" instead of relying on the renderer "logical size". This avoids possible rounding differences between the computed window size and the content size, causing one row or column of black pixels on the bottom or on the right. This also avoids HiDPI scale issues, by computing the scaling manually. This will also enable to draw items at their expected size on the screen (unscaled). Fixes #15 <https://github.com/Genymobile/scrcpy/issues/15>
2020-04-18 00:44:24 +08:00
Fix touch events HiDPI-scaling Touch events were HiDPI-scaled twice: - once because the position (provided as floats between 0 and 1) were converted in pixels using the drawable size (not the window size) - once due to screen_convert_to_frame_coords() One possible fix could be to compute the position in pixels from the window size instead, but this would unnecessarily round the event position to the nearest window coordinates (instead of drawable coordinates). Instead, expose two separate functions to convert to frame coordinates from either window or drawable coordinates. Fixes #1536 <https://github.com/Genymobile/scrcpy/issues/1536> Refs #15 <https://github.com/Genymobile/scrcpy/issues/15> Refs e40532a3761da8b3aef484f1d435ef5f50d94574
2020-06-25 14:54:40 +08:00
struct point
screen_convert_window_to_frame_coords(struct screen *screen,
int32_t x, int32_t y) {
screen_hidpi_scale_coords(screen, &x, &y);
return screen_convert_drawable_to_frame_coords(screen, x, y);
}
Manually position and scale the content Position and scale the content "manually" instead of relying on the renderer "logical size". This avoids possible rounding differences between the computed window size and the content size, causing one row or column of black pixels on the bottom or on the right. This also avoids HiDPI scale issues, by computing the scaling manually. This will also enable to draw items at their expected size on the screen (unscaled). Fixes #15 <https://github.com/Genymobile/scrcpy/issues/15>
2020-04-18 00:44:24 +08:00
void
screen_hidpi_scale_coords(struct screen *screen, int32_t *x, int32_t *y) {
// take the HiDPI scaling (dw/ww and dh/wh) into account
int ww, wh, dw, dh;
SDL_GetWindowSize(screen->window, &ww, &wh);
SDL_GL_GetDrawableSize(screen->window, &dw, &dh);
// scale for HiDPI (64 bits for intermediate multiplications)
*x = (int64_t) *x * dw / ww;
*y = (int64_t) *y * dh / wh;
}
Reference in a new issue Copy permalink