Android/scrcpy
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity

Define macros wrappers for logs

Browse source 
Use macros to wrap SDL_Log* functions with the "application" category.
This commit is contained in:
Romain Vimont 2018-02-13 10:10:18 +01:00
parent d45ef1a295
commit 3ed80a1fac
16 changed files with 105 additions and 81 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
app/src/command.c
View file

@ -3,7 +3,8 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <SDL2/SDL_log.h>
#include "log.h"
#define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0]))
@ -67,15 +68,15 @@ process_t adb_push(const char *serial, const char *local, const char *remote) {
SDL_bool process_check_success(process_t proc, const char *name) {
if (proc == PROCESS_NONE) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not execute \"%s\"", name);
LOGE("Could not execute \"%s\"", name);
return SDL_FALSE;
}
exit_code_t exit_code;
if (!cmd_simple_wait(proc, &exit_code)) {
if (exit_code != NO_EXIT_CODE) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "\"%s\" returned with value %" PRIexitcode, name, exit_code);
LOGE("\"%s\" returned with value %" PRIexitcode, name, exit_code);
} else {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "\"%s\" exited unexpectedly", name);
LOGE("\"%s\" exited unexpectedly", name);
}
return SDL_FALSE;
}

4
app/src/controlevent.c
View file

@ -1,9 +1,9 @@
#include "controlevent.h"
#include <SDL2/SDL_log.h>
#include <SDL2/SDL_stdinc.h>
#include "lockutil.h"
#include "log.h"
static inline void write16(Uint8 *buf, Uint16 value) {
buf[0] = value >> 8;
@ -56,7 +56,7 @@ int control_event_serialize(const struct control_event *event, unsigned char *bu
buf[1] = event->command_event.action;
return 2;
default:
SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Unknown event type: %u", (unsigned) event->type);
LOGW("Unknown event type: %u", (unsigned) event->type);
return 0;
}
}

7
app/src/controller.c
View file

@ -1,6 +1,7 @@
#include "controller.h"
#include "lockutil.h"
#include "log.h"
SDL_bool controller_init(struct controller *controller, TCPsocket video_socket) {
if (!control_event_queue_init(&controller->queue)) {
@ -65,7 +66,7 @@ static int run_controller(void *data) {
struct control_event event;
while (control_event_queue_take(&controller->queue, &event)) {
if (!process_event(controller, &event)) {
SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "Cannot write event to socket");
LOGD("Cannot write event to socket");
goto end;
}
}
@ -76,11 +77,11 @@ end:
}
SDL_bool controller_start(struct controller *controller) {
SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "Starting controller thread");
LOGD("Starting controller thread");
controller->thread = SDL_CreateThread(run_controller, "controller", controller);
if (!controller->thread) {
SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not start controller thread");
LOGC("Could not start controller thread");
return SDL_FALSE;
}

27
app/src/decoder.c
View file

@ -10,6 +10,7 @@
#include "events.h"
#include "frames.h"
#include "lockutil.h"
#include "log.h"
#include "netutil.h"
#define BUFSIZE 0x10000
@ -38,39 +39,39 @@ static int run_decoder(void *data) {
AVCodec *codec = avcodec_find_decoder(AV_CODEC_ID_H264);
if (!codec) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "H.264 decoder not found");
LOGE("H.264 decoder not found");
return -1;
}
AVCodecContext *codec_ctx = avcodec_alloc_context3(codec);
if (!codec_ctx) {
SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not allocate decoder context");
LOGC("Could not allocate decoder context");
return -1;
}
if (avcodec_open2(codec_ctx, codec, NULL) < 0) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not open H.264 codec");
LOGE("Could not open H.264 codec");
ret = -1;
goto run_finally_free_codec_ctx;
}
AVFormatContext *format_ctx = avformat_alloc_context();
if (!format_ctx) {
SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not allocate format context");
LOGC("Could not allocate format context");
ret = -1;
goto run_finally_close_codec;
}
unsigned char *buffer = av_malloc(BUFSIZE);
if (!buffer) {
SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not allocate buffer");
LOGC("Could not allocate buffer");
ret = -1;
goto run_finally_free_format_ctx;
}
AVIOContext *avio_ctx = avio_alloc_context(buffer, BUFSIZE, 0, decoder, read_packet, NULL, NULL);
if (!avio_ctx) {
SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not allocate avio context");
LOGC("Could not allocate avio context");
// avformat_open_input takes ownership of 'buffer'
// so only free the buffer before avformat_open_input()
av_free(buffer);
@ -82,7 +83,7 @@ static int run_decoder(void *data) {
//const char *url = "tcp://127.0.0.1:1234";
if (avformat_open_input(&format_ctx, NULL, NULL, NULL) < 0) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not open video stream");
LOGE("Could not open video stream");
ret = -1;
goto run_finally_free_avio_ctx;
}
@ -100,7 +101,7 @@ static int run_decoder(void *data) {
int got_picture;
int len = avcodec_decode_video2(codec_ctx, decoder->frames->decoding_frame, &got_picture, &packet);
if (len < 0) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not decode video packet: %d", len);
LOGE("Could not decode video packet: %d", len);
goto run_quit;
}
if (got_picture) {
@ -112,11 +113,11 @@ static int run_decoder(void *data) {
#else
int ret;
if ((ret = avcodec_send_packet(codec_ctx, &packet)) < 0) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not send video packet: %d", ret);
LOGE("Could not send video packet: %d", ret);
goto run_quit;
}
if ((ret = avcodec_receive_frame(codec_ctx, decoder->frames->decoding_frame)) < 0) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not receive video frame: %d", ret);
LOGE("Could not receive video frame: %d", ret);
goto run_quit;
}
@ -124,7 +125,7 @@ static int run_decoder(void *data) {
#endif
}
SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "End of frames");
LOGD("End of frames");
run_quit:
avformat_close_input(&format_ctx);
@ -146,11 +147,11 @@ void decoder_init(struct decoder *decoder, struct frames *frames, TCPsocket vide
}
SDL_bool decoder_start(struct decoder *decoder) {
SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "Starting decoder thread");
LOGD("Starting decoder thread");
decoder->thread = SDL_CreateThread(run_decoder, "video_decoder", decoder);
if (!decoder->thread) {
SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not start decoder thread");
LOGC("Could not start decoder thread");
return SDL_FALSE;
}

3
app/src/device.c
View file

@ -1,9 +1,10 @@
#include "device.h"
#include "log.h"
SDL_bool device_read_info(TCPsocket device_socket, char *device_name, struct size *size) {
unsigned char buf[DEVICE_NAME_FIELD_LENGTH + 4];
if (SDLNet_TCP_Recv(device_socket, buf, sizeof(buf)) <= 0) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not retrieve device information");
LOGE("Could not retrieve device information");
return SDL_FALSE;
}
buf[DEVICE_NAME_FIELD_LENGTH - 1] = '\0'; // in case the client sends garbage

4
app/src/frames.c
View file

@ -1,13 +1,13 @@
#include "frames.h"
#include <SDL2/SDL_assert.h>
#include <SDL2/SDL_log.h>
#include <SDL2/SDL_mutex.h>
#include <libavutil/avutil.h>
#include <libavformat/avformat.h>
#include "config.h"
#include "lockutil.h"
#include "log.h"
SDL_bool frames_init(struct frames *frames) {
if (!(frames->decoding_frame = av_frame_alloc())) {
@ -69,7 +69,7 @@ SDL_bool frames_offer_decoded_frame(struct frames *frames) {
}
#else
if (!frames->rendering_frame_consumed) {
SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "Skip frame");
LOGD("Skip frame");
}
#endif

11
app/src/lockutil.c
View file

@ -1,31 +1,32 @@
#include <stdlib.h>
#include <SDL2/SDL_log.h>
#include <SDL2/SDL_mutex.h>
#include "log.h"
void mutex_lock(SDL_mutex *mutex) {
if (SDL_LockMutex(mutex)) {
SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not lock mutex");
LOGC("Could not lock mutex");
abort();
}
}
void mutex_unlock(SDL_mutex *mutex) {
if (SDL_UnlockMutex(mutex)) {
SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not unlock mutex");
LOGC("Could not unlock mutex");
abort();
}
}
void cond_wait(SDL_cond *cond, SDL_mutex *mutex) {
if (SDL_CondWait(cond, mutex)) {
SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not wait on condition");
LOGC("Could not wait on condition");
abort();
}
}
void cond_signal(SDL_cond *cond) {
if (SDL_CondSignal(cond)) {
SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not signal a condition");
LOGC("Could not signal a condition");
abort();
}
}

12
app/src/log.h Normal file
View file

@ -0,0 +1,12 @@
#ifndef LOG_H
#define LOG_H
#include <SDL2/SDL_log.h>
#define LOGD(...) SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
#define LOGI(...) SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
#define LOGW(...) SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
#define LOGE(...) SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
#define LOGC(...) SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, __VA_ARGS__)
#endif

23
app/src/main.c
View file

@ -7,6 +7,7 @@
#include <SDL2/SDL_net.h>
#include "config.h"
#include "log.h"
struct args {
const char *serial;
@ -122,16 +123,16 @@ static int parse_args(struct args *args, int argc, char *argv[]) {
case 'p': {
char *endptr;
if (*optarg == '\0') {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Invalid port parameter is empty");
LOGE("Invalid port parameter is empty");
return -1;
}
long value = strtol(optarg, &endptr, 0);
if (*endptr != '\0') {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Invalid port: %s", optarg);
LOGE("Invalid port: %s", optarg);
return -1;
}
if (value & ~0xffff) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Port out of range: %ld", value);
LOGE("Port out of range: %ld", value);
return -1;
}
args->port = (Uint16) value;
@ -140,16 +141,16 @@ static int parse_args(struct args *args, int argc, char *argv[]) {
case 'm': {
char *endptr;
if (*optarg == '\0') {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Max size parameter is empty");
LOGE("Max size parameter is empty");
return -1;
}
long value = strtol(optarg, &endptr, 0);
if (*endptr != '\0') {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Invalid max size: %s", optarg);
LOGE("Invalid max size: %s", optarg);
return -1;
}
if (value & ~0xffff) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Max size must be between 0 and 65535: %ld", value);
LOGE("Max size must be between 0 and 65535: %ld", value);
return -1;
}
args->max_size = (Uint16) value;
@ -158,14 +159,14 @@ static int parse_args(struct args *args, int argc, char *argv[]) {
case 'b': {
char *endptr;
if (*optarg == '\0') {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Bit-rate parameter is empty");
LOGE("Bit-rate parameter is empty");
return -1;
}
long value = strtol(optarg, &endptr, 0);
int mul = 1;
if (*endptr != '\0') {
if (optarg == endptr) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Invalid bit-rate: %s", optarg);
LOGE("Invalid bit-rate: %s", optarg);
return -1;
}
if ((*endptr == 'M' || *endptr == 'm') && endptr[1] == '\0') {
@ -173,12 +174,12 @@ static int parse_args(struct args *args, int argc, char *argv[]) {
} else if ((*endptr == 'K' || *endptr == 'k') && endptr[1] == '\0') {
mul = 1000;
} else {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Invalid bit-rate unit: %s", optarg);
LOGE("Invalid bit-rate unit: %s", optarg);
return -1;
}
}
if (value < 0 || ((Uint32) -1) / mul < value) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Bitrate must be positive and less than 2^32: %s", optarg);
LOGE("Bitrate must be positive and less than 2^32: %s", optarg);
return -1;
}
args->bit_rate = (Uint32) value * mul;
@ -195,7 +196,7 @@ static int parse_args(struct args *args, int argc, char *argv[]) {
args->serial = argv[index++];
}
if (index < argc) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Unexpected additional argument: %s", argv[index]);
LOGE("Unexpected additional argument: %s", argv[index]);
return -1;
}
return 0;

8
app/src/netutil.c
View file

@ -2,23 +2,25 @@
#include <SDL2/SDL_net.h>
#include "log.h"
// contrary to SDLNet_TCP_Send and SDLNet_TCP_Recv, SDLNet_TCP_Accept is non-blocking
// so we need to block before calling it
TCPsocket server_socket_accept(TCPsocket server_socket, Uint32 timeout_ms) {
SDLNet_SocketSet set = SDLNet_AllocSocketSet(1);
if (!set) {
SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not allocate socket set");
LOGC("Could not allocate socket set");
return NULL;
}
if (SDLNet_TCP_AddSocket(set, server_socket) == -1) {
SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not add socket to set");
LOGC("Could not add socket to set");
SDLNet_FreeSocketSet(set);
return NULL;
}
if (SDLNet_CheckSockets(set, timeout_ms) != 1) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "No connection to accept");
LOGE("No connection to accept");
SDLNet_FreeSocketSet(set);
return NULL;
}

9
app/src/scrcpy.c
View file

@ -15,6 +15,7 @@
#include "device.h"
#include "events.h"
#include "frames.h"
#include "log.h"
#include "lockutil.h"
#include "netutil.h"
#include "screen.h"
@ -40,7 +41,7 @@ static void count_frame(void) {
long now = timestamp_ms();
++nbframes;
if (now - ts > 1000) {
SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "%d fps", nbframes);
LOGD("%d fps", nbframes);
ts = now;
nbframes = 0;
}
@ -51,10 +52,10 @@ static void event_loop(void) {
while (SDL_WaitEvent(&event)) {
switch (event.type) {
case EVENT_DECODER_STOPPED:
SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "Video decoder stopped");
LOGD("Video decoder stopped");
return;
case SDL_QUIT:
SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "User requested to quit");
LOGD("User requested to quit");
return;
case EVENT_NEW_FRAME:
if (!screen.has_frame) {
@ -167,7 +168,7 @@ SDL_bool scrcpy(const char *serial, Uint16 local_port, Uint16 max_size, Uint32 b
event_loop();
SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "quit...");
LOGD("quit...");
screen_destroy(&screen);
finally_stop_and_join_controller:
controller_stop(&controller);

35
app/src/screen.c
View file

@ -5,13 +5,14 @@
#include "icon.xpm"
#include "lockutil.h"
#include "log.h"
#include "tinyxpm.h"
#define DISPLAY_MARGINS 96
SDL_bool sdl_init_and_configure(void) {
if (SDL_Init(SDL_INIT_VIDEO)) {
SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not initialize SDL: %s", SDL_GetError());
LOGC("Could not initialize SDL: %s", SDL_GetError());
return SDL_FALSE;
}
@ -19,13 +20,13 @@ SDL_bool sdl_init_and_configure(void) {
// Bilinear resizing
if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1")) {
SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Could not enable bilinear filtering");
LOGW("Could not enable bilinear filtering");
}
#if SDL_VERSION_ATLEAST(2, 0, 5)
// Handle a click to gain focus as any other click
if (!SDL_SetHint(SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, "1")) {
SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Could not enable mouse focus clickthrough");
LOGW("Could not enable mouse focus clickthrough");
}
#endif
@ -73,7 +74,7 @@ static SDL_bool get_preferred_display_bounds(struct size *bounds) {
# define GET_DISPLAY_BOUNDS(i, r) SDL_GetDisplayBounds((i), (r))
#endif
if (GET_DISPLAY_BOUNDS(0, &rect)) {
SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Could not get display usable bounds: %s", SDL_GetError());
LOGW("Could not get display usable bounds: %s", SDL_GetError());
return SDL_FALSE;
}
@ -137,37 +138,37 @@ SDL_bool screen_init_rendering(struct screen *screen, const char *device_name, s
screen->window = SDL_CreateWindow(device_name, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
window_size.width, window_size.height, SDL_WINDOW_HIDDEN | SDL_WINDOW_RESIZABLE);
if (!screen->window) {
SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not create window: %s", SDL_GetError());
LOGC("Could not create window: %s", SDL_GetError());
return SDL_FALSE;
}
screen->renderer = SDL_CreateRenderer(screen->window, -1, SDL_RENDERER_ACCELERATED);
if (!screen->renderer) {
SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not create renderer: %s", SDL_GetError());
LOGC("Could not create renderer: %s", SDL_GetError());
screen_destroy(screen);
return SDL_FALSE;
}
if (SDL_RenderSetLogicalSize(screen->renderer, frame_size.width, frame_size.height)) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not set renderer logical size: %s", SDL_GetError());
LOGE("Could not set renderer logical size: %s", SDL_GetError());
screen_destroy(screen);
return SDL_FALSE;
}
SDL_Surface *icon = read_xpm(icon_xpm);
if (!icon) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not load icon: %s", SDL_GetError());
LOGE("Could not load icon: %s", SDL_GetError());
screen_destroy(screen);
return SDL_FALSE;
}
SDL_SetWindowIcon(screen->window, icon);
SDL_FreeSurface(icon);
SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Initial texture: %" PRIu16 "x%" PRIu16, frame_size.width, frame_size.height);
LOGI("Initial texture: %" PRIu16 "x%" PRIu16, frame_size.width, frame_size.height);
screen->texture = SDL_CreateTexture(screen->renderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING,
frame_size.width, frame_size.height);
if (!screen->texture) {
SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not create texture: %s", SDL_GetError());
LOGC("Could not create texture: %s", SDL_GetError());
screen_destroy(screen);
return SDL_FALSE;
}
@ -196,7 +197,7 @@ void screen_destroy(struct screen *screen) {
static SDL_bool 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) {
if (SDL_RenderSetLogicalSize(screen->renderer, new_frame_size.width, new_frame_size.height)) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not set renderer logical size: %s", SDL_GetError());
LOGE("Could not set renderer logical size: %s", SDL_GetError());
return SDL_FALSE;
}
@ -213,12 +214,12 @@ static SDL_bool prepare_for_frame(struct screen *screen, struct size new_frame_s
screen->frame_size = new_frame_size;
SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "New texture: %" PRIu16 "x%" PRIu16,
LOGD("New texture: %" PRIu16 "x%" PRIu16,
screen->frame_size.width, screen->frame_size.height);
screen->texture = SDL_CreateTexture(screen->renderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING,
new_frame_size.width, new_frame_size.height);
if (!screen->texture) {
SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not create texture: %s", SDL_GetError());
LOGC("Could not create texture: %s", SDL_GetError());
return SDL_FALSE;
}
}
@ -262,7 +263,7 @@ void screen_switch_fullscreen(struct screen *screen) {
}
Uint32 new_mode = screen->fullscreen ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP;
if (SDL_SetWindowFullscreen(screen->window, new_mode)) {
SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Could not switch fullscreen mode: %s", SDL_GetError());
LOGW("Could not switch fullscreen mode: %s", SDL_GetError());
return;
}
@ -272,7 +273,7 @@ void screen_switch_fullscreen(struct screen *screen) {
SDL_SetWindowSize(screen->window, screen->windowed_window_size.width, screen->windowed_window_size.height);
}
SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "Switched to %s mode", screen->fullscreen ? "fullscreen" : "windowed");
LOGD("Switched to %s mode", screen->fullscreen ? "fullscreen" : "windowed");
screen_render(screen);
}
@ -280,13 +281,13 @@ void screen_resize_to_fit(struct screen *screen) {
if (!screen->fullscreen) {
struct size optimal_size = get_optimal_window_size(screen, screen->frame_size);
SDL_SetWindowSize(screen->window, optimal_size.width, optimal_size.height);
SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "Resized to optimal size");
LOGD("Resized to optimal size");
}
}
void screen_resize_to_pixel_perfect(struct screen *screen) {
if (!screen->fullscreen) {
SDL_SetWindowSize(screen->window, screen->frame_size.width, screen->frame_size.height);
SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "Resized to pixel-perfect");
LOGD("Resized to pixel-perfect");
}
}

19
app/src/screencontrol.c
View file

@ -1,8 +1,7 @@
#include "screencontrol.h"
#include <SDL2/SDL_log.h>
#include "convert.h"
#include "log.h"
static struct point get_mouse_point(void) {
int x;
@ -32,14 +31,14 @@ static void send_keycode(struct controller *controller, enum android_keycode key
};
if (!controller_push_event(controller, &control_event)) {
SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Cannot send %s (DOWN)", name);
LOGW("Cannot send %s (DOWN)", name);
return;
}
// send UP event
control_event.keycode_event.action = AKEY_EVENT_ACTION_UP;
if (!controller_push_event(controller, &control_event)) {
SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Cannot send %s (UP)", name);
LOGW("Cannot send %s (UP)", name);
}
}
@ -75,7 +74,7 @@ static void turn_screen_on(struct controller *controller) {
},
};
if (!controller_push_event(controller, &control_event)) {
SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Cannot turn screen on");
LOGW("Cannot turn screen on");
}
}
@ -99,7 +98,7 @@ void screencontrol_handle_text_input(struct controller *controller,
strncpy(control_event.text_event.text, event->text, TEXT_MAX_LENGTH);
control_event.text_event.text[TEXT_MAX_LENGTH] = '\0';
if (!controller_push_event(controller, &control_event)) {
SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Cannot send text event");
LOGW("Cannot send text event");
}
}
@ -154,7 +153,7 @@ void screencontrol_handle_key(struct controller *controller,
struct control_event control_event;
if (input_key_from_sdl_to_android(event, &control_event)) {
if (!controller_push_event(controller, &control_event)) {
SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Cannot send control event");
LOGW("Cannot send control event");
}
}
}
@ -169,7 +168,7 @@ void screencontrol_handle_mouse_motion(struct controller *controller,
struct control_event control_event;
if (mouse_motion_from_sdl_to_android(event, screen->frame_size, &control_event)) {
if (!controller_push_event(controller, &control_event)) {
SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Cannot send mouse motion event");
LOGW("Cannot send mouse motion event");
}
}
}
@ -184,7 +183,7 @@ void screencontrol_handle_mouse_button(struct controller *controller,
struct control_event control_event;
if (mouse_button_from_sdl_to_android(event, screen->frame_size, &control_event)) {
if (!controller_push_event(controller, &control_event)) {
SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Cannot send mouse button event");
LOGW("Cannot send mouse button event");
}
}
}
@ -199,7 +198,7 @@ void screencontrol_handle_mouse_wheel(struct controller *controller,
struct control_event control_event;
if (mouse_wheel_from_sdl_to_android(event, position, &control_event)) {
if (!controller_push_event(controller, &control_event)) {
SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Cannot send wheel button event");
LOGW("Cannot send wheel button event");
}
}
}

7
app/src/server.c
View file

@ -1,9 +1,10 @@
#include "server.h"
#include <SDL2/SDL_log.h>
#include <SDL2/SDL_net.h>
#include <errno.h>
#include <stdint.h>
#include "log.h"
#include "netutil.h"
#define SOCKET_NAME "scrcpy"
@ -46,7 +47,7 @@ static process_t execute_server(const char *serial, Uint16 max_size, Uint32 bit_
static void terminate_server(process_t server) {
if (!cmd_terminate(server)) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not terminate server: %s", strerror(errno));
LOGE("Could not terminate server: %s", strerror(errno));
}
}
@ -80,7 +81,7 @@ SDL_bool server_start(struct server *server, const char *serial, Uint16 local_po
server->server_socket = listen_on_port(local_port);
if (!server->server_socket) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not listen on port %" PRIu16, local_port);
LOGE("Could not listen on port %" PRIu16, local_port);
disable_tunnel(serial);
return SDL_FALSE;
}

4
app/src/sys/win/command.c
View file

@ -1,6 +1,6 @@
#include "../../command.h"
#include <SDL2/SDL_log.h>
#include "../../log.h"
#include "../../strutil.h"
HANDLE cmd_execute(const char *path, const char *const argv[]) {
@ -16,7 +16,7 @@ HANDLE cmd_execute(const char *path, const char *const argv[]) {
char cmd[256];
size_t ret = xstrjoin(cmd, argv, ' ', sizeof(cmd));
if (ret >= sizeof(cmd)) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Command too long (%" PRIsizet " chars)", sizeof(cmd) - 1);
LOGE("Command too long (%" PRIsizet " chars)", sizeof(cmd) - 1);
return NULL;
}

4
app/src/tinyxpm.c
View file

@ -3,6 +3,8 @@
#include <stdio.h>
#include <stdlib.h>
#include "log.h"
struct index {
char c;
Uint32 color;
@ -69,7 +71,7 @@ SDL_Surface *read_xpm(char *xpm[]) {
// parse image
Uint32 *pixels = SDL_malloc(4 * width * height);
if (!pixels) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not allocate icon memory");
LOGE("Could not allocate icon memory");
return NULL;
}
for (int y = 0; y < height; ++y) {