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

Replace SDL types by C99 standard types

Browse source 
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
This commit is contained in:
Romain Vimont 2019-03-02 23:52:22 +01:00
parent 8655ba7197
commit dfed1b250e
40 changed files with 456 additions and 438 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
app/src/buffer_util.h
View file

@ -1,32 +1,33 @@
#ifndef BUFFER_UTIL_H
#define BUFFER_UTIL_H
#include <SDL2/SDL_stdinc.h>
#include <stdbool.h>
#include <stdint.h>
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

8
app/src/command.c
View file

@ -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;
}

8
app/src/command.h
View file

@ -1,8 +1,8 @@
#ifndef COMMAND_H
#define COMMAND_H
#include <stdbool.h>
#include <inttypes.h>
#include <SDL2/SDL_stdinc.h>
#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

10
app/src/common.h
View file

@ -1,20 +1,20 @@
#ifndef COMMON_H
#define COMMON_H
#include <SDL2/SDL_stdinc.h>
#include <stdint.h>
#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 {

29
app/src/control_event.c
View file

@ -1,6 +1,5 @@
#include "control_event.h"
#include <SDL2/SDL_stdinc.h>
#include <string.h>
#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;
}

17
app/src/control_event.h
View file

@ -1,8 +1,9 @@
#ifndef CONTROLEVENT_H
#define CONTROLEVENT_H
#include <stdbool.h>
#include <stdint.h>
#include <SDL2/SDL_mutex.h>
#include <SDL2/SDL_stdinc.h>
#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);

35
app/src/controller.c
View file

@ -1,29 +1,30 @@
#include "controller.h"
#include <SDL2/SDL_assert.h>
#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);
}

10
app/src/controller.h
View file

@ -3,8 +3,8 @@
#include "control_event.h"
#include <stdbool.h>
#include <SDL2/SDL_mutex.h>
#include <SDL2/SDL_stdinc.h>
#include <SDL2/SDL_thread.h>
#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);

40
app/src/convert.c
View file

@ -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;
}

11
app/src/convert.h
View file

@ -1,8 +1,9 @@
#ifndef CONVERT_H
#define CONVERT_H
#include <SDL2/SDL_stdinc.h>
#include <stdbool.h>
#include <SDL2/SDL_events.h>
#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);

20
app/src/decoder.c
View file

@ -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:
// <http://git.videolan.org/?p=ffmpeg.git;a=commitdiff;h=7fc329e2dd6226dfecaa4a1d7adf353bf2773726>
@ -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

6
app/src/decoder.h
View file

@ -1,8 +1,8 @@
#ifndef DECODER_H
#define DECODER_H
#include <stdbool.h>
#include <libavformat/avformat.h>
#include <SDL2/SDL_stdinc.h>
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

6
app/src/device.c
View file

@ -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;
}

4
app/src/device.h
View file

@ -1,7 +1,7 @@
#ifndef DEVICE_H
#define DEVICE_H
#include <SDL2/SDL_stdinc.h>
#include <stdbool.h>
#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

58
app/src/file_handler.c
View file

@ -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)) {

13
app/src/file_handler.h
View file

@ -1,9 +1,10 @@
#ifndef FILE_HANDLER_H
#define FILE_HANDLER_H
#include <stdbool.h>
#include <SDL2/SDL_mutex.h>
#include <SDL2/SDL_stdinc.h>
#include <SDL2/SDL_thread.h>
#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);

10
app/src/fps_counter.c
View file

@ -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

7
app/src/fps_counter.h
View file

@ -1,13 +1,14 @@
#ifndef FPSCOUNTER_H
#define FPSCOUNTER_H
#include <SDL2/SDL_stdinc.h>
#include <stdbool.h>
#include <stdint.h>
#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;

18
app/src/input_manager.c
View file

@ -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) {

4
app/src/input_manager.h
View file

@ -1,6 +1,8 @@
#ifndef INPUTMANAGER_H
#define INPUTMANAGER_H
#include <stdbool.h>
#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

126
app/src/main.c
View file

@ -1,6 +1,8 @@
#include "scrcpy.h"
#include <getopt.h>
#include <stdbool.h>
#include <stdint.h>
#include <unistd.h>
#include <libavformat/avformat.h>
#include <SDL2/SDL.h>
@ -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;

6
app/src/net.c
View file

@ -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);
}

13
app/src/net.h
View file

@ -1,8 +1,9 @@
#ifndef NET_H
#define NET_H
#include <stdbool.h>
#include <stdint.h>
#include <SDL2/SDL_platform.h>
#include <SDL2/SDL_stdinc.h>
#ifdef __WINDOWS__
# include <winsock2.h>
@ -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

36
app/src/recorder.c
View file

@ -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);

10
app/src/recorder.h
View file

@ -1,8 +1,8 @@
#ifndef RECORDER_H
#define RECORDER_H
#include <stdbool.h>
#include <libavformat/avformat.h>
#include <SDL2/SDL_stdinc.h>
#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

64
app/src/scrcpy.c
View file

@ -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);
}

21
app/src/scrcpy.h
View file

@ -1,7 +1,8 @@
#ifndef SCRCPY_H
#define SCRCPY_H
#include <SDL2/SDL_stdinc.h>
#include <stdbool.h>
#include <stdint.h>
#include <recorder.h>
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

59
app/src/screen.c
View file

@ -1,8 +1,9 @@
#include "screen.h"
#include <SDL2/SDL.h>
#include <string.h>
#include <SDL2/SDL.h>
#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;

21
app/src/screen.h
View file

@ -1,6 +1,7 @@
#ifndef SCREEN_H
#define SCREEN_H
#include <stdbool.h>
#include <SDL2/SDL.h>
#include <libavformat/avformat.h>
@ -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

63
app/src/server.c
View file

@ -2,7 +2,6 @@
#include <errno.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <SDL2/SDL_assert.h>
#include <SDL2/SDL_timer.h>
@ -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;
}

23
app/src/server.h
View file

@ -1,6 +1,9 @@
#ifndef SERVER_H
#define SERVER_H
#include <stdbool.h>
#include <stdint.h>
#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

24
app/src/stream.c
View file

@ -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

7
app/src/stream.h
View file

@ -1,7 +1,8 @@
#ifndef STREAM_H
#define STREAM_H
#include <SDL2/SDL_stdinc.h>
#include <stdbool.h>
#include <stdint.h>
#include <SDL2/SDL_thread.h>
#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

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

@ -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;

6
app/src/sys/unix/net.c
View file

@ -2,10 +2,10 @@
#include <unistd.h>
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);
}

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

@ -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

8
app/src/sys/win/net.c
View file

@ -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);
}

34
app/src/tiny_xpm.c
View file

@ -1,5 +1,7 @@
#include "tiny_xpm.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
@ -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,

20
app/src/video_buffer.c
View file

@ -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);

10
app/src/video_buffer.h
View file

@ -1,8 +1,8 @@
#ifndef VIDEO_BUFFER_H
#define VIDEO_BUFFER_H
#include <stdbool.h>
#include <SDL2/SDL_mutex.h>
#include <SDL2/SDL_stdinc.h>
#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