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

93 lines
2.2 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
#ifndef SCREEN_H
#define SCREEN_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 <stdbool.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 <SDL2/SDL.h>
#include <libavformat/avformat.h>
Include config.h everywhere Ref: <https://github.com/Genymobile/scrcpy/issues/829> Suggested-by: Louis Kruger <louisk@gmail.com>
2019-09-30 04:36:56 +08:00
#include "config.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 "common.h"
Rename "frames" to "video_buffer" It better describes the purpose of the structure.
2019-03-02 22:16:55 +08:00
struct video_buffer;
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 screen {
SDL_Window *window;
SDL_Renderer *renderer;
SDL_Texture *texture;
struct size frame_size;
Fix rotation while the window is maximized Keep the windowed window size to handle maximized window the same way as fullscreen window. Fixes <https://github.com/Genymobile/scrcpy/issues/750>
2019-11-12 04:26:35 +08:00
// The window size the last time it was not maximized or fullscreen.
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 windowed_window_size;
Fix rotation while the window is maximized Keep the windowed window size to handle maximized window the same way as fullscreen window. Fixes <https://github.com/Genymobile/scrcpy/issues/750>
2019-11-12 04:26:35 +08:00
// Since we receive the event SIZE_CHANGED before MAXIMIZED, we must be
// able to revert the size to its non-maximized value.
struct size windowed_window_size_backup;
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 has_frame;
bool fullscreen;
Fix rotation while the window is maximized Keep the windowed window size to handle maximized window the same way as fullscreen window. Fixes <https://github.com/Genymobile/scrcpy/issues/750>
2019-11-12 04:26:35 +08:00
bool maximized;
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 no_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
};
Fix rotation while the window is maximized Keep the windowed window size to handle maximized window the same way as fullscreen window. Fixes <https://github.com/Genymobile/scrcpy/issues/750>
2019-11-12 04:26:35 +08:00
#define SCREEN_INITIALIZER { \
.window = NULL, \
.renderer = NULL, \
.texture = NULL, \
.frame_size = { \
.width = 0, \
.height = 0, \
}, \
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
.windowed_window_size = { \
Fix rotation while the window is maximized Keep the windowed window size to handle maximized window the same way as fullscreen window. Fixes <https://github.com/Genymobile/scrcpy/issues/750>
2019-11-12 04:26:35 +08:00
.width = 0, \
.height = 0, \
}, \
.windowed_window_size_backup = { \
.width = 0, \
.height = 0, \
}, \
.has_frame = false, \
.fullscreen = false, \
.maximized = false, \
.no_window = 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
}
// initialize default values
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_init(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
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
// initialize screen, create window, renderer and texture (window is hidden)
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,
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
struct size frame_size, bool always_on_top);
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
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
// show 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
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
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
// destroy window, renderer and texture (if any)
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);
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
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
// resize if necessary and write the rendered frame into the texture
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
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_update_frame(struct screen *screen, struct video_buffer *vb);
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
// render the texture to the 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_render(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
// switch the fullscreen mode
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);
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
// resize window to optimal size (remove black borders)
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);
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
// resize window to 1:1 (pixel-perfect)
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);
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
// react to window events
void
screen_handle_window_event(struct screen *screen, const SDL_WindowEvent *event);
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
#endif
Reference in a new issue Copy permalink