Display and control your Android device
Improve framerate counting
Romain Vimonte2a272bf99ec
diff --git a/app/src/fps_counter.c b/app/src/fps_counter.cindex 133c7a25..daece470 100644--- a/app/src/fps_counter.c+++ b/app/src/fps_counter.c@@ -1,60 +1,169 @@#include "fps_counter.h"+#include <SDL2/SDL_assert.h>#include <SDL2/SDL_timer.h>+#include "lock_util.h"#include "log.h"-void+#define FPS_COUNTER_INTERVAL_MS 1000++boolfps_counter_init(struct fps_counter *counter) {- counter->started = false;- // no need to initialize the other fields, they are meaningful only when- // started is true-}+ counter->mutex = SDL_CreateMutex();+ if (!counter->mutex) {+ return false;+ }-void-fps_counter_start(struct fps_counter *counter) {- counter->started = true;- counter->slice_start = SDL_GetTicks();- counter->nr_rendered = 0;- counter->nr_skipped = 0;+ counter->state_cond = SDL_CreateCond();+ if (!counter->state_cond) {+ SDL_DestroyMutex(counter->mutex);+ return false;+ }++ counter->thread = NULL;+ SDL_AtomicSet(&counter->started, 0);+ // no need to initialize the other fields, they are unused until started++ return true;}void-fps_counter_stop(struct fps_counter *counter) {- counter->started = false;+fps_counter_destroy(struct fps_counter *counter) {+ SDL_DestroyCond(counter->state_cond);+ SDL_DestroyMutex(counter->mutex);}+// must be called with mutex lockedstatic voiddisplay_fps(struct fps_counter *counter) {+ unsigned rendered_per_second =+ counter->nr_rendered * 1000 / FPS_COUNTER_INTERVAL_MS;if (counter->nr_skipped) {- LOGI("%d fps (+%d frames skipped)", counter->nr_rendered,+ LOGI("%u fps (+%u frames skipped)", rendered_per_second,counter->nr_skipped);} else {- LOGI("%d fps", counter->nr_rendered);+ LOGI("%u fps", rendered_per_second);}}+// must be called with mutex lockedstatic void-check_expired(struct fps_counter *counter) {- uint32_t now = SDL_GetTicks();- if (now - counter->slice_start >= 1000) {- display_fps(counter);- // add a multiple of one second- uint32_t elapsed_slices = (now - counter->slice_start) / 1000;- counter->slice_start += 1000 * elapsed_slices;- counter->nr_rendered = 0;- counter->nr_skipped = 0;+check_interval_expired(struct fps_counter *counter, uint32_t now) {+ if (now < counter->next_timestamp) {+ return;+ }++ display_fps(counter);+ counter->nr_rendered = 0;+ counter->nr_skipped = 0;+ // add a multiple of the interval+ uint32_t elapsed_slices =+ (now - counter->next_timestamp) / FPS_COUNTER_INTERVAL_MS + 1;+ counter->next_timestamp += FPS_COUNTER_INTERVAL_MS * elapsed_slices;+}++static int+run_fps_counter(void *data) {+ struct fps_counter *counter = data;++ mutex_lock(counter->mutex);+ while (!counter->interrupted) {+ while (!counter->interrupted && !SDL_AtomicGet(&counter->started)) {+ cond_wait(counter->state_cond, counter->mutex);+ }+ while (!counter->interrupted && SDL_AtomicGet(&counter->started)) {+ uint32_t now = SDL_GetTicks();+ check_interval_expired(counter, now);++ SDL_assert(counter->next_timestamp > now);+ uint32_t remaining = counter->next_timestamp - now;++ // ignore the reason (timeout or signaled), we just loop anyway+ cond_wait_timeout(counter->state_cond, counter->mutex, remaining);+ }+ }+ mutex_unlock(counter->mutex);+ return 0;+}++bool+fps_counter_start(struct fps_counter *counter) {+ mutex_lock(counter->mutex);+ counter->next_timestamp = SDL_GetTicks() + FPS_COUNTER_INTERVAL_MS;+ counter->nr_rendered = 0;+ counter->nr_skipped = 0;+ mutex_unlock(counter->mutex);++ SDL_AtomicSet(&counter->started, 1);+ cond_signal(counter->state_cond);++ // counter->thread is always accessed from the same thread, no need to lock+ if (!counter->thread) {+ counter->thread =+ SDL_CreateThread(run_fps_counter, "fps counter", counter);+ if (!counter->thread) {+ LOGE("Could not start FPS counter thread");+ return false;+ }+ }++ return true;+}++void+fps_counter_stop(struct fps_counter *counter) {+ SDL_AtomicSet(&counter->started, 0);+ cond_signal(counter->state_cond);+}++bool+fps_counter_is_started(struct fps_counter *counter) {+ return SDL_AtomicGet(&counter->started);+}++void+fps_counter_interrupt(struct fps_counter *counter) {+ if (!counter->thread) {+ return;+ }++ mutex_lock(counter->mutex);+ counter->interrupted = true;+ mutex_unlock(counter->mutex);+ // wake up blocking wait+ cond_signal(counter->state_cond);+}++void+fps_counter_join(struct fps_counter *counter) {+ if (counter->thread) {+ SDL_WaitThread(counter->thread, NULL);}}voidfps_counter_add_rendered_frame(struct fps_counter *counter) {- check_expired(counter);+ if (!SDL_AtomicGet(&counter->started)) {+ return;+ }++ mutex_lock(counter->mutex);+ uint32_t now = SDL_GetTicks();+ check_interval_expired(counter, now);++counter->nr_rendered;+ mutex_unlock(counter->mutex);}voidfps_counter_add_skipped_frame(struct fps_counter *counter) {- check_expired(counter);+ if (!SDL_AtomicGet(&counter->started)) {+ return;+ }++ mutex_lock(counter->mutex);+ uint32_t now = SDL_GetTicks();+ check_interval_expired(counter, now);++counter->nr_skipped;+ mutex_unlock(counter->mutex);}diff --git a/app/src/fps_counter.h b/app/src/fps_counter.hindex fecef806..6b560a35 100644--- a/app/src/fps_counter.h+++ b/app/src/fps_counter.h@@ -3,23 +3,49 @@#include <stdbool.h>#include <stdint.h>+#include <SDL2/SDL_atomic.h>+#include <SDL2/SDL_mutex.h>+#include <SDL2/SDL_thread.h>struct fps_counter {- bool started;- uint32_t slice_start; // initialized by SDL_GetTicks()- int nr_rendered;- int nr_skipped;+ SDL_Thread *thread;+ SDL_mutex *mutex;+ SDL_cond *state_cond;++ // atomic so that we can check without locking the mutex+ // if the FPS counter is disabled, we don't want to lock unnecessarily+ SDL_atomic_t started;++ // the following fields are protected by the mutex+ bool interrupted;+ unsigned nr_rendered;+ unsigned nr_skipped;+ uint32_t next_timestamp;};-void+boolfps_counter_init(struct fps_counter *counter);void+fps_counter_destroy(struct fps_counter *counter);++boolfps_counter_start(struct fps_counter *counter);voidfps_counter_stop(struct fps_counter *counter);+bool+fps_counter_is_started(struct fps_counter *counter);++// request to stop the thread (on quit)+// must be called before fps_counter_join()+void+fps_counter_interrupt(struct fps_counter *counter);++void+fps_counter_join(struct fps_counter *counter);+voidfps_counter_add_rendered_frame(struct fps_counter *counter);diff --git a/app/src/input_manager.c b/app/src/input_manager.cindex 03f299db..fb8ef8f0 100644--- a/app/src/input_manager.c+++ b/app/src/input_manager.c@@ -172,16 +172,19 @@ set_screen_power_mode(struct controller *controller,}static void-switch_fps_counter_state(struct video_buffer *vb) {- mutex_lock(vb->mutex);- if (vb->fps_counter.started) {+switch_fps_counter_state(struct fps_counter *fps_counter) {+ // the started state can only be written from the current thread, so there+ // is no ToCToU issue+ if (fps_counter_is_started(fps_counter)) {+ fps_counter_stop(fps_counter);LOGI("FPS counter stopped");- fps_counter_stop(&vb->fps_counter);} else {- LOGI("FPS counter started");- fps_counter_start(&vb->fps_counter);+ if (fps_counter_start(fps_counter)) {+ LOGI("FPS counter started");+ } else {+ LOGE("FPS counter starting failed");+ }}- mutex_unlock(vb->mutex);}static void@@ -339,7 +342,9 @@ input_manager_process_key(struct input_manager *input_manager,return;case SDLK_i:if (ctrl && !meta && !shift && !repeat && down) {- switch_fps_counter_state(input_manager->video_buffer);+ struct fps_counter *fps_counter =+ input_manager->video_buffer->fps_counter;+ switch_fps_counter_state(fps_counter);}return;case SDLK_n:diff --git a/app/src/scrcpy.c b/app/src/scrcpy.cindex 38ad1ceb..761edb69 100644--- a/app/src/scrcpy.c+++ b/app/src/scrcpy.c@@ -29,6 +29,7 @@static struct server server = SERVER_INITIALIZER;static struct screen screen = SCREEN_INITIALIZER;+static struct fps_counter fps_counter;static struct video_buffer video_buffer;static struct stream stream;static struct decoder decoder;@@ -293,6 +294,7 @@ scrcpy(const struct scrcpy_options *options) {bool ret = false;+ bool fps_counter_initialized = false;bool video_buffer_initialized = false;bool file_handler_initialized = false;bool recorder_initialized = false;@@ -320,7 +322,13 @@ scrcpy(const struct scrcpy_options *options) {struct decoder *dec = NULL;if (options->display) {- if (!video_buffer_init(&video_buffer, options->render_expired_frames)) {+ if (!fps_counter_init(&fps_counter)) {+ goto end;+ }+ fps_counter_initialized = true;++ if (!video_buffer_init(&video_buffer, &fps_counter,+ options->render_expired_frames)) {goto end;}video_buffer_initialized = true;@@ -414,6 +422,9 @@ end:if (file_handler_initialized) {file_handler_stop(&file_handler);}+ if (fps_counter_initialized) {+ fps_counter_interrupt(&fps_counter);+ }// shutdown the sockets and kill the serverserver_stop(&server);@@ -443,6 +454,11 @@ end:video_buffer_destroy(&video_buffer);}+ if (fps_counter_initialized) {+ fps_counter_join(&fps_counter);+ fps_counter_destroy(&fps_counter);+ }+if (options->show_touches) {if (!show_touches_waited) {// wait the process which enabled "show touches"diff --git a/app/src/video_buffer.c b/app/src/video_buffer.cindex f26af0b6..2b5f1c2f 100644--- a/app/src/video_buffer.c+++ b/app/src/video_buffer.c@@ -10,7 +10,10 @@#include "log.h"bool-video_buffer_init(struct video_buffer *vb, bool render_expired_frames) {+video_buffer_init(struct video_buffer *vb, struct fps_counter *fps_counter,+ bool render_expired_frames) {+ vb->fps_counter = fps_counter;+if (!(vb->decoding_frame = av_frame_alloc())) {goto error_0;}@@ -37,7 +40,6 @@ video_buffer_init(struct video_buffer *vb, bool render_expired_frames) {// there is initially no rendering frame, so consider it has already been// consumedvb->rendering_frame_consumed = true;- fps_counter_init(&vb->fps_counter);return true;@@ -75,10 +77,8 @@ video_buffer_offer_decoded_frame(struct video_buffer *vb,while (!vb->rendering_frame_consumed && !vb->interrupted) {cond_wait(vb->rendering_frame_consumed_cond, vb->mutex);}- } else {- if (vb->fps_counter.started && !vb->rendering_frame_consumed) {- fps_counter_add_skipped_frame(&vb->fps_counter);- }+ } else if (!vb->rendering_frame_consumed) {+ fps_counter_add_skipped_frame(vb->fps_counter);}video_buffer_swap_frames(vb);@@ -93,9 +93,7 @@ const AVFrame *video_buffer_consume_rendered_frame(struct video_buffer *vb) {SDL_assert(!vb->rendering_frame_consumed);vb->rendering_frame_consumed = true;- if (vb->fps_counter.started) {- fps_counter_add_rendered_frame(&vb->fps_counter);- }+ fps_counter_add_rendered_frame(vb->fps_counter);if (vb->render_expired_frames) {// unblock video_buffer_offer_decoded_frame()cond_signal(vb->rendering_frame_consumed_cond);diff --git a/app/src/video_buffer.h b/app/src/video_buffer.hindex 9f328172..26a6fa1f 100644--- a/app/src/video_buffer.h+++ b/app/src/video_buffer.h@@ -17,11 +17,12 @@ struct video_buffer {bool interrupted;SDL_cond *rendering_frame_consumed_cond;bool rendering_frame_consumed;- struct fps_counter fps_counter;+ struct fps_counter *fps_counter;};bool-video_buffer_init(struct video_buffer *vb, bool render_expired_frames);+video_buffer_init(struct video_buffer *vb, struct fps_counter *fps_counter,+ bool render_expired_frames);voidvideo_buffer_destroy(struct video_buffer *vb);