Skip to content

Display and control your Android device

Extract sc_delay_buffer

Romain Vimontf410f2bdc468
diff --git a/app/meson.build b/app/meson.build
index e34f7cc1..7749d664 100644
--- a/app/meson.build
+++ b/app/meson.build
@@ -10,6 +10,7 @@ src = [
'src/control_msg.c',
'src/controller.c',
'src/decoder.c',
+ 'src/delay_buffer.c',
'src/demuxer.c',
'src/device_msg.c',
'src/icon.c',
diff --git a/app/src/delay_buffer.c b/app/src/delay_buffer.c
new file mode 100644
index 00000000..95d47c9c
--- /dev/null
+++ b/app/src/delay_buffer.c
@@ -0,0 +1,246 @@
+#include "delay_buffer.h"
+
+#include <assert.h>
+#include <stdlib.h>
+
+#include <libavutil/avutil.h>
+#include <libavformat/avformat.h>
+
+#include "util/log.h"
+
+#define SC_BUFFERING_NDEBUG // comment to debug
+
+static bool
+sc_delayed_frame_init(struct sc_delayed_frame *dframe, const AVFrame *frame) {
+ dframe->frame = av_frame_alloc();
+ if (!dframe->frame) {
+ LOG_OOM();
+ return false;
+ }
+
+ if (av_frame_ref(dframe->frame, frame)) {
+ LOG_OOM();
+ av_frame_free(&dframe->frame);
+ return false;
+ }
+
+ return true;
+}
+
+static void
+sc_delayed_frame_destroy(struct sc_delayed_frame *dframe) {
+ av_frame_unref(dframe->frame);
+ av_frame_free(&dframe->frame);
+}
+
+static bool
+sc_delay_buffer_offer(struct sc_delay_buffer *db, const AVFrame *frame) {
+ return db->cbs->on_new_frame(db, frame, db->cbs_userdata);
+}
+
+static int
+run_buffering(void *data) {
+ struct sc_delay_buffer *db = data;
+
+ assert(db->delay > 0);
+
+ for (;;) {
+ sc_mutex_lock(&db->b.mutex);
+
+ while (!db->b.stopped && sc_vecdeque_is_empty(&db->b.queue)) {
+ sc_cond_wait(&db->b.queue_cond, &db->b.mutex);
+ }
+
+ if (db->b.stopped) {
+ sc_mutex_unlock(&db->b.mutex);
+ goto stopped;
+ }
+
+ struct sc_delayed_frame dframe = sc_vecdeque_pop(&db->b.queue);
+
+ sc_tick max_deadline = sc_tick_now() + db->delay;
+ // PTS (written by the server) are expressed in microseconds
+ sc_tick pts = SC_TICK_FROM_US(dframe.frame->pts);
+
+ bool timed_out = false;
+ while (!db->b.stopped && !timed_out) {
+ sc_tick deadline = sc_clock_to_system_time(&db->b.clock, pts)
+ + db->delay;
+ if (deadline > max_deadline) {
+ deadline = max_deadline;
+ }
+
+ timed_out =
+ !sc_cond_timedwait(&db->b.wait_cond, &db->b.mutex, deadline);
+ }
+
+ bool stopped = db->b.stopped;
+ sc_mutex_unlock(&db->b.mutex);
+
+ if (stopped) {
+ sc_delayed_frame_destroy(&dframe);
+ goto stopped;
+ }
+
+#ifndef SC_BUFFERING_NDEBUG
+ LOGD("Buffering: %" PRItick ";%" PRItick ";%" PRItick,
+ pts, dframe.push_date, sc_tick_now());
+#endif
+
+ bool ok = sc_delay_buffer_offer(db, dframe.frame);
+ sc_delayed_frame_destroy(&dframe);
+ if (!ok) {
+ LOGE("Delayed frame could not be pushed, stopping");
+ sc_mutex_lock(&db->b.mutex);
+ // Prevent to push any new packet
+ db->b.stopped = true;
+ sc_mutex_unlock(&db->b.mutex);
+ goto stopped;
+ }
+ }
+
+stopped:
+ assert(db->b.stopped);
+
+ // Flush queue
+ while (!sc_vecdeque_is_empty(&db->b.queue)) {
+ struct sc_delayed_frame *dframe = sc_vecdeque_popref(&db->b.queue);
+ sc_delayed_frame_destroy(dframe);
+ }
+
+ LOGD("Buffering thread ended");
+
+ return 0;
+}
+
+bool
+sc_delay_buffer_init(struct sc_delay_buffer *db, sc_tick delay,
+ const struct sc_delay_buffer_callbacks *cbs,
+ void *cbs_userdata) {
+ assert(delay >= 0);
+
+ if (delay) {
+ bool ok = sc_mutex_init(&db->b.mutex);
+ if (!ok) {
+ return false;
+ }
+
+ ok = sc_cond_init(&db->b.queue_cond);
+ if (!ok) {
+ sc_mutex_destroy(&db->b.mutex);
+ return false;
+ }
+
+ ok = sc_cond_init(&db->b.wait_cond);
+ if (!ok) {
+ sc_cond_destroy(&db->b.queue_cond);
+ sc_mutex_destroy(&db->b.mutex);
+ return false;
+ }
+
+ sc_clock_init(&db->b.clock);
+ sc_vecdeque_init(&db->b.queue);
+ }
+
+ assert(cbs);
+ assert(cbs->on_new_frame);
+
+ db->delay = delay;
+ db->cbs = cbs;
+ db->cbs_userdata = cbs_userdata;
+
+ return true;
+}
+
+bool
+sc_delay_buffer_start(struct sc_delay_buffer *db) {
+ if (db->delay) {
+ bool ok =
+ sc_thread_create(&db->b.thread, run_buffering, "scrcpy-dbuf", db);
+ if (!ok) {
+ LOGE("Could not start buffering thread");
+ return false;
+ }
+ }
+
+ return true;
+}
+
+void
+sc_delay_buffer_stop(struct sc_delay_buffer *db) {
+ if (db->delay) {
+ sc_mutex_lock(&db->b.mutex);
+ db->b.stopped = true;
+ sc_cond_signal(&db->b.queue_cond);
+ sc_cond_signal(&db->b.wait_cond);
+ sc_mutex_unlock(&db->b.mutex);
+ }
+}
+
+void
+sc_delay_buffer_join(struct sc_delay_buffer *db) {
+ if (db->delay) {
+ sc_thread_join(&db->b.thread, NULL);
+ }
+}
+
+void
+sc_delay_buffer_destroy(struct sc_delay_buffer *db) {
+ if (db->delay) {
+ sc_cond_destroy(&db->b.wait_cond);
+ sc_cond_destroy(&db->b.queue_cond);
+ sc_mutex_destroy(&db->b.mutex);
+ }
+}
+
+bool
+sc_delay_buffer_push(struct sc_delay_buffer *db, const AVFrame *frame) {
+ if (!db->delay) {
+ // No buffering
+ return sc_delay_buffer_offer(db, frame);
+ }
+
+ sc_mutex_lock(&db->b.mutex);
+
+ if (db->b.stopped) {
+ sc_mutex_unlock(&db->b.mutex);
+ return false;
+ }
+
+ sc_tick pts = SC_TICK_FROM_US(frame->pts);
+ sc_clock_update(&db->b.clock, sc_tick_now(), pts);
+ sc_cond_signal(&db->b.wait_cond);
+
+ if (db->b.clock.count == 1) {
+ sc_mutex_unlock(&db->b.mutex);
+ // First frame, offer it immediately, for two reasons:
+ // - not to delay the opening of the scrcpy window
+ // - the buffering estimation needs at least two clock points, so it
+ // could not handle the first frame
+ return sc_delay_buffer_offer(db, frame);
+ }
+
+ struct sc_delayed_frame dframe;
+ bool ok = sc_delayed_frame_init(&dframe, frame);
+ if (!ok) {
+ sc_mutex_unlock(&db->b.mutex);
+ return false;
+ }
+
+#ifndef SC_BUFFERING_NDEBUG
+ dframe.push_date = sc_tick_now();
+#endif
+
+ ok = sc_vecdeque_push(&db->b.queue, dframe);
+ if (!ok) {
+ sc_mutex_unlock(&db->b.mutex);
+ LOG_OOM();
+ return false;
+ }
+
+ sc_cond_signal(&db->b.queue_cond);
+
+ sc_mutex_unlock(&db->b.mutex);
+
+ return true;
+}
diff --git a/app/src/delay_buffer.h b/app/src/delay_buffer.h
new file mode 100644
index 00000000..9e5347c7
--- /dev/null
+++ b/app/src/delay_buffer.h
@@ -0,0 +1,69 @@
+#ifndef SC_DELAY_BUFFER_H
+#define SC_DELAY_BUFFER_H
+
+#include "common.h"
+
+#include <stdbool.h>
+
+#include "clock.h"
+#include "util/thread.h"
+#include "util/tick.h"
+#include "util/vecdeque.h"
+
+// forward declarations
+typedef struct AVFrame AVFrame;
+
+struct sc_delayed_frame {
+ AVFrame *frame;
+#ifndef NDEBUG
+ sc_tick push_date;
+#endif
+};
+
+struct sc_delayed_frame_queue SC_VECDEQUE(struct sc_delayed_frame);
+
+struct sc_delay_buffer {
+ sc_tick delay;
+
+ // only if delay > 0
+ struct {
+ sc_thread thread;
+ sc_mutex mutex;
+ sc_cond queue_cond;
+ sc_cond wait_cond;
+
+ struct sc_clock clock;
+ struct sc_delayed_frame_queue queue;
+ bool stopped;
+ } b; // buffering
+
+ const struct sc_delay_buffer_callbacks *cbs;
+ void *cbs_userdata;
+};
+
+struct sc_delay_buffer_callbacks {
+ bool (*on_new_frame)(struct sc_delay_buffer *db, const AVFrame *frame,
+ void *userdata);
+};
+
+bool
+sc_delay_buffer_init(struct sc_delay_buffer *db, sc_tick delay,
+ const struct sc_delay_buffer_callbacks *cbs,
+ void *cbs_userdata);
+
+bool
+sc_delay_buffer_start(struct sc_delay_buffer *db);
+
+void
+sc_delay_buffer_stop(struct sc_delay_buffer *db);
+
+void
+sc_delay_buffer_join(struct sc_delay_buffer *db);
+
+void
+sc_delay_buffer_destroy(struct sc_delay_buffer *db);
+
+bool
+sc_delay_buffer_push(struct sc_delay_buffer *db, const AVFrame *frame);
+
+#endif
diff --git a/app/src/video_buffer.c b/app/src/video_buffer.c
index 74a4b042..da47a0b5 100644
--- a/app/src/video_buffer.c
+++ b/app/src/video_buffer.c
@@ -8,32 +8,13 @@
#include "util/log.h"
-#define SC_BUFFERING_NDEBUG // comment to debug
-
static bool
-sc_video_buffer_frame_init(struct sc_video_buffer_frame *vb_frame,
- const AVFrame *frame) {
- vb_frame->frame = av_frame_alloc();
- if (!vb_frame->frame) {
- return false;
- }
-
- if (av_frame_ref(vb_frame->frame, frame)) {
- av_frame_free(&vb_frame->frame);
- return false;
- }
-
- return true;
-}
+sc_delay_buffer_on_new_frame(struct sc_delay_buffer *db, const AVFrame *frame,
+ void *userdata) {
+ (void) db;
-static void
-sc_video_buffer_frame_destroy(struct sc_video_buffer_frame *vb_frame) {
- av_frame_unref(vb_frame->frame);
- av_frame_free(&vb_frame->frame);
-}
+ struct sc_video_buffer *vb = userdata;
-static bool
-sc_video_buffer_offer(struct sc_video_buffer *vb, const AVFrame *frame) {
bool previous_skipped;
bool ok = sc_frame_buffer_push(&vb->fb, frame, &previous_skipped);
if (!ok) {
@@ -43,83 +24,8 @@ sc_video_buffer_offer(struct sc_video_buffer *vb, const AVFrame *frame) {
return vb->cbs->on_new_frame(vb, previous_skipped, vb->cbs_userdata);
}
-static int
-run_buffering(void *data) {
- struct sc_video_buffer *vb = data;
-
- assert(vb->buffering_time > 0);
-
- for (;;) {
- sc_mutex_lock(&vb->b.mutex);
-
- while (!vb->b.stopped && sc_vecdeque_is_empty(&vb->b.queue)) {
- sc_cond_wait(&vb->b.queue_cond, &vb->b.mutex);
- }
-
- if (vb->b.stopped) {
- sc_mutex_unlock(&vb->b.mutex);
- goto stopped;
- }
-
- struct sc_video_buffer_frame vb_frame = sc_vecdeque_pop(&vb->b.queue);
-
- sc_tick max_deadline = sc_tick_now() + vb->buffering_time;
- // PTS (written by the server) are expressed in microseconds
- sc_tick pts = SC_TICK_FROM_US(vb_frame.frame->pts);
-
- bool timed_out = false;
- while (!vb->b.stopped && !timed_out) {
- sc_tick deadline = sc_clock_to_system_time(&vb->b.clock, pts)
- + vb->buffering_time;
- if (deadline > max_deadline) {
- deadline = max_deadline;
- }
-
- timed_out =
- !sc_cond_timedwait(&vb->b.wait_cond, &vb->b.mutex, deadline);
- }
-
- if (vb->b.stopped) {
- sc_video_buffer_frame_destroy(&vb_frame);
- sc_mutex_unlock(&vb->b.mutex);
- goto stopped;
- }
-
- sc_mutex_unlock(&vb->b.mutex);
-
-#ifndef SC_BUFFERING_NDEBUG
- LOGD("Buffering: %" PRItick ";%" PRItick ";%" PRItick,
- pts, vb_frame.push_date, sc_tick_now());
-#endif
-
- bool ok = sc_video_buffer_offer(vb, vb_frame.frame);
- sc_video_buffer_frame_destroy(&vb_frame);
- if (!ok) {
- LOGE("Delayed frame could not be pushed, stopping");
- sc_mutex_lock(&vb->b.mutex);
- // Prevent to push any new packet
- vb->b.stopped = true;
- sc_mutex_unlock(&vb->b.mutex);
- goto stopped;
- }
- }
-
-stopped:
- assert(vb->b.stopped);
-
- // Flush queue
- while (!sc_vecdeque_is_empty(&vb->b.queue)) {
- struct sc_video_buffer_frame *p = sc_vecdeque_popref(&vb->b.queue);
- sc_video_buffer_frame_destroy(p);
- }
-
- LOGD("Buffering thread ended");
-
- return 0;
-}
-
bool
-sc_video_buffer_init(struct sc_video_buffer *vb, sc_tick buffering_time,
+sc_video_buffer_init(struct sc_video_buffer *vb, sc_tick delay,
const struct sc_video_buffer_callbacks *cbs,
void *cbs_userdata) {
bool ok = sc_frame_buffer_init(&vb->fb);
@@ -127,135 +33,49 @@ sc_video_buffer_init(struct sc_video_buffer *vb, sc_tick buffering_time,
return false;
}
- assert(buffering_time >= 0);
- if (buffering_time) {
- ok = sc_mutex_init(&vb->b.mutex);
- if (!ok) {
- sc_frame_buffer_destroy(&vb->fb);
- return false;
- }
-
- ok = sc_cond_init(&vb->b.queue_cond);
- if (!ok) {
- sc_mutex_destroy(&vb->b.mutex);
- sc_frame_buffer_destroy(&vb->fb);
- return false;
- }
+ static const struct sc_delay_buffer_callbacks db_cbs = {
+ .on_new_frame = sc_delay_buffer_on_new_frame,
+ };
- ok = sc_cond_init(&vb->b.wait_cond);
- if (!ok) {
- sc_cond_destroy(&vb->b.queue_cond);
- sc_mutex_destroy(&vb->b.mutex);
- sc_frame_buffer_destroy(&vb->fb);
- return false;
- }
-
- sc_clock_init(&vb->b.clock);
- sc_vecdeque_init(&vb->b.queue);
+ ok = sc_delay_buffer_init(&vb->db, delay, &db_cbs, vb);
+ if (!ok) {
+ sc_frame_buffer_destroy(&vb->fb);
+ return false;
}
assert(cbs);
assert(cbs->on_new_frame);
- vb->buffering_time = buffering_time;
vb->cbs = cbs;
vb->cbs_userdata = cbs_userdata;
+
return true;
}
bool
sc_video_buffer_start(struct sc_video_buffer *vb) {
- if (vb->buffering_time) {
- bool ok =
- sc_thread_create(&vb->b.thread, run_buffering, "scrcpy-vbuf", vb);
- if (!ok) {
- LOGE("Could not start buffering thread");
- return false;
- }
- }
-
- return true;
+ return sc_delay_buffer_start(&vb->db);
}
void
sc_video_buffer_stop(struct sc_video_buffer *vb) {
- if (vb->buffering_time) {
- sc_mutex_lock(&vb->b.mutex);
- vb->b.stopped = true;
- sc_cond_signal(&vb->b.queue_cond);
- sc_cond_signal(&vb->b.wait_cond);
- sc_mutex_unlock(&vb->b.mutex);
- }
+ return sc_delay_buffer_stop(&vb->db);
}
void
sc_video_buffer_join(struct sc_video_buffer *vb) {
- if (vb->buffering_time) {
- sc_thread_join(&vb->b.thread, NULL);
- }
+ return sc_delay_buffer_join(&vb->db);
}
void
sc_video_buffer_destroy(struct sc_video_buffer *vb) {
sc_frame_buffer_destroy(&vb->fb);
- if (vb->buffering_time) {
- sc_cond_destroy(&vb->b.wait_cond);
- sc_cond_destroy(&vb->b.queue_cond);
- sc_mutex_destroy(&vb->b.mutex);
- }
+ sc_delay_buffer_destroy(&vb->db);
}
bool
sc_video_buffer_push(struct sc_video_buffer *vb, const AVFrame *frame) {
- if (!vb->buffering_time) {
- // No buffering
- return sc_video_buffer_offer(vb, frame);
- }
-
- sc_mutex_lock(&vb->b.mutex);
-
- if (vb->b.stopped) {
- sc_mutex_unlock(&vb->b.mutex);
- return false;
- }
-
- sc_tick pts = SC_TICK_FROM_US(frame->pts);
- sc_clock_update(&vb->b.clock, sc_tick_now(), pts);
- sc_cond_signal(&vb->b.wait_cond);
-
- if (vb->b.clock.count == 1) {
- sc_mutex_unlock(&vb->b.mutex);
- // First frame, offer it immediately, for two reasons:
- // - not to delay the opening of the scrcpy window
- // - the buffering estimation needs at least two clock points, so it
- // could not handle the first frame
- return sc_video_buffer_offer(vb, frame);
- }
-
- struct sc_video_buffer_frame vb_frame;
- bool ok = sc_video_buffer_frame_init(&vb_frame, frame);
- if (!ok) {
- sc_mutex_unlock(&vb->b.mutex);
- LOG_OOM();
- return false;
- }
-
-#ifndef SC_BUFFERING_NDEBUG
- vb_frame.push_date = sc_tick_now();
-#endif
-
- ok = sc_vecdeque_push(&vb->b.queue, vb_frame);
- if (!ok) {
- sc_mutex_unlock(&vb->b.mutex);
- LOG_OOM();
- return false;
- }
-
- sc_cond_signal(&vb->b.queue_cond);
-
- sc_mutex_unlock(&vb->b.mutex);
-
- return true;
+ return sc_delay_buffer_push(&vb->db, frame);
}
void
diff --git a/app/src/video_buffer.h b/app/src/video_buffer.h
index d183a484..ebca3915 100644
--- a/app/src/video_buffer.h
+++ b/app/src/video_buffer.h
@@ -5,41 +5,13 @@
#include <stdbool.h>
-#include "clock.h"
+#include "delay_buffer.h"
#include "frame_buffer.h"
-#include "util/thread.h"
-#include "util/tick.h"
-#include "util/vecdeque.h"
-
-// forward declarations
-typedef struct AVFrame AVFrame;
-
-struct sc_video_buffer_frame {
- AVFrame *frame;
-#ifndef NDEBUG
- sc_tick push_date;
-#endif
-};
-
-struct sc_video_buffer_frame_queue SC_VECDEQUE(struct sc_video_buffer_frame);
struct sc_video_buffer {
+ struct sc_delay_buffer db;
struct sc_frame_buffer fb;
- sc_tick buffering_time;
-
- // only if buffering_time > 0
- struct {
- sc_thread thread;
- sc_mutex mutex;
- sc_cond queue_cond;
- sc_cond wait_cond;
-
- struct sc_clock clock;
- struct sc_video_buffer_frame_queue queue;
- bool stopped;
- } b; // buffering
-
const struct sc_video_buffer_callbacks *cbs;
void *cbs_userdata;
};
@@ -50,7 +22,7 @@ struct sc_video_buffer_callbacks {
};
bool
-sc_video_buffer_init(struct sc_video_buffer *vb, sc_tick buffering_time,
+sc_video_buffer_init(struct sc_video_buffer *vb, sc_tick delay,
const struct sc_video_buffer_callbacks *cbs,
void *cbs_userdata);