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

Log with category APPLICATION

Browse source 
All our logs should use APPLICATION category. The logs for other
categories are not printed by default under the "critical" level.
This commit is contained in:
Romain Vimont 2018-02-12 16:06:53 +01:00
parent 598ddcbfbc
commit 6fe65d9f5c
9 changed files with 34 additions and 34 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
app/src/command.c
View file

@ -67,7 +67,7 @@ process_t adb_push(const char *serial, const char *local, const char *remote) {
SDL_bool process_check_success(process_t proc, const char *name) { SDL_bool process_check_success(process_t proc, const char *name) {
if (proc == PROCESS_NONE) { if (proc == PROCESS_NONE) {
SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "Could not execute \"%s\"", name); SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not execute \"%s\"", name);
return SDL_FALSE; return SDL_FALSE;
} }
exit_code_t exit_code; exit_code_t exit_code;

2
app/src/controller.c
View file

@ -80,7 +80,7 @@ SDL_bool controller_start(struct controller *controller) {
controller->thread = SDL_CreateThread(run_controller, "controller", controller); controller->thread = SDL_CreateThread(run_controller, "controller", controller);
if (!controller->thread) { if (!controller->thread) {
SDL_LogCritical(SDL_LOG_CATEGORY_SYSTEM, "Could not start controller thread"); SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not start controller thread");
return SDL_FALSE; return SDL_FALSE;
} }

24
app/src/decoder.c
View file

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

2
app/src/frames.c
View file

@ -69,7 +69,7 @@ SDL_bool frames_offer_decoded_frame(struct frames *frames) {
} }
#else #else
if (!frames->rendering_frame_consumed) { if (!frames->rendering_frame_consumed) {
SDL_LogDebug(SDL_LOG_CATEGORY_RENDER, "Skip frame"); SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "Skip frame");
} }
#endif #endif

8
app/src/lockutil.c
View file

@ -4,28 +4,28 @@
void mutex_lock(SDL_mutex *mutex) { void mutex_lock(SDL_mutex *mutex) {
if (SDL_LockMutex(mutex)) { if (SDL_LockMutex(mutex)) {
SDL_LogCritical(SDL_LOG_CATEGORY_SYSTEM, "Could not lock mutex"); SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not lock mutex");
abort(); abort();
} }
} }
void mutex_unlock(SDL_mutex *mutex) { void mutex_unlock(SDL_mutex *mutex) {
if (SDL_UnlockMutex(mutex)) { if (SDL_UnlockMutex(mutex)) {
SDL_LogCritical(SDL_LOG_CATEGORY_SYSTEM, "Could not unlock mutex"); SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not unlock mutex");
abort(); abort();
} }
} }
void cond_wait(SDL_cond *cond, SDL_mutex *mutex) { void cond_wait(SDL_cond *cond, SDL_mutex *mutex) {
if (SDL_CondWait(cond, mutex)) { if (SDL_CondWait(cond, mutex)) {
SDL_LogCritical(SDL_LOG_CATEGORY_SYSTEM, "Could not wait on condition"); SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not wait on condition");
abort(); abort();
} }
} }
void cond_signal(SDL_cond *cond) { void cond_signal(SDL_cond *cond) {
if (SDL_CondSignal(cond)) { if (SDL_CondSignal(cond)) {
SDL_LogCritical(SDL_LOG_CATEGORY_SYSTEM, "Could not signal a condition"); SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not signal a condition");
abort(); abort();
} }
} }

6
app/src/netutil.c
View file

@ -7,18 +7,18 @@
TCPsocket server_socket_accept(TCPsocket server_socket, Uint32 timeout_ms) { TCPsocket server_socket_accept(TCPsocket server_socket, Uint32 timeout_ms) {
SDLNet_SocketSet set = SDLNet_AllocSocketSet(1); SDLNet_SocketSet set = SDLNet_AllocSocketSet(1);
if (!set) { if (!set) {
SDL_LogCritical(SDL_LOG_CATEGORY_SYSTEM, "Could not allocate socket set"); SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not allocate socket set");
return NULL; return NULL;
} }
if (SDLNet_TCP_AddSocket(set, server_socket) == -1) { if (SDLNet_TCP_AddSocket(set, server_socket) == -1) {
SDL_LogCritical(SDL_LOG_CATEGORY_SYSTEM, "Could not add socket to set"); SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not add socket to set");
SDLNet_FreeSocketSet(set); SDLNet_FreeSocketSet(set);
return NULL; return NULL;
} }
if (SDLNet_CheckSockets(set, timeout_ms) != 1) { if (SDLNet_CheckSockets(set, timeout_ms) != 1) {
SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "No connection to accept"); SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "No connection to accept");
SDLNet_FreeSocketSet(set); SDLNet_FreeSocketSet(set);
return NULL; return NULL;
} }

20
app/src/screen.c
View file

@ -19,13 +19,13 @@ SDL_bool sdl_init_and_configure(void) {
// Bilinear resizing // Bilinear resizing
if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1")) { if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1")) {
SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO, "Could not enable bilinear filtering"); SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Could not enable bilinear filtering");
} }
#if SDL_VERSION_ATLEAST(2, 0, 5) #if SDL_VERSION_ATLEAST(2, 0, 5)
// Handle a click to gain focus as any other click // Handle a click to gain focus as any other click
if (!SDL_SetHint(SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, "1")) { if (!SDL_SetHint(SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, "1")) {
SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO, "Could not enable mouse focus clickthrough"); SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Could not enable mouse focus clickthrough");
} }
#endif #endif
@ -73,7 +73,7 @@ static SDL_bool get_preferred_display_bounds(struct size *bounds) {
# define GET_DISPLAY_BOUNDS(i, r) SDL_GetDisplayBounds((i), (r)) # define GET_DISPLAY_BOUNDS(i, r) SDL_GetDisplayBounds((i), (r))
#endif #endif
if (GET_DISPLAY_BOUNDS(0, &rect)) { if (GET_DISPLAY_BOUNDS(0, &rect)) {
SDL_LogWarn(SDL_LOG_CATEGORY_SYSTEM, "Could not get display usable bounds: %s", SDL_GetError()); SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Could not get display usable bounds: %s", SDL_GetError());
return SDL_FALSE; return SDL_FALSE;
} }
@ -137,26 +137,26 @@ SDL_bool screen_init_rendering(struct screen *screen, const char *device_name, s
screen->window = SDL_CreateWindow(device_name, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, screen->window = SDL_CreateWindow(device_name, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
window_size.width, window_size.height, SDL_WINDOW_HIDDEN | SDL_WINDOW_RESIZABLE); window_size.width, window_size.height, SDL_WINDOW_HIDDEN | SDL_WINDOW_RESIZABLE);
if (!screen->window) { if (!screen->window) {
SDL_LogCritical(SDL_LOG_CATEGORY_SYSTEM, "Could not create window: %s", SDL_GetError()); SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not create window: %s", SDL_GetError());
return SDL_FALSE; return SDL_FALSE;
} }
screen->renderer = SDL_CreateRenderer(screen->window, -1, SDL_RENDERER_ACCELERATED); screen->renderer = SDL_CreateRenderer(screen->window, -1, SDL_RENDERER_ACCELERATED);
if (!screen->renderer) { if (!screen->renderer) {
SDL_LogCritical(SDL_LOG_CATEGORY_RENDER, "Could not create renderer: %s", SDL_GetError()); SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not create renderer: %s", SDL_GetError());
screen_destroy(screen); screen_destroy(screen);
return SDL_FALSE; return SDL_FALSE;
} }
if (SDL_RenderSetLogicalSize(screen->renderer, frame_size.width, frame_size.height)) { if (SDL_RenderSetLogicalSize(screen->renderer, frame_size.width, frame_size.height)) {
SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Could not set renderer logical size: %s", SDL_GetError()); SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not set renderer logical size: %s", SDL_GetError());
screen_destroy(screen); screen_destroy(screen);
return SDL_FALSE; return SDL_FALSE;
} }
SDL_Surface *icon = read_xpm(icon_xpm); SDL_Surface *icon = read_xpm(icon_xpm);
if (!icon) { if (!icon) {
SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "Could not load icon: %s", SDL_GetError()); SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not load icon: %s", SDL_GetError());
screen_destroy(screen); screen_destroy(screen);
return SDL_FALSE; return SDL_FALSE;
} }
@ -167,7 +167,7 @@ SDL_bool screen_init_rendering(struct screen *screen, const char *device_name, s
screen->texture = SDL_CreateTexture(screen->renderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING, screen->texture = SDL_CreateTexture(screen->renderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING,
frame_size.width, frame_size.height); frame_size.width, frame_size.height);
if (!screen->texture) { if (!screen->texture) {
SDL_LogCritical(SDL_LOG_CATEGORY_RENDER, "Could not create texture: %s", SDL_GetError()); SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not create texture: %s", SDL_GetError());
screen_destroy(screen); screen_destroy(screen);
return SDL_FALSE; return SDL_FALSE;
} }
@ -196,7 +196,7 @@ void screen_destroy(struct screen *screen) {
static SDL_bool prepare_for_frame(struct screen *screen, struct size new_frame_size) { static SDL_bool prepare_for_frame(struct screen *screen, struct size new_frame_size) {
if (screen->frame_size.width != new_frame_size.width || screen->frame_size.height != new_frame_size.height) { if (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)) { if (SDL_RenderSetLogicalSize(screen->renderer, new_frame_size.width, new_frame_size.height)) {
SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Could not set renderer logical size: %s", SDL_GetError()); SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not set renderer logical size: %s", SDL_GetError());
return SDL_FALSE; return SDL_FALSE;
} }
@ -218,7 +218,7 @@ static SDL_bool prepare_for_frame(struct screen *screen, struct size new_frame_s
screen->texture = SDL_CreateTexture(screen->renderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING, screen->texture = SDL_CreateTexture(screen->renderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING,
new_frame_size.width, new_frame_size.height); new_frame_size.width, new_frame_size.height);
if (!screen->texture) { if (!screen->texture) {
SDL_LogCritical(SDL_LOG_CATEGORY_RENDER, "Could not create texture: %s", SDL_GetError()); SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Could not create texture: %s", SDL_GetError());
return SDL_FALSE; return SDL_FALSE;
} }
} }

2
app/src/server.c
View file

@ -46,7 +46,7 @@ static process_t execute_server(const char *serial, Uint16 max_size, Uint32 bit_
static void terminate_server(process_t server) { static void terminate_server(process_t server) {
if (!cmd_terminate(server)) { if (!cmd_terminate(server)) {
SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "Could not terminate server: %s", strerror(errno)); SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not terminate server: %s", strerror(errno));
} }
} }

2
app/src/tinyxpm.c
View file

@ -69,7 +69,7 @@ SDL_Surface *read_xpm(char *xpm[]) {
// parse image // parse image
Uint32 *pixels = SDL_malloc(4 * width * height); Uint32 *pixels = SDL_malloc(4 * width * height);
if (!pixels) { if (!pixels) {
SDL_LogError(SDL_LOG_CATEGORY_SYSTEM, "Could not allocate icon memory"); SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Could not allocate icon memory");
return NULL; return NULL;
} }
for (int y = 0; y < height; ++y) { for (int y = 0; y < height; ++y) {