mirror of https://github.com/Genymobile/scrcpy
clock_noslope
parent
2fff9b9edf
commit
0969f4eae7
@ -1,116 +1,34 @@
|
||||
#include "clock.h"
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "util/log.h"
|
||||
|
||||
#define SC_CLOCK_NDEBUG // comment to debug
|
||||
|
||||
void
|
||||
sc_clock_init(struct sc_clock *clock) {
|
||||
clock->count = 0;
|
||||
clock->head = 0;
|
||||
clock->left_sum.system = 0;
|
||||
clock->left_sum.stream = 0;
|
||||
clock->right_sum.system = 0;
|
||||
clock->right_sum.stream = 0;
|
||||
}
|
||||
|
||||
// Estimate the affine function f(stream) = slope * stream + offset
|
||||
static void
|
||||
sc_clock_estimate(struct sc_clock *clock,
|
||||
double *out_slope, sc_tick *out_offset) {
|
||||
assert(clock->count);
|
||||
|
||||
if (clock->count == 1) {
|
||||
// If there is only 1 point, we can't compute a slope. Assume it is 1.
|
||||
struct sc_clock_point *single_point = &clock->right_sum;
|
||||
*out_slope = 1;
|
||||
*out_offset = single_point->system - single_point->stream;
|
||||
return;
|
||||
}
|
||||
|
||||
struct sc_clock_point left_avg = {
|
||||
.system = clock->left_sum.system / (clock->count / 2),
|
||||
.stream = clock->left_sum.stream / (clock->count / 2),
|
||||
};
|
||||
struct sc_clock_point right_avg = {
|
||||
.system = clock->right_sum.system / ((clock->count + 1) / 2),
|
||||
.stream = clock->right_sum.stream / ((clock->count + 1) / 2),
|
||||
};
|
||||
|
||||
double slope = (double) (right_avg.system - left_avg.system)
|
||||
/ (right_avg.stream - left_avg.stream);
|
||||
|
||||
if (clock->count < SC_CLOCK_RANGE) {
|
||||
/* The first frames are typically received and decoded with more delay
|
||||
* than the others, causing a wrong slope estimation on start. To
|
||||
* compensate, assume an initial slope of 1, then progressively use the
|
||||
* estimated slope. */
|
||||
slope = (clock->count * slope + (SC_CLOCK_RANGE - clock->count))
|
||||
/ SC_CLOCK_RANGE;
|
||||
}
|
||||
|
||||
struct sc_clock_point global_avg = {
|
||||
.system = (clock->left_sum.system + clock->right_sum.system)
|
||||
/ clock->count,
|
||||
.stream = (clock->left_sum.stream + clock->right_sum.stream)
|
||||
/ clock->count,
|
||||
};
|
||||
|
||||
sc_tick offset = global_avg.system - (sc_tick) (global_avg.stream * slope);
|
||||
|
||||
*out_slope = slope;
|
||||
*out_offset = offset;
|
||||
clock->range = 0;
|
||||
clock->offset = 0;
|
||||
}
|
||||
|
||||
void
|
||||
sc_clock_update(struct sc_clock *clock, sc_tick system, sc_tick stream) {
|
||||
struct sc_clock_point *point = &clock->points[clock->head];
|
||||
|
||||
if (clock->count == SC_CLOCK_RANGE || clock->count & 1) {
|
||||
// One point passes from the right sum to the left sum
|
||||
|
||||
unsigned mid;
|
||||
if (clock->count == SC_CLOCK_RANGE) {
|
||||
mid = (clock->head + SC_CLOCK_RANGE / 2) % SC_CLOCK_RANGE;
|
||||
} else {
|
||||
// Only for the first frames
|
||||
mid = clock->count / 2;
|
||||
}
|
||||
|
||||
struct sc_clock_point *mid_point = &clock->points[mid];
|
||||
clock->left_sum.system += mid_point->system;
|
||||
clock->left_sum.stream += mid_point->stream;
|
||||
clock->right_sum.system -= mid_point->system;
|
||||
clock->right_sum.stream -= mid_point->stream;
|
||||
if (clock->range < SC_CLOCK_RANGE) {
|
||||
++clock->range;
|
||||
}
|
||||
|
||||
if (clock->count == SC_CLOCK_RANGE) {
|
||||
// The current point overwrites the previous value in the circular
|
||||
// array, update the left sum accordingly
|
||||
clock->left_sum.system -= point->system;
|
||||
clock->left_sum.stream -= point->stream;
|
||||
} else {
|
||||
++clock->count;
|
||||
}
|
||||
|
||||
point->system = system;
|
||||
point->stream = stream;
|
||||
|
||||
clock->right_sum.system += system;
|
||||
clock->right_sum.stream += stream;
|
||||
|
||||
clock->head = (clock->head + 1) % SC_CLOCK_RANGE;
|
||||
|
||||
// Update estimation
|
||||
sc_clock_estimate(clock, &clock->slope, &clock->offset);
|
||||
sc_tick offset = system - stream;
|
||||
clock->offset = ((clock->range - 1) * clock->offset + offset)
|
||||
/ clock->range;
|
||||
|
||||
#ifndef SC_CLOCK_NDEBUG
|
||||
LOGD("Clock estimation: %f * pts + %" PRItick, clock->slope, clock->offset);
|
||||
LOGD("Clock estimation: pts + %" PRItick, clock->offset);
|
||||
#endif
|
||||
}
|
||||
|
||||
sc_tick
|
||||
sc_clock_to_system_time(struct sc_clock *clock, sc_tick stream) {
|
||||
assert(clock->count); // sc_clock_update() must have been called
|
||||
return (sc_tick) (stream * clock->slope) + clock->offset;
|
||||
assert(clock->range); // sc_clock_update() must have been called
|
||||
return stream + clock->offset;
|
||||
}
|
||||
|
@ -1,79 +0,0 @@
|
||||
#include "common.h"
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "clock.h"
|
||||
|
||||
void test_small_rolling_sum(void) {
|
||||
struct sc_clock clock;
|
||||
sc_clock_init(&clock);
|
||||
|
||||
assert(clock.count == 0);
|
||||
assert(clock.left_sum.system == 0);
|
||||
assert(clock.left_sum.stream == 0);
|
||||
assert(clock.right_sum.system == 0);
|
||||
assert(clock.right_sum.stream == 0);
|
||||
|
||||
sc_clock_update(&clock, 2, 3);
|
||||
assert(clock.count == 1);
|
||||
assert(clock.left_sum.system == 0);
|
||||
assert(clock.left_sum.stream == 0);
|
||||
assert(clock.right_sum.system == 2);
|
||||
assert(clock.right_sum.stream == 3);
|
||||
|
||||
sc_clock_update(&clock, 10, 20);
|
||||
assert(clock.count == 2);
|
||||
assert(clock.left_sum.system == 2);
|
||||
assert(clock.left_sum.stream == 3);
|
||||
assert(clock.right_sum.system == 10);
|
||||
assert(clock.right_sum.stream == 20);
|
||||
|
||||
sc_clock_update(&clock, 40, 80);
|
||||
assert(clock.count == 3);
|
||||
assert(clock.left_sum.system == 2);
|
||||
assert(clock.left_sum.stream == 3);
|
||||
assert(clock.right_sum.system == 50);
|
||||
assert(clock.right_sum.stream == 100);
|
||||
|
||||
sc_clock_update(&clock, 400, 800);
|
||||
assert(clock.count == 4);
|
||||
assert(clock.left_sum.system == 12);
|
||||
assert(clock.left_sum.stream == 23);
|
||||
assert(clock.right_sum.system == 440);
|
||||
assert(clock.right_sum.stream == 880);
|
||||
}
|
||||
|
||||
void test_large_rolling_sum(void) {
|
||||
const unsigned half_range = SC_CLOCK_RANGE / 2;
|
||||
|
||||
struct sc_clock clock1;
|
||||
sc_clock_init(&clock1);
|
||||
for (unsigned i = 0; i < 5 * half_range; ++i) {
|
||||
sc_clock_update(&clock1, i, 2 * i + 1);
|
||||
}
|
||||
|
||||
struct sc_clock clock2;
|
||||
sc_clock_init(&clock2);
|
||||
for (unsigned i = 3 * half_range; i < 5 * half_range; ++i) {
|
||||
sc_clock_update(&clock2, i, 2 * i + 1);
|
||||
}
|
||||
|
||||
assert(clock1.count == SC_CLOCK_RANGE);
|
||||
assert(clock2.count == SC_CLOCK_RANGE);
|
||||
|
||||
// The values before the last SC_CLOCK_RANGE points in clock1 should have
|
||||
// no impact
|
||||
assert(clock1.left_sum.system == clock2.left_sum.system);
|
||||
assert(clock1.left_sum.stream == clock2.left_sum.stream);
|
||||
assert(clock1.right_sum.system == clock2.right_sum.system);
|
||||
assert(clock1.right_sum.stream == clock2.right_sum.stream);
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
(void) argc;
|
||||
(void) argv;
|
||||
|
||||
test_small_rolling_sum();
|
||||
test_large_rolling_sum();
|
||||
return 0;
|
||||
};
|
Loading…
Reference in New Issue