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

Use sc_prefix for fps counter

Browse source
This commit is contained in:
Romain Vimont 2022-02-17 19:55:14 +01:00
parent 85edba20e7
commit 03705b828b
5 changed files with 42 additions and 42 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

38
app/src/fps_counter.c
View file

@ -4,10 +4,10 @@
#include "util/log.h" #include "util/log.h"
#define FPS_COUNTER_INTERVAL SC_TICK_FROM_SEC(1) #define SC_FPS_COUNTER_INTERVAL SC_TICK_FROM_SEC(1)
bool bool
fps_counter_init(struct fps_counter *counter) { sc_fps_counter_init(struct sc_fps_counter *counter) {
bool ok = sc_mutex_init(&counter->mutex); bool ok = sc_mutex_init(&counter->mutex);
if (!ok) { if (!ok) {
return false; return false;
@ -27,26 +27,26 @@ fps_counter_init(struct fps_counter *counter) {
} }
void void
fps_counter_destroy(struct fps_counter *counter) { sc_fps_counter_destroy(struct sc_fps_counter *counter) {
sc_cond_destroy(&counter->state_cond); sc_cond_destroy(&counter->state_cond);
sc_mutex_destroy(&counter->mutex); sc_mutex_destroy(&counter->mutex);
} }
static inline bool static inline bool
is_started(struct fps_counter *counter) { is_started(struct sc_fps_counter *counter) {
return atomic_load_explicit(&counter->started, memory_order_acquire); return atomic_load_explicit(&counter->started, memory_order_acquire);
} }
static inline void static inline void
set_started(struct fps_counter *counter, bool started) { set_started(struct sc_fps_counter *counter, bool started) {
atomic_store_explicit(&counter->started, started, memory_order_release); atomic_store_explicit(&counter->started, started, memory_order_release);
} }
// must be called with mutex locked // must be called with mutex locked
static void static void
display_fps(struct fps_counter *counter) { display_fps(struct sc_fps_counter *counter) {
unsigned rendered_per_second = unsigned rendered_per_second =
counter->nr_rendered * SC_TICK_FREQ / FPS_COUNTER_INTERVAL; counter->nr_rendered * SC_TICK_FREQ / SC_FPS_COUNTER_INTERVAL;
if (counter->nr_skipped) { if (counter->nr_skipped) {
LOGI("%u fps (+%u frames skipped)", rendered_per_second, LOGI("%u fps (+%u frames skipped)", rendered_per_second,
counter->nr_skipped); counter->nr_skipped);
@ -57,7 +57,7 @@ display_fps(struct fps_counter *counter) {
// must be called with mutex locked // must be called with mutex locked
static void static void
check_interval_expired(struct fps_counter *counter, sc_tick now) { check_interval_expired(struct sc_fps_counter *counter, sc_tick now) {
if (now < counter->next_timestamp) { if (now < counter->next_timestamp) {
return; return;
} }
@ -67,13 +67,13 @@ check_interval_expired(struct fps_counter *counter, sc_tick now) {
counter->nr_skipped = 0; counter->nr_skipped = 0;
// add a multiple of the interval // add a multiple of the interval
uint32_t elapsed_slices = uint32_t elapsed_slices =
(now - counter->next_timestamp) / FPS_COUNTER_INTERVAL + 1; (now - counter->next_timestamp) / SC_FPS_COUNTER_INTERVAL + 1;
counter->next_timestamp += FPS_COUNTER_INTERVAL * elapsed_slices; counter->next_timestamp += SC_FPS_COUNTER_INTERVAL * elapsed_slices;
} }
static int static int
run_fps_counter(void *data) { run_fps_counter(void *data) {
struct fps_counter *counter = data; struct sc_fps_counter *counter = data;
sc_mutex_lock(&counter->mutex); sc_mutex_lock(&counter->mutex);
while (!counter->interrupted) { while (!counter->interrupted) {
@ -94,9 +94,9 @@ run_fps_counter(void *data) {
} }
bool bool
fps_counter_start(struct fps_counter *counter) { sc_fps_counter_start(struct sc_fps_counter *counter) {
sc_mutex_lock(&counter->mutex); sc_mutex_lock(&counter->mutex);
counter->next_timestamp = sc_tick_now() + FPS_COUNTER_INTERVAL; counter->next_timestamp = sc_tick_now() + SC_FPS_COUNTER_INTERVAL;
counter->nr_rendered = 0; counter->nr_rendered = 0;
counter->nr_skipped = 0; counter->nr_skipped = 0;
sc_mutex_unlock(&counter->mutex); sc_mutex_unlock(&counter->mutex);
@ -121,18 +121,18 @@ fps_counter_start(struct fps_counter *counter) {
} }
void void
fps_counter_stop(struct fps_counter *counter) { sc_fps_counter_stop(struct sc_fps_counter *counter) {
set_started(counter, false); set_started(counter, false);
sc_cond_signal(&counter->state_cond); sc_cond_signal(&counter->state_cond);
} }
bool bool
fps_counter_is_started(struct fps_counter *counter) { sc_fps_counter_is_started(struct sc_fps_counter *counter) {
return is_started(counter); return is_started(counter);
} }
void void
fps_counter_interrupt(struct fps_counter *counter) { sc_fps_counter_interrupt(struct sc_fps_counter *counter) {
if (!counter->thread_started) { if (!counter->thread_started) {
return; return;
} }
@ -145,7 +145,7 @@ fps_counter_interrupt(struct fps_counter *counter) {
} }
void void
fps_counter_join(struct fps_counter *counter) { sc_fps_counter_join(struct sc_fps_counter *counter) {
if (counter->thread_started) { if (counter->thread_started) {
// interrupted must be set by the thread calling join(), so no need to // interrupted must be set by the thread calling join(), so no need to
// lock for the assertion // lock for the assertion
@ -156,7 +156,7 @@ fps_counter_join(struct fps_counter *counter) {
} }
void void
fps_counter_add_rendered_frame(struct fps_counter *counter) { sc_fps_counter_add_rendered_frame(struct sc_fps_counter *counter) {
if (!is_started(counter)) { if (!is_started(counter)) {
return; return;
} }
@ -169,7 +169,7 @@ fps_counter_add_rendered_frame(struct fps_counter *counter) {
} }
void void
fps_counter_add_skipped_frame(struct fps_counter *counter) { sc_fps_counter_add_skipped_frame(struct sc_fps_counter *counter) {
if (!is_started(counter)) { if (!is_started(counter)) {
return; return;
} }

22
app/src/fps_counter.h
View file

@ -9,7 +9,7 @@
#include "util/thread.h" #include "util/thread.h"
struct fps_counter { struct sc_fps_counter {
sc_thread thread; sc_thread thread;
sc_mutex mutex; sc_mutex mutex;
sc_cond state_cond; sc_cond state_cond;
@ -28,32 +28,32 @@ struct fps_counter {
}; };
bool bool
fps_counter_init(struct fps_counter *counter); sc_fps_counter_init(struct sc_fps_counter *counter);
void void
fps_counter_destroy(struct fps_counter *counter); sc_fps_counter_destroy(struct sc_fps_counter *counter);
bool bool
fps_counter_start(struct fps_counter *counter); sc_fps_counter_start(struct sc_fps_counter *counter);
void void
fps_counter_stop(struct fps_counter *counter); sc_fps_counter_stop(struct sc_fps_counter *counter);
bool bool
fps_counter_is_started(struct fps_counter *counter); sc_fps_counter_is_started(struct sc_fps_counter *counter);
// request to stop the thread (on quit) // request to stop the thread (on quit)
// must be called before fps_counter_join() // must be called before sc_fps_counter_join()
void void
fps_counter_interrupt(struct fps_counter *counter); sc_fps_counter_interrupt(struct sc_fps_counter *counter);
void void
fps_counter_join(struct fps_counter *counter); sc_fps_counter_join(struct sc_fps_counter *counter);
void void
fps_counter_add_rendered_frame(struct fps_counter *counter); sc_fps_counter_add_rendered_frame(struct sc_fps_counter *counter);
void void
fps_counter_add_skipped_frame(struct fps_counter *counter); sc_fps_counter_add_skipped_frame(struct sc_fps_counter *counter);
#endif #endif

8
app/src/input_manager.c
View file

@ -242,14 +242,14 @@ set_screen_power_mode(struct sc_controller *controller,
} }
static void static void
switch_fps_counter_state(struct fps_counter *fps_counter) { switch_fps_counter_state(struct sc_fps_counter *fps_counter) {
// the started state can only be written from the current thread, so there // the started state can only be written from the current thread, so there
// is no ToCToU issue // is no ToCToU issue
if (fps_counter_is_started(fps_counter)) { if (sc_fps_counter_is_started(fps_counter)) {
fps_counter_stop(fps_counter); sc_fps_counter_stop(fps_counter);
LOGI("FPS counter stopped"); LOGI("FPS counter stopped");
} else { } else {
if (fps_counter_start(fps_counter)) { if (sc_fps_counter_start(fps_counter)) {
LOGI("FPS counter started"); LOGI("FPS counter started");
} else { } else {
LOGE("FPS counter starting failed"); LOGE("FPS counter starting failed");

14
app/src/screen.c
View file

@ -347,7 +347,7 @@ sc_video_buffer_on_new_frame(struct sc_video_buffer *vb, bool previous_skipped,
bool need_new_event; bool need_new_event;
if (previous_skipped) { if (previous_skipped) {
fps_counter_add_skipped_frame(&screen->fps_counter); sc_fps_counter_add_skipped_frame(&screen->fps_counter);
// The EVENT_NEW_FRAME triggered for the previous frame will consume // The EVENT_NEW_FRAME triggered for the previous frame will consume
// this new frame instead, unless the previous event failed // this new frame instead, unless the previous event failed
need_new_event = screen->event_failed; need_new_event = screen->event_failed;
@ -402,7 +402,7 @@ sc_screen_init(struct sc_screen *screen,
goto error_destroy_video_buffer; goto error_destroy_video_buffer;
} }
if (!fps_counter_init(&screen->fps_counter)) { if (!sc_fps_counter_init(&screen->fps_counter)) {
goto error_stop_and_join_video_buffer; goto error_stop_and_join_video_buffer;
} }
@ -534,7 +534,7 @@ error_destroy_renderer:
error_destroy_window: error_destroy_window:
SDL_DestroyWindow(screen->window); SDL_DestroyWindow(screen->window);
error_destroy_fps_counter: error_destroy_fps_counter:
fps_counter_destroy(&screen->fps_counter); sc_fps_counter_destroy(&screen->fps_counter);
error_stop_and_join_video_buffer: error_stop_and_join_video_buffer:
sc_video_buffer_stop(&screen->vb); sc_video_buffer_stop(&screen->vb);
sc_video_buffer_join(&screen->vb); sc_video_buffer_join(&screen->vb);
@ -573,13 +573,13 @@ sc_screen_hide_window(struct sc_screen *screen) {
void void
sc_screen_interrupt(struct sc_screen *screen) { sc_screen_interrupt(struct sc_screen *screen) {
sc_video_buffer_stop(&screen->vb); sc_video_buffer_stop(&screen->vb);
fps_counter_interrupt(&screen->fps_counter); sc_fps_counter_interrupt(&screen->fps_counter);
} }
void void
sc_screen_join(struct sc_screen *screen) { sc_screen_join(struct sc_screen *screen) {
sc_video_buffer_join(&screen->vb); sc_video_buffer_join(&screen->vb);
fps_counter_join(&screen->fps_counter); sc_fps_counter_join(&screen->fps_counter);
} }
void void
@ -591,7 +591,7 @@ sc_screen_destroy(struct sc_screen *screen) {
SDL_DestroyTexture(screen->texture); SDL_DestroyTexture(screen->texture);
SDL_DestroyRenderer(screen->renderer); SDL_DestroyRenderer(screen->renderer);
SDL_DestroyWindow(screen->window); SDL_DestroyWindow(screen->window);
fps_counter_destroy(&screen->fps_counter); sc_fps_counter_destroy(&screen->fps_counter);
sc_video_buffer_destroy(&screen->vb); sc_video_buffer_destroy(&screen->vb);
} }
@ -701,7 +701,7 @@ sc_screen_update_frame(struct sc_screen *screen) {
sc_video_buffer_consume(&screen->vb, screen->frame); sc_video_buffer_consume(&screen->vb, screen->frame);
AVFrame *frame = screen->frame; AVFrame *frame = screen->frame;
fps_counter_add_rendered_frame(&screen->fps_counter); sc_fps_counter_add_rendered_frame(&screen->fps_counter);
struct sc_size new_frame_size = {frame->width, frame->height}; struct sc_size new_frame_size = {frame->width, frame->height};
if (!prepare_for_frame(screen, new_frame_size)) { if (!prepare_for_frame(screen, new_frame_size)) {

2
app/src/screen.h
View file

@ -26,7 +26,7 @@ struct sc_screen {
struct sc_input_manager im; struct sc_input_manager im;
struct sc_video_buffer vb; struct sc_video_buffer vb;
struct fps_counter fps_counter; struct sc_fps_counter fps_counter;
// The initial requested window properties // The initial requested window properties
struct { struct {