From dfed1b250e5aada1c0b4c75fbaf54aebc19a92d5 Mon Sep 17 00:00:00 2001 From: Romain Vimont Date: Sat, 2 Mar 2019 23:52:22 +0100 Subject: [PATCH] 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 --- app/src/buffer_util.h | 19 +++--- app/src/command.c | 8 +-- app/src/command.h | 8 +-- app/src/common.h | 10 +-- app/src/control_event.c | 29 +++++---- app/src/control_event.h | 17 ++--- app/src/controller.c | 35 ++++++----- app/src/controller.h | 10 +-- app/src/convert.c | 40 ++++++------ app/src/convert.h | 11 ++-- app/src/decoder.c | 20 +++--- app/src/decoder.h | 6 +- app/src/device.c | 6 +- app/src/device.h | 4 +- app/src/file_handler.c | 58 ++++++++--------- app/src/file_handler.h | 13 ++-- app/src/fps_counter.c | 10 +-- app/src/fps_counter.h | 7 ++- app/src/input_manager.c | 18 +++--- app/src/input_manager.h | 4 +- app/src/main.c | 126 +++++++++++++++++++------------------ app/src/net.c | 6 +- app/src/net.h | 13 ++-- app/src/recorder.c | 36 +++++------ app/src/recorder.h | 10 +-- app/src/scrcpy.c | 64 +++++++++---------- app/src/scrcpy.h | 21 ++++--- app/src/screen.c | 59 ++++++++--------- app/src/screen.h | 21 ++++--- app/src/server.c | 63 +++++++++---------- app/src/server.h | 23 ++++--- app/src/stream.c | 24 +++---- app/src/stream.h | 7 ++- app/src/sys/unix/command.c | 4 +- app/src/sys/unix/net.c | 8 +-- app/src/sys/win/command.c | 4 +- app/src/sys/win/net.c | 8 +-- app/src/tiny_xpm.c | 34 +++++----- app/src/video_buffer.c | 20 +++--- app/src/video_buffer.h | 10 +-- 40 files changed, 456 insertions(+), 438 deletions(-) diff --git a/app/src/buffer_util.h b/app/src/buffer_util.h index 9b2f0780..5d94deef 100644 --- a/app/src/buffer_util.h +++ b/app/src/buffer_util.h @@ -1,32 +1,33 @@ #ifndef BUFFER_UTIL_H #define BUFFER_UTIL_H -#include +#include +#include static inline void -buffer_write16be(Uint8 *buf, Uint16 value) { +buffer_write16be(uint8_t *buf, uint16_t value) { buf[0] = value >> 8; buf[1] = value; } static inline void -buffer_write32be(Uint8 *buf, Uint32 value) { +buffer_write32be(uint8_t *buf, uint32_t value) { buf[0] = value >> 24; buf[1] = value >> 16; buf[2] = value >> 8; buf[3] = value; } -static inline Uint32 -buffer_read32be(Uint8 *buf) { +static inline uint32_t +buffer_read32be(uint8_t *buf) { return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3]; } static inline -Uint64 buffer_read64be(Uint8 *buf) { - Uint32 msb = buffer_read32be(buf); - Uint32 lsb = buffer_read32be(&buf[4]); - return ((Uint64) msb << 32) | lsb; +uint64_t buffer_read64be(uint8_t *buf) { + uint32_t msb = buffer_read32be(buf); + uint32_t lsb = buffer_read32be(&buf[4]); + return ((uint64_t) msb << 32) | lsb; } #endif diff --git a/app/src/command.c b/app/src/command.c index 01f82344..2e116ac8 100644 --- a/app/src/command.c +++ b/app/src/command.c @@ -146,11 +146,11 @@ adb_install(const char *serial, const char *local) { return proc; } -SDL_bool +bool process_check_success(process_t proc, const char *name) { if (proc == PROCESS_NONE) { LOGE("Could not execute \"%s\"", name); - return SDL_FALSE; + return false; } exit_code_t exit_code; if (!cmd_simple_wait(proc, &exit_code)) { @@ -159,7 +159,7 @@ process_check_success(process_t proc, const char *name) { } else { LOGE("\"%s\" exited unexpectedly", name); } - return SDL_FALSE; + return false; } - return SDL_TRUE; + return true; } diff --git a/app/src/command.h b/app/src/command.h index 835fce25..6681f5ea 100644 --- a/app/src/command.h +++ b/app/src/command.h @@ -1,8 +1,8 @@ #ifndef COMMAND_H #define COMMAND_H +#include #include -#include #ifdef _WIN32 @@ -42,10 +42,10 @@ enum process_result { enum process_result cmd_execute(const char *path, const char *const argv[], process_t *process); -SDL_bool +bool cmd_terminate(process_t pid); -SDL_bool +bool cmd_simple_wait(process_t pid, exit_code_t *exit_code); process_t @@ -73,7 +73,7 @@ adb_install(const char *serial, const char *local); // convenience function to wait for a successful process execution // automatically log process errors with the provided process name -SDL_bool +bool process_check_success(process_t process, const char *name); #endif diff --git a/app/src/common.h b/app/src/common.h index 133f09f5..8963f058 100644 --- a/app/src/common.h +++ b/app/src/common.h @@ -1,20 +1,20 @@ #ifndef COMMON_H #define COMMON_H -#include +#include #define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0])) #define MIN(X,Y) (X) < (Y) ? (X) : (Y) #define MAX(X,Y) (X) > (Y) ? (X) : (Y) struct size { - Uint16 width; - Uint16 height; + uint16_t width; + uint16_t height; }; struct point { - Sint32 x; - Sint32 y; + int32_t x; + int32_t y; }; struct position { diff --git a/app/src/control_event.c b/app/src/control_event.c index 9ed69b71..40de6efc 100644 --- a/app/src/control_event.c +++ b/app/src/control_event.c @@ -1,6 +1,5 @@ #include "control_event.h" -#include #include #include "buffer_util.h" @@ -8,7 +7,7 @@ #include "log.h" static void -write_position(Uint8 *buf, const struct position *position) { +write_position(uint8_t *buf, const struct position *position) { buffer_write32be(&buf[0], position->point.x); buffer_write32be(&buf[4], position->point.y); buffer_write16be(&buf[8], position->screen_size.width); @@ -31,7 +30,7 @@ control_event_serialize(const struct control_event *event, unsigned char *buf) { // injecting a text takes time, so limit the text length len = TEXT_MAX_LENGTH; } - buffer_write16be(&buf[1], (Uint16) len); + buffer_write16be(&buf[1], (uint16_t) len); memcpy(&buf[3], event->text_event.text, len); return 3 + len; } @@ -42,8 +41,8 @@ control_event_serialize(const struct control_event *event, unsigned char *buf) { return 18; case CONTROL_EVENT_TYPE_SCROLL: write_position(&buf[1], &event->scroll_event.position); - buffer_write32be(&buf[13], (Uint32) event->scroll_event.hscroll); - buffer_write32be(&buf[17], (Uint32) event->scroll_event.vscroll); + buffer_write32be(&buf[13], (uint32_t) event->scroll_event.hscroll); + buffer_write32be(&buf[17], (uint32_t) event->scroll_event.vscroll); return 21; case CONTROL_EVENT_TYPE_COMMAND: buf[1] = event->command_event.action; @@ -61,22 +60,22 @@ control_event_destroy(struct control_event *event) { } } -SDL_bool +bool control_event_queue_is_empty(const struct control_event_queue *queue) { return queue->head == queue->tail; } -SDL_bool +bool control_event_queue_is_full(const struct control_event_queue *queue) { return (queue->head + 1) % CONTROL_EVENT_QUEUE_SIZE == queue->tail; } -SDL_bool +bool control_event_queue_init(struct control_event_queue *queue) { queue->head = 0; queue->tail = 0; // the current implementation may not fail - return SDL_TRUE; + return true; } void @@ -88,24 +87,24 @@ control_event_queue_destroy(struct control_event_queue *queue) { } } -SDL_bool +bool control_event_queue_push(struct control_event_queue *queue, const struct control_event *event) { if (control_event_queue_is_full(queue)) { - return SDL_FALSE; + return false; } queue->data[queue->head] = *event; queue->head = (queue->head + 1) % CONTROL_EVENT_QUEUE_SIZE; - return SDL_TRUE; + return true; } -SDL_bool +bool control_event_queue_take(struct control_event_queue *queue, struct control_event *event) { if (control_event_queue_is_empty(queue)) { - return SDL_FALSE; + return false; } *event = queue->data[queue->tail]; queue->tail = (queue->tail + 1) % CONTROL_EVENT_QUEUE_SIZE; - return SDL_TRUE; + return true; } diff --git a/app/src/control_event.h b/app/src/control_event.h index 18294ef8..2a33244b 100644 --- a/app/src/control_event.h +++ b/app/src/control_event.h @@ -1,8 +1,9 @@ #ifndef CONTROLEVENT_H #define CONTROLEVENT_H +#include +#include #include -#include #include "android/input.h" #include "android/keycodes.h" @@ -44,8 +45,8 @@ struct control_event { } mouse_event; struct { struct position position; - Sint32 hscroll; - Sint32 vscroll; + int32_t hscroll; + int32_t vscroll; } scroll_event; struct { enum control_event_command action; @@ -63,24 +64,24 @@ struct control_event_queue { int control_event_serialize(const struct control_event *event, unsigned char *buf); -SDL_bool +bool control_event_queue_init(struct control_event_queue *queue); void control_event_queue_destroy(struct control_event_queue *queue); -SDL_bool +bool control_event_queue_is_empty(const struct control_event_queue *queue); -SDL_bool +bool control_event_queue_is_full(const struct control_event_queue *queue); // event is copied, the queue does not use the event after the function returns -SDL_bool +bool control_event_queue_push(struct control_event_queue *queue, const struct control_event *event); -SDL_bool +bool control_event_queue_take(struct control_event_queue *queue, struct control_event *event); diff --git a/app/src/controller.c b/app/src/controller.c index 89be7e98..8b95e88c 100644 --- a/app/src/controller.c +++ b/app/src/controller.c @@ -1,29 +1,30 @@ #include "controller.h" #include + #include "config.h" #include "lock_util.h" #include "log.h" -SDL_bool +bool controller_init(struct controller *controller, socket_t video_socket) { if (!control_event_queue_init(&controller->queue)) { - return SDL_FALSE; + return false; } if (!(controller->mutex = SDL_CreateMutex())) { - return SDL_FALSE; + return false; } if (!(controller->event_cond = SDL_CreateCond())) { SDL_DestroyMutex(controller->mutex); - return SDL_FALSE; + return false; } controller->video_socket = video_socket; - controller->stopped = SDL_FALSE; + controller->stopped = false; - return SDL_TRUE; + return true; } void @@ -33,12 +34,12 @@ controller_destroy(struct controller *controller) { control_event_queue_destroy(&controller->queue); } -SDL_bool +bool controller_push_event(struct controller *controller, const struct control_event *event) { - SDL_bool res; + bool res; mutex_lock(controller->mutex); - SDL_bool was_empty = control_event_queue_is_empty(&controller->queue); + bool was_empty = control_event_queue_is_empty(&controller->queue); res = control_event_queue_push(&controller->queue, event); if (was_empty) { cond_signal(controller->event_cond); @@ -47,13 +48,13 @@ controller_push_event(struct controller *controller, return res; } -static SDL_bool +static bool process_event(struct controller *controller, const struct control_event *event) { unsigned char serialized_event[SERIALIZED_EVENT_MAX_SIZE]; int length = control_event_serialize(event, serialized_event); if (!length) { - return SDL_FALSE; + return false; } int w = net_send_all(controller->video_socket, serialized_event, length); return w == length; @@ -75,12 +76,12 @@ run_controller(void *data) { break; } struct control_event event; - SDL_bool non_empty = control_event_queue_take(&controller->queue, + bool non_empty = control_event_queue_take(&controller->queue, &event); SDL_assert(non_empty); mutex_unlock(controller->mutex); - SDL_bool ok = process_event(controller, &event); + bool ok = process_event(controller, &event); control_event_destroy(&event); if (!ok) { LOGD("Cannot write event to socket"); @@ -90,7 +91,7 @@ run_controller(void *data) { return 0; } -SDL_bool +bool controller_start(struct controller *controller) { LOGD("Starting controller thread"); @@ -98,16 +99,16 @@ controller_start(struct controller *controller) { controller); if (!controller->thread) { LOGC("Could not start controller thread"); - return SDL_FALSE; + return false; } - return SDL_TRUE; + return true; } void controller_stop(struct controller *controller) { mutex_lock(controller->mutex); - controller->stopped = SDL_TRUE; + controller->stopped = true; cond_signal(controller->event_cond); mutex_unlock(controller->mutex); } diff --git a/app/src/controller.h b/app/src/controller.h index 5afebc82..2f7696e3 100644 --- a/app/src/controller.h +++ b/app/src/controller.h @@ -3,8 +3,8 @@ #include "control_event.h" +#include #include -#include #include #include "net.h" @@ -14,17 +14,17 @@ struct controller { SDL_Thread *thread; SDL_mutex *mutex; SDL_cond *event_cond; - SDL_bool stopped; + bool stopped; struct control_event_queue queue; }; -SDL_bool +bool controller_init(struct controller *controller, socket_t video_socket); void controller_destroy(struct controller *controller); -SDL_bool +bool controller_start(struct controller *controller); void @@ -34,7 +34,7 @@ void controller_join(struct controller *controller); // expose simple API to hide control_event_queue -SDL_bool +bool controller_push_event(struct controller *controller, const struct control_event *event); diff --git a/app/src/convert.c b/app/src/convert.c index 6bdd9631..d20e255f 100644 --- a/app/src/convert.c +++ b/app/src/convert.c @@ -1,9 +1,9 @@ #include "convert.h" -#define MAP(FROM, TO) case FROM: *to = TO; return SDL_TRUE -#define FAIL default: return SDL_FALSE +#define MAP(FROM, TO) case FROM: *to = TO; return true +#define FAIL default: return false -static SDL_bool +static bool convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) { switch (from) { MAP(SDL_KEYDOWN, AKEY_EVENT_ACTION_DOWN); @@ -73,8 +73,8 @@ convert_meta_state(SDL_Keymod mod) { return autocomplete_metastate(metastate); } -static SDL_bool -convert_keycode(SDL_Keycode from, enum android_keycode *to, Uint16 mod) { +static bool +convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod) { switch (from) { MAP(SDLK_RETURN, AKEYCODE_ENTER); MAP(SDLK_KP_ENTER, AKEYCODE_NUMPAD_ENTER); @@ -92,7 +92,7 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, Uint16 mod) { MAP(SDLK_UP, AKEYCODE_DPAD_UP); } if (mod & (KMOD_LALT | KMOD_RALT | KMOD_LGUI | KMOD_RGUI)) { - return SDL_FALSE; + return false; } // if ALT and META are not pressed, also handle letters and space switch (from) { @@ -127,7 +127,7 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, Uint16 mod) { } } -static SDL_bool +static bool convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to) { switch (from) { MAP(SDL_MOUSEBUTTONDOWN, AMOTION_EVENT_ACTION_DOWN); @@ -137,7 +137,7 @@ convert_mouse_action(SDL_EventType from, enum android_motionevent_action *to) { } static enum android_motionevent_buttons -convert_mouse_buttons(Uint32 state) { +convert_mouse_buttons(uint32_t state) { enum android_motionevent_buttons buttons = 0; if (state & SDL_BUTTON_LMASK) { buttons |= AMOTION_EVENT_BUTTON_PRIMARY; @@ -157,33 +157,33 @@ convert_mouse_buttons(Uint32 state) { return buttons; } -SDL_bool +bool input_key_from_sdl_to_android(const SDL_KeyboardEvent *from, struct control_event *to) { to->type = CONTROL_EVENT_TYPE_KEYCODE; if (!convert_keycode_action(from->type, &to->keycode_event.action)) { - return SDL_FALSE; + return false; } - Uint16 mod = from->keysym.mod; + uint16_t mod = from->keysym.mod; if (!convert_keycode(from->keysym.sym, &to->keycode_event.keycode, mod)) { - return SDL_FALSE; + return false; } to->keycode_event.metastate = convert_meta_state(mod); - return SDL_TRUE; + return true; } -SDL_bool +bool mouse_button_from_sdl_to_android(const SDL_MouseButtonEvent *from, struct size screen_size, struct control_event *to) { to->type = CONTROL_EVENT_TYPE_MOUSE; if (!convert_mouse_action(from->type, &to->mouse_event.action)) { - return SDL_FALSE; + return false; } to->mouse_event.buttons = convert_mouse_buttons(SDL_BUTTON(from->button)); @@ -191,10 +191,10 @@ mouse_button_from_sdl_to_android(const SDL_MouseButtonEvent *from, to->mouse_event.position.point.x = from->x; to->mouse_event.position.point.y = from->y; - return SDL_TRUE; + return true; } -SDL_bool +bool mouse_motion_from_sdl_to_android(const SDL_MouseMotionEvent *from, struct size screen_size, struct control_event *to) { @@ -205,10 +205,10 @@ mouse_motion_from_sdl_to_android(const SDL_MouseMotionEvent *from, to->mouse_event.position.point.x = from->x; to->mouse_event.position.point.y = from->y; - return SDL_TRUE; + return true; } -SDL_bool +bool mouse_wheel_from_sdl_to_android(const SDL_MouseWheelEvent *from, struct position position, struct control_event *to) { @@ -223,5 +223,5 @@ mouse_wheel_from_sdl_to_android(const SDL_MouseWheelEvent *from, to->scroll_event.hscroll = -mul * from->x; to->scroll_event.vscroll = mul * from->y; - return SDL_TRUE; + return true; } diff --git a/app/src/convert.h b/app/src/convert.h index edd3e0fa..22cf1023 100644 --- a/app/src/convert.h +++ b/app/src/convert.h @@ -1,8 +1,9 @@ #ifndef CONVERT_H #define CONVERT_H -#include +#include #include + #include "control_event.h" struct complete_mouse_motion_event { @@ -15,24 +16,24 @@ struct complete_mouse_wheel_event { struct point position; }; -SDL_bool +bool input_key_from_sdl_to_android(const SDL_KeyboardEvent *from, struct control_event *to); -SDL_bool +bool mouse_button_from_sdl_to_android(const SDL_MouseButtonEvent *from, struct size screen_size, struct control_event *to); // the video size may be different from the real device size, so we need the // size to which the absolute position apply, to scale it accordingly -SDL_bool +bool mouse_motion_from_sdl_to_android(const SDL_MouseMotionEvent *from, struct size screen_size, struct control_event *to); // on Android, a scroll event requires the current mouse position -SDL_bool +bool mouse_wheel_from_sdl_to_android(const SDL_MouseWheelEvent *from, struct position position, struct control_event *to); diff --git a/app/src/decoder.c b/app/src/decoder.c index 84886c9d..59bd94ce 100644 --- a/app/src/decoder.c +++ b/app/src/decoder.c @@ -20,7 +20,7 @@ // set the decoded frame as ready for rendering, and notify static void push_frame(struct decoder *decoder) { - SDL_bool previous_frame_consumed = + bool previous_frame_consumed = video_buffer_offer_decoded_frame(decoder->video_buffer); if (!previous_frame_consumed) { // the previous EVENT_NEW_FRAME will consume this frame @@ -37,21 +37,21 @@ decoder_init(struct decoder *decoder, struct video_buffer *vb) { decoder->video_buffer = vb; } -SDL_bool +bool decoder_open(struct decoder *decoder, AVCodec *codec) { decoder->codec_ctx = avcodec_alloc_context3(codec); if (!decoder->codec_ctx) { LOGC("Could not allocate decoder context"); - return SDL_FALSE; + return false; } if (avcodec_open2(decoder->codec_ctx, codec, NULL) < 0) { LOGE("Could not open codec"); avcodec_free_context(&decoder->codec_ctx); - return SDL_FALSE; + return false; } - return SDL_TRUE; + return true; } void @@ -60,7 +60,7 @@ decoder_close(struct decoder *decoder) { avcodec_free_context(&decoder->codec_ctx); } -SDL_bool +bool decoder_push(struct decoder *decoder, AVPacket *packet) { // the new decoding/encoding API has been introduced by: // @@ -68,7 +68,7 @@ decoder_push(struct decoder *decoder, AVPacket *packet) { int ret; if ((ret = avcodec_send_packet(decoder->codec_ctx, packet)) < 0) { LOGE("Could not send video packet: %d", ret); - return SDL_FALSE; + return false; } ret = avcodec_receive_frame(decoder->codec_ctx, decoder->video_buffer->decoding_frame); @@ -77,7 +77,7 @@ decoder_push(struct decoder *decoder, AVPacket *packet) { push_frame(decoder); } else if (ret != AVERROR(EAGAIN)) { LOGE("Could not receive video frame: %d", ret); - return SDL_FALSE; + return false; } #else int got_picture; @@ -87,13 +87,13 @@ decoder_push(struct decoder *decoder, AVPacket *packet) { packet); if (len < 0) { LOGE("Could not decode video packet: %d", len); - return SDL_FALSE; + return false; } if (got_picture) { push_frame(decoder); } #endif - return SDL_TRUE; + return true; } void diff --git a/app/src/decoder.h b/app/src/decoder.h index 266876c9..c6349281 100644 --- a/app/src/decoder.h +++ b/app/src/decoder.h @@ -1,8 +1,8 @@ #ifndef DECODER_H #define DECODER_H +#include #include -#include struct video_buffer; @@ -14,13 +14,13 @@ struct decoder { void decoder_init(struct decoder *decoder, struct video_buffer *vb); -SDL_bool +bool decoder_open(struct decoder *decoder, AVCodec *codec); void decoder_close(struct decoder *decoder); -SDL_bool +bool decoder_push(struct decoder *decoder, AVPacket *packet); void diff --git a/app/src/device.c b/app/src/device.c index 9c38bf12..8027ccbb 100644 --- a/app/src/device.c +++ b/app/src/device.c @@ -1,13 +1,13 @@ #include "device.h" #include "log.h" -SDL_bool +bool device_read_info(socket_t device_socket, char *device_name, struct size *size) { unsigned char buf[DEVICE_NAME_FIELD_LENGTH + 4]; int r = net_recv_all(device_socket, buf, sizeof(buf)); if (r < DEVICE_NAME_FIELD_LENGTH + 4) { LOGE("Could not retrieve device information"); - return SDL_FALSE; + return false; } // in case the client sends garbage buf[DEVICE_NAME_FIELD_LENGTH - 1] = '\0'; @@ -18,5 +18,5 @@ device_read_info(socket_t device_socket, char *device_name, struct size *size) { | buf[DEVICE_NAME_FIELD_LENGTH + 1]; size->height = (buf[DEVICE_NAME_FIELD_LENGTH + 2] << 8) | buf[DEVICE_NAME_FIELD_LENGTH + 3]; - return SDL_TRUE; + return true; } diff --git a/app/src/device.h b/app/src/device.h index bacc5355..09934046 100644 --- a/app/src/device.h +++ b/app/src/device.h @@ -1,7 +1,7 @@ #ifndef DEVICE_H #define DEVICE_H -#include +#include #include "common.h" #include "net.h" @@ -10,7 +10,7 @@ #define DEVICE_SDCARD_PATH "/sdcard/" // name must be at least DEVICE_NAME_FIELD_LENGTH bytes -SDL_bool +bool device_read_info(socket_t device_socket, char *name, struct size *frame_size); #endif diff --git a/app/src/file_handler.c b/app/src/file_handler.c index f70f61d3..d3dedcd2 100644 --- a/app/src/file_handler.c +++ b/app/src/file_handler.c @@ -33,21 +33,21 @@ request_free(struct request *req) { SDL_free((void *) req); } -static SDL_bool +static bool request_queue_is_empty(const struct request_queue *queue) { return queue->head == queue->tail; } -static SDL_bool +static bool request_queue_is_full(const struct request_queue *queue) { return (queue->head + 1) % REQUEST_QUEUE_SIZE == queue->tail; } -static SDL_bool +static bool request_queue_init(struct request_queue *queue) { queue->head = 0; queue->tail = 0; - return SDL_TRUE; + return true; } static void @@ -59,41 +59,41 @@ request_queue_destroy(struct request_queue *queue) { } } -static SDL_bool +static bool request_queue_push(struct request_queue *queue, struct request *req) { if (request_queue_is_full(queue)) { - return SDL_FALSE; + return false; } queue->reqs[queue->head] = req; queue->head = (queue->head + 1) % REQUEST_QUEUE_SIZE; - return SDL_TRUE; + return true; } -static SDL_bool +static bool request_queue_take(struct request_queue *queue, struct request **req) { if (request_queue_is_empty(queue)) { - return SDL_FALSE; + return false; } // transfer ownership *req = queue->reqs[queue->tail]; queue->tail = (queue->tail + 1) % REQUEST_QUEUE_SIZE; - return SDL_TRUE; + return true; } -SDL_bool +bool file_handler_init(struct file_handler *file_handler, const char *serial) { if (!request_queue_init(&file_handler->queue)) { - return SDL_FALSE; + return false; } if (!(file_handler->mutex = SDL_CreateMutex())) { - return SDL_FALSE; + return false; } if (!(file_handler->event_cond = SDL_CreateCond())) { SDL_DestroyMutex(file_handler->mutex); - return SDL_FALSE; + return false; } if (serial) { @@ -101,19 +101,19 @@ file_handler_init(struct file_handler *file_handler, const char *serial) { if (!file_handler->serial) { LOGW("Cannot strdup serial"); SDL_DestroyMutex(file_handler->mutex); - return SDL_FALSE; + return false; } } else { file_handler->serial = NULL; } // lazy initialization - file_handler->initialized = SDL_FALSE; + file_handler->initialized = false; - file_handler->stopped = SDL_FALSE; + file_handler->stopped = false; file_handler->current_process = PROCESS_NONE; - return SDL_TRUE; + return true; } void @@ -134,18 +134,18 @@ push_file(const char *serial, const char *file) { return adb_push(serial, file, DEVICE_SDCARD_PATH); } -SDL_bool +bool file_handler_request(struct file_handler *file_handler, file_handler_action_t action, const char *file) { - SDL_bool res; + bool res; // start file_handler if it's used for the first time if (!file_handler->initialized) { if (!file_handler_start(file_handler)) { - return SDL_FALSE; + return false; } - file_handler->initialized = SDL_TRUE; + file_handler->initialized = true; } LOGI("Request to %s %s", action == ACTION_INSTALL_APK ? "install" : "push", @@ -153,11 +153,11 @@ file_handler_request(struct file_handler *file_handler, struct request *req = request_new(action, file); if (!req) { LOGE("Could not create request"); - return SDL_FALSE; + return false; } mutex_lock(file_handler->mutex); - SDL_bool was_empty = request_queue_is_empty(&file_handler->queue); + bool was_empty = request_queue_is_empty(&file_handler->queue); res = request_queue_push(&file_handler->queue, req); if (was_empty) { cond_signal(file_handler->event_cond); @@ -183,7 +183,7 @@ run_file_handler(void *data) { break; } struct request *req; - SDL_bool non_empty = request_queue_take(&file_handler->queue, &req); + bool non_empty = request_queue_take(&file_handler->queue, &req); SDL_assert(non_empty); process_t process; @@ -216,7 +216,7 @@ run_file_handler(void *data) { return 0; } -SDL_bool +bool file_handler_start(struct file_handler *file_handler) { LOGD("Starting file_handler thread"); @@ -224,16 +224,16 @@ file_handler_start(struct file_handler *file_handler) { file_handler); if (!file_handler->thread) { LOGC("Could not start file_handler thread"); - return SDL_FALSE; + return false; } - return SDL_TRUE; + return true; } void file_handler_stop(struct file_handler *file_handler) { mutex_lock(file_handler->mutex); - file_handler->stopped = SDL_TRUE; + file_handler->stopped = true; cond_signal(file_handler->event_cond); if (file_handler->current_process != PROCESS_NONE) { if (!cmd_terminate(file_handler->current_process)) { diff --git a/app/src/file_handler.h b/app/src/file_handler.h index ed1c8867..111161dc 100644 --- a/app/src/file_handler.h +++ b/app/src/file_handler.h @@ -1,9 +1,10 @@ #ifndef FILE_HANDLER_H #define FILE_HANDLER_H +#include #include -#include #include + #include "command.h" #define REQUEST_QUEUE_SIZE 16 @@ -24,19 +25,19 @@ struct file_handler { SDL_Thread *thread; SDL_mutex *mutex; SDL_cond *event_cond; - SDL_bool stopped; - SDL_bool initialized; + bool stopped; + bool initialized; process_t current_process; struct request_queue queue; }; -SDL_bool +bool file_handler_init(struct file_handler *file_handler, const char *serial); void file_handler_destroy(struct file_handler *file_handler); -SDL_bool +bool file_handler_start(struct file_handler *file_handler); void @@ -45,7 +46,7 @@ file_handler_stop(struct file_handler *file_handler); void file_handler_join(struct file_handler *file_handler); -SDL_bool +bool file_handler_request(struct file_handler *file_handler, file_handler_action_t action, const char *file); diff --git a/app/src/fps_counter.c b/app/src/fps_counter.c index fc86f22c..6c8ef795 100644 --- a/app/src/fps_counter.c +++ b/app/src/fps_counter.c @@ -6,14 +6,14 @@ void fps_counter_init(struct fps_counter *counter) { - counter->started = SDL_FALSE; + counter->started = false; // no need to initialize the other fields, they are meaningful only when // started is true } void fps_counter_start(struct fps_counter *counter) { - counter->started = SDL_TRUE; + counter->started = true; counter->slice_start = SDL_GetTicks(); counter->nr_rendered = 0; #ifdef SKIP_FRAMES @@ -23,7 +23,7 @@ fps_counter_start(struct fps_counter *counter) { void fps_counter_stop(struct fps_counter *counter) { - counter->started = SDL_FALSE; + counter->started = false; } static void @@ -42,11 +42,11 @@ display_fps(struct fps_counter *counter) { static void check_expired(struct fps_counter *counter) { - Uint32 now = SDL_GetTicks(); + uint32_t now = SDL_GetTicks(); if (now - counter->slice_start >= 1000) { display_fps(counter); // add a multiple of one second - Uint32 elapsed_slices = (now - counter->slice_start) / 1000; + uint32_t elapsed_slices = (now - counter->slice_start) / 1000; counter->slice_start += 1000 * elapsed_slices; counter->nr_rendered = 0; #ifdef SKIP_FRAMES diff --git a/app/src/fps_counter.h b/app/src/fps_counter.h index 2d48624f..dcdf10bf 100644 --- a/app/src/fps_counter.h +++ b/app/src/fps_counter.h @@ -1,13 +1,14 @@ #ifndef FPSCOUNTER_H #define FPSCOUNTER_H -#include +#include +#include #include "config.h" struct fps_counter { - SDL_bool started; - Uint32 slice_start; // initialized by SDL_GetTicks() + bool started; + uint32_t slice_start; // initialized by SDL_GetTicks() int nr_rendered; #ifdef SKIP_FRAMES int nr_skipped; diff --git a/app/src/input_manager.c b/app/src/input_manager.c index 33b5b0d3..eb4047e9 100644 --- a/app/src/input_manager.c +++ b/app/src/input_manager.c @@ -192,9 +192,9 @@ input_manager_process_text_input(struct input_manager *input_manager, void input_manager_process_key(struct input_manager *input_manager, const SDL_KeyboardEvent *event) { - SDL_bool ctrl = event->keysym.mod & (KMOD_LCTRL | KMOD_RCTRL); - SDL_bool alt = event->keysym.mod & (KMOD_LALT | KMOD_RALT); - SDL_bool meta = event->keysym.mod & (KMOD_LGUI | KMOD_RGUI); + bool ctrl = event->keysym.mod & (KMOD_LCTRL | KMOD_RCTRL); + bool alt = event->keysym.mod & (KMOD_LALT | KMOD_RALT); + bool meta = event->keysym.mod & (KMOD_LGUI | KMOD_RGUI); if (alt) { // no shortcut involves Alt or Meta, and they should not be forwarded @@ -203,14 +203,14 @@ input_manager_process_key(struct input_manager *input_manager, } // false if the user requested not to interact with the device - SDL_bool control = input_manager->control; + bool control = input_manager->control; // capture all Ctrl events if (ctrl | meta) { SDL_Keycode keycode = event->keysym.sym; int action = event->type == SDL_KEYDOWN ? ACTION_DOWN : ACTION_UP; - SDL_bool repeat = event->repeat; - SDL_bool shift = event->keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT); + bool repeat = event->repeat; + bool shift = event->keysym.mod & (KMOD_LSHIFT | KMOD_RSHIFT); switch (keycode) { case SDLK_h: if (control && ctrl && !meta && !shift && !repeat) { @@ -332,7 +332,7 @@ input_manager_process_mouse_motion(struct input_manager *input_manager, } } -static SDL_bool +static bool is_outside_device_screen(struct input_manager *input_manager, int x, int y) { return x < 0 || x >= input_manager->screen->frame_size.width || @@ -343,7 +343,7 @@ void input_manager_process_mouse_button(struct input_manager *input_manager, const SDL_MouseButtonEvent *event) { // false if the user requested not to interact with the device - SDL_bool control = input_manager->control; + bool control = input_manager->control; if (event->type == SDL_MOUSEBUTTONDOWN) { if (control && event->button == SDL_BUTTON_RIGHT) { @@ -356,7 +356,7 @@ input_manager_process_mouse_button(struct input_manager *input_manager, } // double-click on black borders resize to fit the device screen if (event->button == SDL_BUTTON_LEFT && event->clicks == 2) { - SDL_bool outside = is_outside_device_screen(input_manager, + bool outside = is_outside_device_screen(input_manager, event->x, event->y); if (outside) { diff --git a/app/src/input_manager.h b/app/src/input_manager.h index 28a9a879..c30a8188 100644 --- a/app/src/input_manager.h +++ b/app/src/input_manager.h @@ -1,6 +1,8 @@ #ifndef INPUTMANAGER_H #define INPUTMANAGER_H +#include + #include "common.h" #include "controller.h" #include "fps_counter.h" @@ -11,7 +13,7 @@ struct input_manager { struct controller *controller; struct video_buffer *video_buffer; struct screen *screen; - SDL_bool control; + bool control; }; void diff --git a/app/src/main.c b/app/src/main.c index a4d705ce..b2a6bf5e 100644 --- a/app/src/main.c +++ b/app/src/main.c @@ -1,6 +1,8 @@ #include "scrcpy.h" #include +#include +#include #include #include #include @@ -15,16 +17,16 @@ struct args { const char *crop; const char *record_filename; enum recorder_format record_format; - SDL_bool fullscreen; - SDL_bool no_control; - SDL_bool no_display; - SDL_bool help; - SDL_bool version; - SDL_bool show_touches; - Uint16 port; - Uint16 max_size; - Uint32 bit_rate; - SDL_bool always_on_top; + bool fullscreen; + bool no_control; + bool no_display; + bool help; + bool version; + bool show_touches; + uint16_t port; + uint16_t max_size; + uint32_t bit_rate; + bool always_on_top; }; static void usage(const char *arg0) { @@ -168,19 +170,19 @@ print_version(void) { LIBAVUTIL_VERSION_MICRO); } -static SDL_bool -parse_bit_rate(char *optarg, Uint32 *bit_rate) { +static bool +parse_bit_rate(char *optarg, uint32_t *bit_rate) { char *endptr; if (*optarg == '\0') { LOGE("Bit-rate parameter is empty"); - return SDL_FALSE; + return false; } long value = strtol(optarg, &endptr, 0); int mul = 1; if (*endptr != '\0') { if (optarg == endptr) { LOGE("Invalid bit-rate: %s", optarg); - return SDL_FALSE; + return false; } if ((*endptr == 'M' || *endptr == 'm') && endptr[1] == '\0') { mul = 1000000; @@ -188,72 +190,72 @@ parse_bit_rate(char *optarg, Uint32 *bit_rate) { mul = 1000; } else { LOGE("Invalid bit-rate unit: %s", optarg); - return SDL_FALSE; + return false; } } - if (value < 0 || ((Uint32) -1) / mul < value) { + if (value < 0 || ((uint32_t) -1) / mul < value) { LOGE("Bitrate must be positive and less than 2^32: %s", optarg); - return SDL_FALSE; + return false; } - *bit_rate = (Uint32) value * mul; - return SDL_TRUE; + *bit_rate = (uint32_t) value * mul; + return true; } -static SDL_bool -parse_max_size(char *optarg, Uint16 *max_size) { +static bool +parse_max_size(char *optarg, uint16_t *max_size) { char *endptr; if (*optarg == '\0') { LOGE("Max size parameter is empty"); - return SDL_FALSE; + return false; } long value = strtol(optarg, &endptr, 0); if (*endptr != '\0') { LOGE("Invalid max size: %s", optarg); - return SDL_FALSE; + return false; } if (value & ~0xffff) { LOGE("Max size must be between 0 and 65535: %ld", value); - return SDL_FALSE; + return false; } - *max_size = (Uint16) value; - return SDL_TRUE; + *max_size = (uint16_t) value; + return true; } -static SDL_bool -parse_port(char *optarg, Uint16 *port) { +static bool +parse_port(char *optarg, uint16_t *port) { char *endptr; if (*optarg == '\0') { LOGE("Invalid port parameter is empty"); - return SDL_FALSE; + return false; } long value = strtol(optarg, &endptr, 0); if (*endptr != '\0') { LOGE("Invalid port: %s", optarg); - return SDL_FALSE; + return false; } if (value & ~0xffff) { LOGE("Port out of range: %ld", value); - return SDL_FALSE; + return false; } - *port = (Uint16) value; - return SDL_TRUE; + *port = (uint16_t) value; + return true; } -static SDL_bool +static bool parse_record_format(const char *optarg, enum recorder_format *format) { if (!strcmp(optarg, "mp4")) { *format = RECORDER_FORMAT_MP4; - return SDL_TRUE; + return true; } if (!strcmp(optarg, "mkv")) { *format = RECORDER_FORMAT_MKV; - return SDL_TRUE; + return true; } LOGE("Unsupported format: %s (expected mp4 or mkv)", optarg); - return SDL_FALSE; + return false; } static enum recorder_format @@ -272,7 +274,7 @@ guess_record_format(const char *filename) { return 0; } -static SDL_bool +static bool parse_args(struct args *args, int argc, char *argv[]) { static const struct option long_options[] = { {"always-on-top", no_argument, NULL, 'T'}, @@ -297,37 +299,37 @@ parse_args(struct args *args, int argc, char *argv[]) { switch (c) { case 'b': if (!parse_bit_rate(optarg, &args->bit_rate)) { - return SDL_FALSE; + return false; } break; case 'c': args->crop = optarg; break; case 'f': - args->fullscreen = SDL_TRUE; + args->fullscreen = true; break; case 'F': if (!parse_record_format(optarg, &args->record_format)) { - return SDL_FALSE; + return false; } break; case 'h': - args->help = SDL_TRUE; + args->help = true; break; case 'm': if (!parse_max_size(optarg, &args->max_size)) { - return SDL_FALSE; + return false; } break; case 'n': - args->no_control = SDL_TRUE; + args->no_control = true; break; case 'N': - args->no_display = SDL_TRUE; + args->no_display = true; break; case 'p': if (!parse_port(optarg, &args->port)) { - return SDL_FALSE; + return false; } break; case 'r': @@ -337,39 +339,39 @@ parse_args(struct args *args, int argc, char *argv[]) { args->serial = optarg; break; case 't': - args->show_touches = SDL_TRUE; + args->show_touches = true; break; case 'T': - args->always_on_top = SDL_TRUE; + args->always_on_top = true; break; case 'v': - args->version = SDL_TRUE; + args->version = true; break; default: // getopt prints the error message on stderr - return SDL_FALSE; + return false; } } if (args->no_display && !args->record_filename) { LOGE("-N/--no-display requires screen recording (-r/--record)"); - return SDL_FALSE; + return false; } if (args->no_display && args->fullscreen) { LOGE("-f/--fullscreen-window is incompatible with -N/--no-display"); - return SDL_FALSE; + return false; } int index = optind; if (index < argc) { LOGE("Unexpected additional argument: %s", argv[index]); - return SDL_FALSE; + return false; } if (args->record_format && !args->record_filename) { LOGE("Record format specified without recording"); - return SDL_FALSE; + return false; } if (args->record_filename && !args->record_format) { @@ -377,11 +379,11 @@ parse_args(struct args *args, int argc, char *argv[]) { if (!args->record_format) { LOGE("No format specified for \"%s\" (try with -F mkv)", args->record_filename); - return SDL_FALSE; + return false; } } - return SDL_TRUE; + return true; } int @@ -397,15 +399,15 @@ main(int argc, char *argv[]) { .crop = NULL, .record_filename = NULL, .record_format = 0, - .help = SDL_FALSE, - .version = SDL_FALSE, - .show_touches = SDL_FALSE, + .help = false, + .version = false, + .show_touches = false, .port = DEFAULT_LOCAL_PORT, .max_size = DEFAULT_MAX_SIZE, .bit_rate = DEFAULT_BIT_RATE, - .always_on_top = SDL_FALSE, - .no_control = SDL_FALSE, - .no_display = SDL_FALSE, + .always_on_top = false, + .no_control = false, + .no_display = false, }; if (!parse_args(&args, argc, argv)) { return 1; diff --git a/app/src/net.c b/app/src/net.c index 70fcb304..b5b227c2 100644 --- a/app/src/net.c +++ b/app/src/net.c @@ -19,7 +19,7 @@ #endif socket_t -net_connect(Uint32 addr, Uint16 port) { +net_connect(uint32_t addr, uint16_t port) { socket_t sock = socket(AF_INET, SOCK_STREAM, 0); if (sock == INVALID_SOCKET) { perror("socket"); @@ -40,7 +40,7 @@ net_connect(Uint32 addr, Uint16 port) { } socket_t -net_listen(Uint32 addr, Uint16 port, int backlog) { +net_listen(uint32_t addr, uint16_t port, int backlog) { socket_t sock = socket(AF_INET, SOCK_STREAM, 0); if (sock == INVALID_SOCKET) { perror("socket"); @@ -107,7 +107,7 @@ net_send_all(socket_t socket, const void *buf, size_t len) { return w; } -SDL_bool +bool net_shutdown(socket_t socket, int how) { return !shutdown(socket, how); } diff --git a/app/src/net.h b/app/src/net.h index d712e6d3..dd82c083 100644 --- a/app/src/net.h +++ b/app/src/net.h @@ -1,8 +1,9 @@ #ifndef NET_H #define NET_H +#include +#include #include -#include #ifdef __WINDOWS__ # include @@ -16,17 +17,17 @@ typedef int socket_t; #endif -SDL_bool +bool net_init(void); void net_cleanup(void); socket_t -net_connect(Uint32 addr, Uint16 port); +net_connect(uint32_t addr, uint16_t port); socket_t -net_listen(Uint32 addr, Uint16 port, int backlog); +net_listen(uint32_t addr, uint16_t port, int backlog); socket_t net_accept(socket_t server_socket); @@ -45,10 +46,10 @@ ssize_t net_send_all(socket_t socket, const void *buf, size_t len); // how is SHUT_RD (read), SHUT_WR (write) or SHUT_RDWR (both) -SDL_bool +bool net_shutdown(socket_t socket, int how); -SDL_bool +bool net_close(socket_t socket); #endif diff --git a/app/src/recorder.c b/app/src/recorder.c index db9d8a7a..2f33702d 100644 --- a/app/src/recorder.c +++ b/app/src/recorder.c @@ -26,7 +26,7 @@ find_muxer(const char *name) { return oformat; } -SDL_bool +bool recorder_init(struct recorder *recorder, const char *filename, enum recorder_format format, @@ -34,14 +34,14 @@ recorder_init(struct recorder *recorder, recorder->filename = SDL_strdup(filename); if (!recorder->filename) { LOGE("Cannot strdup filename"); - return SDL_FALSE; + return false; } recorder->format = format; recorder->declared_frame_size = declared_frame_size; - recorder->header_written = SDL_FALSE; + recorder->header_written = false; - return SDL_TRUE; + return true; } void @@ -58,20 +58,20 @@ recorder_get_format_name(enum recorder_format format) { } } -SDL_bool +bool recorder_open(struct recorder *recorder, AVCodec *input_codec) { const char *format_name = recorder_get_format_name(recorder->format); SDL_assert(format_name); const AVOutputFormat *format = find_muxer(format_name); if (!format) { LOGE("Could not find muxer"); - return SDL_FALSE; + return false; } recorder->ctx = avformat_alloc_context(); if (!recorder->ctx) { LOGE("Could not allocate output context"); - return SDL_FALSE; + return false; } // contrary to the deprecated API (av_oformat_next()), av_muxer_iterate() @@ -83,7 +83,7 @@ recorder_open(struct recorder *recorder, AVCodec *input_codec) { AVStream *ostream = avformat_new_stream(recorder->ctx, input_codec); if (!ostream) { avformat_free_context(recorder->ctx); - return SDL_FALSE; + return false; } #ifdef SCRCPY_LAVF_HAS_NEW_CODEC_PARAMS_API @@ -106,12 +106,12 @@ recorder_open(struct recorder *recorder, AVCodec *input_codec) { LOGE("Failed to open output file: %s", recorder->filename); // ostream will be cleaned up during context cleaning avformat_free_context(recorder->ctx); - return SDL_FALSE; + return false; } LOGI("Recording started to %s file: %s", format_name, recorder->filename); - return SDL_TRUE; + return true; } void @@ -127,14 +127,14 @@ recorder_close(struct recorder *recorder) { LOGI("Recording complete to %s file: %s", format_name, recorder->filename); } -static SDL_bool +static bool recorder_write_header(struct recorder *recorder, AVPacket *packet) { AVStream *ostream = recorder->ctx->streams[0]; uint8_t *extradata = av_malloc(packet->size * sizeof(uint8_t)); if (!extradata) { LOGC("Cannot allocate extradata"); - return SDL_FALSE; + return false; } // copy the first packet to the extra data @@ -154,10 +154,10 @@ recorder_write_header(struct recorder *recorder, AVPacket *packet) { SDL_free(extradata); avio_closep(&recorder->ctx->pb); avformat_free_context(recorder->ctx); - return SDL_FALSE; + return false; } - return SDL_TRUE; + return true; } static void @@ -166,14 +166,14 @@ recorder_rescale_packet(struct recorder *recorder, AVPacket *packet) { av_packet_rescale_ts(packet, SCRCPY_TIME_BASE, ostream->time_base); } -SDL_bool +bool recorder_write(struct recorder *recorder, AVPacket *packet) { if (!recorder->header_written) { - SDL_bool ok = recorder_write_header(recorder, packet); + bool ok = recorder_write_header(recorder, packet); if (!ok) { - return SDL_FALSE; + return false; } - recorder->header_written = SDL_TRUE; + recorder->header_written = true; } recorder_rescale_packet(recorder, packet); diff --git a/app/src/recorder.h b/app/src/recorder.h index 5ead6f3f..c126b29b 100644 --- a/app/src/recorder.h +++ b/app/src/recorder.h @@ -1,8 +1,8 @@ #ifndef RECORDER_H #define RECORDER_H +#include #include -#include #include "common.h" @@ -16,23 +16,23 @@ struct recorder { enum recorder_format format; AVFormatContext *ctx; struct size declared_frame_size; - SDL_bool header_written; + bool header_written; }; -SDL_bool +bool recorder_init(struct recorder *recoder, const char *filename, enum recorder_format format, struct size declared_frame_size); void recorder_destroy(struct recorder *recorder); -SDL_bool +bool recorder_open(struct recorder *recorder, AVCodec *input_codec); void recorder_close(struct recorder *recorder); -SDL_bool +bool recorder_write(struct recorder *recorder, AVPacket *packet); #endif diff --git a/app/src/scrcpy.c b/app/src/scrcpy.c index 15ffdd32..26bde219 100644 --- a/app/src/scrcpy.c +++ b/app/src/scrcpy.c @@ -39,7 +39,7 @@ static struct input_manager input_manager = { .controller = &controller, .video_buffer = &video_buffer, .screen = &screen, - .control = SDL_TRUE, + .control = true, }; #if defined(__APPLE__) || defined(__WINDOWS__) @@ -63,7 +63,7 @@ event_watcher(void *data, SDL_Event *event) { } #endif -static SDL_bool +static bool is_apk(const char *file) { const char *ext = strrchr(file, '.'); return ext && !strcmp(ext, ".apk"); @@ -76,7 +76,7 @@ enum event_result { }; static enum event_result -handle_event(SDL_Event *event, SDL_bool control) { +handle_event(SDL_Event *event, bool control) { switch (event->type) { case EVENT_STREAM_STOPPED: LOGD("Video stream stopped"); @@ -86,12 +86,12 @@ handle_event(SDL_Event *event, SDL_bool control) { return EVENT_RESULT_STOPPED_BY_USER; case EVENT_NEW_FRAME: if (!screen.has_frame) { - screen.has_frame = SDL_TRUE; + screen.has_frame = true; // this is the very first frame, show the window screen_show_window(&screen); } if (!screen_update_frame(&screen, &video_buffer)) { - return SDL_FALSE; + return false; } break; case SDL_WINDOWEVENT: @@ -149,8 +149,8 @@ handle_event(SDL_Event *event, SDL_bool control) { return EVENT_RESULT_CONTINUE; } -static SDL_bool -event_loop(SDL_bool display, SDL_bool control) { +static bool +event_loop(bool display, bool control) { #ifdef CONTINUOUS_RESIZING_WORKAROUND if (display) { SDL_AddEventWatch(event_watcher, NULL); @@ -161,18 +161,18 @@ event_loop(SDL_bool display, SDL_bool control) { enum event_result result = handle_event(&event, control); switch (result) { case EVENT_RESULT_STOPPED_BY_USER: - return SDL_TRUE; + return true; case EVENT_RESULT_STOPPED_BY_EOS: - return SDL_FALSE; + return false; case EVENT_RESULT_CONTINUE: break; } } - return SDL_FALSE; + return false; } static process_t -set_show_touches_enabled(const char *serial, SDL_bool enabled) { +set_show_touches_enabled(const char *serial, bool enabled) { const char *value = enabled ? "1" : "0"; const char *const adb_cmd[] = { "shell", "settings", "put", "system", "show_touches", value @@ -221,34 +221,34 @@ av_log_callback(void *avcl, int level, const char *fmt, va_list vl) { SDL_free(local_fmt); } -SDL_bool +bool scrcpy(const struct scrcpy_options *options) { - SDL_bool record = !!options->record_filename; + bool record = !!options->record_filename; if (!server_start(&server, options->serial, options->port, options->max_size, options->bit_rate, options->crop, record)) { - return SDL_FALSE; + return false; } process_t proc_show_touches = PROCESS_NONE; - SDL_bool show_touches_waited; + bool show_touches_waited; if (options->show_touches) { LOGI("Enable show_touches"); - proc_show_touches = set_show_touches_enabled(options->serial, SDL_TRUE); - show_touches_waited = SDL_FALSE; + proc_show_touches = set_show_touches_enabled(options->serial, true); + show_touches_waited = false; } - SDL_bool ret = SDL_TRUE; + bool ret = true; if (!sdl_init_and_configure()) { - ret = SDL_FALSE; + ret = false; goto finally_destroy_server; } socket_t device_socket = server_connect_to(&server); if (device_socket == INVALID_SOCKET) { server_stop(&server); - ret = SDL_FALSE; + ret = false; goto finally_destroy_server; } @@ -260,12 +260,12 @@ scrcpy(const struct scrcpy_options *options) { // to be able to init the window immediately if (!device_read_info(device_socket, device_name, &frame_size)) { server_stop(&server); - ret = SDL_FALSE; + ret = false; goto finally_destroy_server; } - SDL_bool display = !options->no_display; - SDL_bool control = !options->no_control; + bool display = !options->no_display; + bool control = !options->no_control; input_manager.control = control; @@ -273,12 +273,12 @@ scrcpy(const struct scrcpy_options *options) { if (display) { if (!video_buffer_init(&video_buffer)) { server_stop(&server); - ret = SDL_FALSE; + ret = false; goto finally_destroy_server; } if (control && !file_handler_init(&file_handler, server.serial)) { - ret = SDL_FALSE; + ret = false; server_stop(&server); goto finally_destroy_video_buffer; } @@ -293,7 +293,7 @@ scrcpy(const struct scrcpy_options *options) { options->record_filename, options->record_format, frame_size)) { - ret = SDL_FALSE; + ret = false; server_stop(&server); goto finally_destroy_file_handler; } @@ -307,7 +307,7 @@ scrcpy(const struct scrcpy_options *options) { // now we consumed the header values, the socket receives the video stream // start the stream if (!stream_start(&stream)) { - ret = SDL_FALSE; + ret = false; server_stop(&server); goto finally_destroy_recorder; } @@ -315,19 +315,19 @@ scrcpy(const struct scrcpy_options *options) { if (display) { if (control) { if (!controller_init(&controller, device_socket)) { - ret = SDL_FALSE; + ret = false; goto finally_stop_stream; } if (!controller_start(&controller)) { - ret = SDL_FALSE; + ret = false; goto finally_destroy_controller; } } if (!screen_init_rendering(&screen, device_name, frame_size, options->always_on_top)) { - ret = SDL_FALSE; + ret = false; goto finally_stop_and_join_controller; } @@ -338,7 +338,7 @@ scrcpy(const struct scrcpy_options *options) { if (options->show_touches) { wait_show_touches(proc_show_touches); - show_touches_waited = SDL_TRUE; + show_touches_waited = true; } ret = event_loop(display, control); @@ -382,7 +382,7 @@ finally_destroy_server: } LOGI("Disable show_touches"); proc_show_touches = set_show_touches_enabled(options->serial, - SDL_FALSE); + false); wait_show_touches(proc_show_touches); } diff --git a/app/src/scrcpy.h b/app/src/scrcpy.h index f5b6be26..114c12a4 100644 --- a/app/src/scrcpy.h +++ b/app/src/scrcpy.h @@ -1,7 +1,8 @@ #ifndef SCRCPY_H #define SCRCPY_H -#include +#include +#include #include struct scrcpy_options { @@ -9,17 +10,17 @@ struct scrcpy_options { const char *crop; const char *record_filename; enum recorder_format record_format; - Uint16 port; - Uint16 max_size; - Uint32 bit_rate; - SDL_bool show_touches; - SDL_bool fullscreen; - SDL_bool always_on_top; - SDL_bool no_control; - SDL_bool no_display; + uint16_t port; + uint16_t max_size; + uint32_t bit_rate; + bool show_touches; + bool fullscreen; + bool always_on_top; + bool no_control; + bool no_display; }; -SDL_bool +bool scrcpy(const struct scrcpy_options *options); #endif diff --git a/app/src/screen.c b/app/src/screen.c index 5da96b93..962d5b70 100644 --- a/app/src/screen.c +++ b/app/src/screen.c @@ -1,8 +1,9 @@ #include "screen.h" -#include #include +#include +#include "common.h" #include "compat.h" #include "icon.xpm" #include "lock_util.h" @@ -12,11 +13,11 @@ #define DISPLAY_MARGINS 96 -SDL_bool +bool sdl_init_and_configure(void) { if (SDL_Init(SDL_INIT_VIDEO)) { LOGC("Could not initialize SDL: %s", SDL_GetError()); - return SDL_FALSE; + return false; } atexit(SDL_Quit); @@ -36,7 +37,7 @@ sdl_init_and_configure(void) { // Do not disable the screensaver when scrcpy is running SDL_EnableScreenSaver(); - return SDL_TRUE; + return true; } // get the window size in a struct size @@ -75,7 +76,7 @@ set_window_size(struct screen *screen, struct size new_size) { } // get the preferred display bounds (i.e. the screen bounds with some margins) -static SDL_bool +static bool get_preferred_display_bounds(struct size *bounds) { SDL_Rect rect; #ifdef SCRCPY_SDL_HAS_GET_DISPLAY_USABLE_BOUNDS @@ -85,12 +86,12 @@ get_preferred_display_bounds(struct size *bounds) { #endif if (GET_DISPLAY_BOUNDS(0, &rect)) { LOGW("Could not get display usable bounds: %s", SDL_GetError()); - return SDL_FALSE; + return false; } bounds->width = MAX(0, rect.w - DISPLAY_MARGINS); bounds->height = MAX(0, rect.h - DISPLAY_MARGINS); - return SDL_TRUE; + return true; } // return the optimal size of the window, with the following constraints: @@ -107,8 +108,8 @@ get_optimal_size(struct size current_size, struct size frame_size) { struct size display_size; // 32 bits because we need to multiply two 16 bits values - Uint32 w; - Uint32 h; + uint32_t w; + uint32_t h; if (!get_preferred_display_bounds(&display_size)) { // cannot get display bounds, do not constraint the size @@ -119,7 +120,7 @@ get_optimal_size(struct size current_size, struct size frame_size) { h = MIN(current_size.height, display_size.height); } - SDL_bool keep_width = frame_size.width * h > frame_size.height * w; + bool keep_width = frame_size.width * h > frame_size.height * w; if (keep_width) { // remove black borders on top and bottom h = frame_size.height * w / frame_size.width; @@ -159,13 +160,13 @@ create_texture(SDL_Renderer *renderer, struct size frame_size) { frame_size.width, frame_size.height); } -SDL_bool +bool screen_init_rendering(struct screen *screen, const char *device_name, - struct size frame_size, SDL_bool always_on_top) { + struct size frame_size, bool always_on_top) { screen->frame_size = frame_size; struct size window_size = get_initial_optimal_size(frame_size); - Uint32 window_flags = SDL_WINDOW_HIDDEN | SDL_WINDOW_RESIZABLE; + uint32_t window_flags = SDL_WINDOW_HIDDEN | SDL_WINDOW_RESIZABLE; #ifdef HIDPI_SUPPORT window_flags |= SDL_WINDOW_ALLOW_HIGHDPI; #endif @@ -184,7 +185,7 @@ screen_init_rendering(struct screen *screen, const char *device_name, window_flags); if (!screen->window) { LOGC("Could not create window: %s", SDL_GetError()); - return SDL_FALSE; + return false; } screen->renderer = SDL_CreateRenderer(screen->window, -1, @@ -192,21 +193,21 @@ screen_init_rendering(struct screen *screen, const char *device_name, if (!screen->renderer) { LOGC("Could not create renderer: %s", SDL_GetError()); screen_destroy(screen); - return SDL_FALSE; + return false; } if (SDL_RenderSetLogicalSize(screen->renderer, frame_size.width, frame_size.height)) { LOGE("Could not set renderer logical size: %s", SDL_GetError()); screen_destroy(screen); - return SDL_FALSE; + return false; } SDL_Surface *icon = read_xpm(icon_xpm); if (!icon) { LOGE("Could not load icon: %s", SDL_GetError()); screen_destroy(screen); - return SDL_FALSE; + return false; } SDL_SetWindowIcon(screen->window, icon); SDL_FreeSurface(icon); @@ -217,10 +218,10 @@ screen_init_rendering(struct screen *screen, const char *device_name, if (!screen->texture) { LOGC("Could not create texture: %s", SDL_GetError()); screen_destroy(screen); - return SDL_FALSE; + return false; } - return SDL_TRUE; + return true; } void @@ -242,14 +243,14 @@ screen_destroy(struct screen *screen) { } // recreate the texture and resize the window if the frame size has changed -static SDL_bool +static 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)) { LOGE("Could not set renderer logical size: %s", SDL_GetError()); - return SDL_FALSE; + return false; } // frame dimension changed, destroy texture @@ -257,9 +258,9 @@ prepare_for_frame(struct screen *screen, struct size new_frame_size) { struct size current_size = get_window_size(screen); struct size target_size = { - (Uint32) current_size.width * new_frame_size.width + (uint32_t) current_size.width * new_frame_size.width / screen->frame_size.width, - (Uint32) current_size.height * new_frame_size.height + (uint32_t) current_size.height * new_frame_size.height / screen->frame_size.height, }; target_size = get_optimal_size(target_size, new_frame_size); @@ -272,11 +273,11 @@ prepare_for_frame(struct screen *screen, struct size new_frame_size) { screen->texture = create_texture(screen->renderer, new_frame_size); if (!screen->texture) { LOGC("Could not create texture: %s", SDL_GetError()); - return SDL_FALSE; + return false; } } - return SDL_TRUE; + return true; } // write the frame into the texture @@ -288,20 +289,20 @@ update_texture(struct screen *screen, const AVFrame *frame) { frame->data[2], frame->linesize[2]); } -SDL_bool +bool screen_update_frame(struct screen *screen, struct video_buffer *vb) { mutex_lock(vb->mutex); const AVFrame *frame = video_buffer_consume_rendered_frame(vb); struct size new_frame_size = {frame->width, frame->height}; if (!prepare_for_frame(screen, new_frame_size)) { mutex_unlock(vb->mutex); - return SDL_FALSE; + return false; } update_texture(screen, frame); mutex_unlock(vb->mutex); screen_render(screen); - return SDL_TRUE; + return true; } void @@ -317,7 +318,7 @@ screen_switch_fullscreen(struct screen *screen) { // going to fullscreen, store the current windowed window size screen->windowed_window_size = get_native_window_size(screen->window); } - Uint32 new_mode = screen->fullscreen ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP; + uint32_t new_mode = screen->fullscreen ? 0 : SDL_WINDOW_FULLSCREEN_DESKTOP; if (SDL_SetWindowFullscreen(screen->window, new_mode)) { LOGW("Could not switch fullscreen mode: %s", SDL_GetError()); return; diff --git a/app/src/screen.h b/app/src/screen.h index 51f9396d..b3e3ecaa 100644 --- a/app/src/screen.h +++ b/app/src/screen.h @@ -1,6 +1,7 @@ #ifndef SCREEN_H #define SCREEN_H +#include #include #include @@ -15,9 +16,9 @@ struct screen { struct size frame_size; //used only in fullscreen mode to know the windowed window size struct size windowed_window_size; - SDL_bool has_frame; - SDL_bool fullscreen; - SDL_bool no_window; + bool has_frame; + bool fullscreen; + bool no_window; }; #define SCREEN_INITIALIZER { \ @@ -32,13 +33,13 @@ struct screen { .width = 0, \ .height = 0, \ }, \ - .has_frame = SDL_FALSE, \ - .fullscreen = SDL_FALSE, \ - .no_window = SDL_FALSE, \ + .has_frame = false, \ + .fullscreen = false, \ + .no_window = false, \ } // init SDL and set appropriate hints -SDL_bool +bool sdl_init_and_configure(void); // initialize default values @@ -46,9 +47,9 @@ void screen_init(struct screen *screen); // initialize screen, create window, renderer and texture (window is hidden) -SDL_bool +bool screen_init_rendering(struct screen *screen, const char *device_name, - struct size frame_size, SDL_bool always_on_top); + struct size frame_size, bool always_on_top); // show the window void @@ -59,7 +60,7 @@ void screen_destroy(struct screen *screen); // resize if necessary and write the rendered frame into the texture -SDL_bool +bool screen_update_frame(struct screen *screen, struct video_buffer *vb); // render the texture to the renderer diff --git a/app/src/server.c b/app/src/server.c index 1dce347f..6f23d8af 100644 --- a/app/src/server.c +++ b/app/src/server.c @@ -2,7 +2,6 @@ #include #include -#include #include #include #include @@ -30,48 +29,48 @@ get_server_path(void) { return server_path; } -static SDL_bool +static bool push_server(const char *serial) { process_t process = adb_push(serial, get_server_path(), DEVICE_SERVER_PATH); return process_check_success(process, "adb push"); } -static SDL_bool -enable_tunnel_reverse(const char *serial, Uint16 local_port) { +static bool +enable_tunnel_reverse(const char *serial, uint16_t local_port) { process_t process = adb_reverse(serial, SOCKET_NAME, local_port); return process_check_success(process, "adb reverse"); } -static SDL_bool +static bool disable_tunnel_reverse(const char *serial) { process_t process = adb_reverse_remove(serial, SOCKET_NAME); return process_check_success(process, "adb reverse --remove"); } -static SDL_bool -enable_tunnel_forward(const char *serial, Uint16 local_port) { +static bool +enable_tunnel_forward(const char *serial, uint16_t local_port) { process_t process = adb_forward(serial, local_port, SOCKET_NAME); return process_check_success(process, "adb forward"); } -static SDL_bool -disable_tunnel_forward(const char *serial, Uint16 local_port) { +static bool +disable_tunnel_forward(const char *serial, uint16_t local_port) { process_t process = adb_forward_remove(serial, local_port); return process_check_success(process, "adb forward --remove"); } -static SDL_bool +static bool enable_tunnel(struct server *server) { if (enable_tunnel_reverse(server->serial, server->local_port)) { - return SDL_TRUE; + return true; } LOGW("'adb reverse' failed, fallback to 'adb forward'"); - server->tunnel_forward = SDL_TRUE; + server->tunnel_forward = true; return enable_tunnel_forward(server->serial, server->local_port); } -static SDL_bool +static bool disable_tunnel(struct server *server) { if (server->tunnel_forward) { return disable_tunnel_forward(server->serial, server->local_port); @@ -81,9 +80,9 @@ disable_tunnel(struct server *server) { static process_t execute_server(const char *serial, - Uint16 max_size, Uint32 bit_rate, - SDL_bool tunnel_forward, const char *crop, - SDL_bool send_frame_meta) { + uint16_t max_size, uint32_t bit_rate, + bool tunnel_forward, const char *crop, + bool send_frame_meta) { char max_size_string[6]; char bit_rate_string[11]; sprintf(max_size_string, "%"PRIu16, max_size); @@ -106,12 +105,12 @@ execute_server(const char *serial, #define IPV4_LOCALHOST 0x7F000001 static socket_t -listen_on_port(Uint16 port) { +listen_on_port(uint16_t port) { return net_listen(IPV4_LOCALHOST, port, 1); } static socket_t -connect_and_read_byte(Uint16 port) { +connect_and_read_byte(uint16_t port) { socket_t socket = net_connect(IPV4_LOCALHOST, port); if (socket == INVALID_SOCKET) { return INVALID_SOCKET; @@ -128,7 +127,7 @@ connect_and_read_byte(Uint16 port) { } static socket_t -connect_to_server(Uint16 port, Uint32 attempts, Uint32 delay) { +connect_to_server(uint16_t port, uint32_t attempts, uint32_t delay) { do { LOGD("Remaining connection attempts: %d", (int) attempts); socket_t socket = connect_and_read_byte(port); @@ -159,27 +158,27 @@ server_init(struct server *server) { *server = (struct server) SERVER_INITIALIZER; } -SDL_bool +bool server_start(struct server *server, const char *serial, - Uint16 local_port, Uint16 max_size, Uint32 bit_rate, - const char *crop, SDL_bool send_frame_meta) { + uint16_t local_port, uint16_t max_size, uint32_t bit_rate, + const char *crop, bool send_frame_meta) { server->local_port = local_port; if (serial) { server->serial = SDL_strdup(serial); if (!server->serial) { - return SDL_FALSE; + return false; } } if (!push_server(serial)) { SDL_free((void *) server->serial); - return SDL_FALSE; + return false; } if (!enable_tunnel(server)) { SDL_free((void *) server->serial); - return SDL_FALSE; + return false; } // if "adb reverse" does not work (e.g. over "adb connect"), it fallbacks to @@ -197,7 +196,7 @@ server_start(struct server *server, const char *serial, LOGE("Could not listen on port %" PRIu16, local_port); disable_tunnel(server); SDL_free((void *) server->serial); - return SDL_FALSE; + return false; } } @@ -212,12 +211,12 @@ server_start(struct server *server, const char *serial, } disable_tunnel(server); SDL_free((void *) server->serial); - return SDL_FALSE; + return false; } - server->tunnel_enabled = SDL_TRUE; + server->tunnel_enabled = true; - return SDL_TRUE; + return true; } socket_t @@ -225,8 +224,8 @@ server_connect_to(struct server *server) { if (!server->tunnel_forward) { server->device_socket = net_accept(server->server_socket); } else { - Uint32 attempts = 100; - Uint32 delay = 100; // ms + uint32_t attempts = 100; + uint32_t delay = 100; // ms server->device_socket = connect_to_server(server->local_port, attempts, delay); } @@ -242,7 +241,7 @@ server_connect_to(struct server *server) { // we don't need the adb tunnel anymore disable_tunnel(server); // ignore failure - server->tunnel_enabled = SDL_FALSE; + server->tunnel_enabled = false; return server->device_socket; } diff --git a/app/src/server.h b/app/src/server.h index d6d2c3eb..61e0311f 100644 --- a/app/src/server.h +++ b/app/src/server.h @@ -1,6 +1,9 @@ #ifndef SERVER_H #define SERVER_H +#include +#include + #include "command.h" #include "net.h" @@ -9,10 +12,10 @@ struct server { process_t process; socket_t server_socket; // only used if !tunnel_forward socket_t device_socket; - Uint16 local_port; - SDL_bool tunnel_enabled; - SDL_bool tunnel_forward; // use "adb forward" instead of "adb reverse" - SDL_bool send_frame_meta; // request frame PTS to be able to record properly + uint16_t local_port; + bool tunnel_enabled; + bool tunnel_forward; // use "adb forward" instead of "adb reverse" + bool send_frame_meta; // request frame PTS to be able to record properly }; #define SERVER_INITIALIZER { \ @@ -21,9 +24,9 @@ struct server { .server_socket = INVALID_SOCKET, \ .device_socket = INVALID_SOCKET, \ .local_port = 0, \ - .tunnel_enabled = SDL_FALSE, \ - .tunnel_forward = SDL_FALSE, \ - .send_frame_meta = SDL_FALSE, \ + .tunnel_enabled = false, \ + .tunnel_forward = false, \ + .send_frame_meta = false, \ } // init default values @@ -31,10 +34,10 @@ void server_init(struct server *server); // push, enable tunnel et start the server -SDL_bool +bool server_start(struct server *server, const char *serial, - Uint16 local_port, Uint16 max_size, Uint32 bit_rate, - const char *crop, SDL_bool send_frame_meta); + uint16_t local_port, uint16_t max_size, uint32_t bit_rate, + const char *crop, bool send_frame_meta); // block until the communication with the server is established socket_t diff --git a/app/src/stream.c b/app/src/stream.c index 2c9ba078..7ed95ee8 100644 --- a/app/src/stream.c +++ b/app/src/stream.c @@ -23,7 +23,7 @@ #define NO_PTS UINT64_C(-1) static struct frame_meta * -frame_meta_new(Uint64 pts) { +frame_meta_new(uint64_t pts) { struct frame_meta *meta = malloc(sizeof(*meta)); if (!meta) { return meta; @@ -38,11 +38,11 @@ frame_meta_delete(struct frame_meta *frame_meta) { free(frame_meta); } -static SDL_bool -receiver_state_push_meta(struct receiver_state *state, Uint64 pts) { +static bool +receiver_state_push_meta(struct receiver_state *state, uint64_t pts) { struct frame_meta *frame_meta = frame_meta_new(pts); if (!frame_meta) { - return SDL_FALSE; + return false; } // append to the list @@ -52,14 +52,14 @@ receiver_state_push_meta(struct receiver_state *state, Uint64 pts) { p = &(*p)->next; } *p = frame_meta; - return SDL_TRUE; + return true; } -static Uint64 +static uint64_t receiver_state_take_meta(struct receiver_state *state) { struct frame_meta *frame_meta = state->frame_meta_queue; // first item SDL_assert(frame_meta); // must not be empty - Uint64 pts = frame_meta->pts; + uint64_t pts = frame_meta->pts; state->frame_meta_queue = frame_meta->next; // remove the item frame_meta_delete(frame_meta); return pts; @@ -95,7 +95,7 @@ read_packet_with_meta(void *opaque, uint8_t *buf, int buf_size) { // no partial read (net_recv_all()) SDL_assert_release(r == HEADER_SIZE); - Uint64 pts = buffer_read64be(header); + uint64_t pts = buffer_read64be(header); state->remaining = buffer_read32be(&header[8]); if (pts != NO_PTS && !receiver_state_push_meta(state, pts)) { @@ -215,7 +215,7 @@ run_stream(void *data) { if (stream->recorder) { // we retrieve the PTS in order they were received, so they will // be assigned to the correct frame - Uint64 pts = receiver_state_take_meta(&stream->receiver_state); + uint64_t pts = receiver_state_take_meta(&stream->receiver_state); packet.pts = pts; packet.dts = pts; @@ -261,16 +261,16 @@ stream_init(struct stream *stream, socket_t socket, stream->recorder = recorder; } -SDL_bool +bool stream_start(struct stream *stream) { LOGD("Starting stream thread"); stream->thread = SDL_CreateThread(run_stream, "stream", stream); if (!stream->thread) { LOGC("Could not start stream thread"); - return SDL_FALSE; + return false; } - return SDL_TRUE; + return true; } void diff --git a/app/src/stream.h b/app/src/stream.h index d8b61857..d5eda0ac 100644 --- a/app/src/stream.h +++ b/app/src/stream.h @@ -1,7 +1,8 @@ #ifndef STREAM_H #define STREAM_H -#include +#include +#include #include #include "net.h" @@ -9,7 +10,7 @@ struct video_buffer; struct frame_meta { - Uint64 pts; + uint64_t pts; struct frame_meta *next; }; @@ -30,7 +31,7 @@ void stream_init(struct stream *stream, socket_t socket, struct decoder *decoder, struct recorder *recorder); -SDL_bool +bool stream_start(struct stream *stream); void diff --git a/app/src/sys/unix/command.c b/app/src/sys/unix/command.c index cec215aa..fa41571e 100644 --- a/app/src/sys/unix/command.c +++ b/app/src/sys/unix/command.c @@ -73,7 +73,7 @@ end: return ret; } -SDL_bool +bool cmd_terminate(pid_t pid) { if (pid <= 0) { LOGC("Requested to kill %d, this is an error. Please report the bug.\n", @@ -83,7 +83,7 @@ cmd_terminate(pid_t pid) { return kill(pid, SIGTERM) != -1; } -SDL_bool +bool cmd_simple_wait(pid_t pid, int *exit_code) { int status; int code; diff --git a/app/src/sys/unix/net.c b/app/src/sys/unix/net.c index 7fed5ebb..199cd7c2 100644 --- a/app/src/sys/unix/net.c +++ b/app/src/sys/unix/net.c @@ -1,11 +1,11 @@ #include "net.h" -# include +#include -SDL_bool +bool net_init(void) { // do nothing - return SDL_TRUE; + return true; } void @@ -13,7 +13,7 @@ net_cleanup(void) { // do nothing } -SDL_bool +bool net_close(socket_t socket) { return !close(socket); } diff --git a/app/src/sys/win/command.c b/app/src/sys/win/command.c index c5580946..1cd7274f 100644 --- a/app/src/sys/win/command.c +++ b/app/src/sys/win/command.c @@ -57,12 +57,12 @@ cmd_execute(const char *path, const char *const argv[], HANDLE *handle) { return PROCESS_SUCCESS; } -SDL_bool +bool cmd_terminate(HANDLE handle) { return TerminateProcess(handle, 1) && CloseHandle(handle); } -SDL_bool +bool cmd_simple_wait(HANDLE handle, DWORD *exit_code) { DWORD code; if (WaitForSingleObject(handle, INFINITE) != WAIT_OBJECT_0 diff --git a/app/src/sys/win/net.c b/app/src/sys/win/net.c index 0ca55f9b..dc483682 100644 --- a/app/src/sys/win/net.c +++ b/app/src/sys/win/net.c @@ -2,15 +2,15 @@ #include "log.h" -SDL_bool +bool net_init(void) { WSADATA wsa; int res = WSAStartup(MAKEWORD(2, 2), &wsa) < 0; if (res < 0) { LOGC("WSAStartup failed with error %d", res); - return SDL_FALSE; + return false; } - return SDL_TRUE; + return true; } void @@ -18,7 +18,7 @@ net_cleanup(void) { WSACleanup(); } -SDL_bool +bool net_close(socket_t socket) { return !closesocket(socket); } diff --git a/app/src/tiny_xpm.c b/app/src/tiny_xpm.c index b9efd575..01fd280f 100644 --- a/app/src/tiny_xpm.c +++ b/app/src/tiny_xpm.c @@ -1,5 +1,7 @@ #include "tiny_xpm.h" +#include +#include #include #include @@ -7,20 +9,20 @@ struct index { char c; - Uint32 color; + uint32_t color; }; -static SDL_bool -find_color(struct index *index, int len, char c, Uint32 *color) { +static bool +find_color(struct index *index, int len, char c, uint32_t *color) { // there are typically very few color, so it's ok to iterate over the array for (int i = 0; i < len; ++i) { if (index[i].c == c) { *color = index[i].color; - return SDL_TRUE; + return true; } } *color = 0; - return SDL_FALSE; + return false; } // We encounter some problems with SDL2_image on MSYS2 (Windows), @@ -71,7 +73,7 @@ read_xpm(char *xpm[]) { } // parse image - Uint32 *pixels = SDL_malloc(4 * width * height); + uint32_t *pixels = SDL_malloc(4 * width * height); if (!pixels) { LOGE("Could not allocate icon memory"); return NULL; @@ -80,23 +82,23 @@ read_xpm(char *xpm[]) { const char *line = xpm[1 + colors + y]; for (int x = 0; x < width; ++x) { char c = line[x]; - Uint32 color; - SDL_bool color_found = find_color(index, colors, c, &color); + uint32_t color; + bool color_found = find_color(index, colors, c, &color); SDL_assert(color_found); pixels[y * width + x] = color; } } #if SDL_BYTEORDER == SDL_BIG_ENDIAN - Uint32 amask = 0x000000ff; - Uint32 rmask = 0x0000ff00; - Uint32 gmask = 0x00ff0000; - Uint32 bmask = 0xff000000; + uint32_t amask = 0x000000ff; + uint32_t rmask = 0x0000ff00; + uint32_t gmask = 0x00ff0000; + uint32_t bmask = 0xff000000; #else // little endian, like x86 - Uint32 amask = 0xff000000; - Uint32 rmask = 0x00ff0000; - Uint32 gmask = 0x0000ff00; - Uint32 bmask = 0x000000ff; + uint32_t amask = 0xff000000; + uint32_t rmask = 0x00ff0000; + uint32_t gmask = 0x0000ff00; + uint32_t bmask = 0x000000ff; #endif SDL_Surface *surface = SDL_CreateRGBSurfaceFrom(pixels, diff --git a/app/src/video_buffer.c b/app/src/video_buffer.c index f7c34bef..b56ae9f2 100644 --- a/app/src/video_buffer.c +++ b/app/src/video_buffer.c @@ -9,7 +9,7 @@ #include "lock_util.h" #include "log.h" -SDL_bool +bool video_buffer_init(struct video_buffer *vb) { if (!(vb->decoding_frame = av_frame_alloc())) { goto error_0; @@ -28,22 +28,22 @@ video_buffer_init(struct video_buffer *vb) { SDL_DestroyMutex(vb->mutex); goto error_2; } - vb->interrupted = SDL_FALSE; + vb->interrupted = false; #endif // there is initially no rendering frame, so consider it has already been // consumed - vb->rendering_frame_consumed = SDL_TRUE; + vb->rendering_frame_consumed = true; fps_counter_init(&vb->fps_counter); - return SDL_TRUE; + return true; error_2: av_frame_free(&vb->rendering_frame); error_1: av_frame_free(&vb->decoding_frame); error_0: - return SDL_FALSE; + return false; } void @@ -63,7 +63,7 @@ video_buffer_swap_frames(struct video_buffer *vb) { vb->rendering_frame = tmp; } -SDL_bool +bool video_buffer_offer_decoded_frame(struct video_buffer *vb) { mutex_lock(vb->mutex); #ifndef SKIP_FRAMES @@ -80,8 +80,8 @@ video_buffer_offer_decoded_frame(struct video_buffer *vb) { video_buffer_swap_frames(vb); - SDL_bool previous_frame_consumed = vb->rendering_frame_consumed; - vb->rendering_frame_consumed = SDL_FALSE; + bool previous_frame_consumed = vb->rendering_frame_consumed; + vb->rendering_frame_consumed = false; mutex_unlock(vb->mutex); return previous_frame_consumed; @@ -90,7 +90,7 @@ video_buffer_offer_decoded_frame(struct video_buffer *vb) { const AVFrame * video_buffer_consume_rendered_frame(struct video_buffer *vb) { SDL_assert(!vb->rendering_frame_consumed); - vb->rendering_frame_consumed = SDL_TRUE; + vb->rendering_frame_consumed = true; if (vb->fps_counter.started) { fps_counter_add_rendered_frame(&vb->fps_counter); } @@ -108,7 +108,7 @@ video_buffer_interrupt(struct video_buffer *vb) { (void) vb; // unused #else mutex_lock(vb->mutex); - vb->interrupted = SDL_TRUE; + vb->interrupted = true; mutex_unlock(vb->mutex); // wake up blocking wait cond_signal(vb->rendering_frame_consumed_cond); diff --git a/app/src/video_buffer.h b/app/src/video_buffer.h index e9a72f50..03bcaa18 100644 --- a/app/src/video_buffer.h +++ b/app/src/video_buffer.h @@ -1,8 +1,8 @@ #ifndef VIDEO_BUFFER_H #define VIDEO_BUFFER_H +#include #include -#include #include "config.h" #include "fps_counter.h" @@ -15,14 +15,14 @@ struct video_buffer { AVFrame *rendering_frame; SDL_mutex *mutex; #ifndef SKIP_FRAMES - SDL_bool interrupted; + bool interrupted; SDL_cond *rendering_frame_consumed_cond; #endif - SDL_bool rendering_frame_consumed; + bool rendering_frame_consumed; struct fps_counter fps_counter; }; -SDL_bool +bool video_buffer_init(struct video_buffer *vb); void @@ -31,7 +31,7 @@ video_buffer_destroy(struct video_buffer *vb); // set the decoded frame as ready for rendering // this function locks frames->mutex during its execution // returns true if the previous frame had been consumed -SDL_bool +bool video_buffer_offer_decoded_frame(struct video_buffer *vb); // mark the rendering frame as consumed and return it