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

Simplify bytebuf naming

Browse source 
Rename read_available to can_read and write_available to can_write.
This is more readable.
This commit is contained in:
Romain Vimont 2023-03-11 10:16:43 +01:00
parent 14f9d82fda
commit e06acc1ba2
6 changed files with 47 additions and 47 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
app/src/audio_player.c
View file

@ -33,7 +33,7 @@ sc_audio_player_sdl_callback(void *userdata, uint8_t *stream, int len_int) {
LOGD("[Audio] SDL callback requests %" PRIu32 " samples", count);
#endif
uint32_t buffered_samples = sc_audiobuf_read_available(&ap->buf);
uint32_t buffered_samples = sc_audiobuf_can_read(&ap->buf);
if (!ap->played) {
// Part of the buffering is handled by inserting initial silence. The
// remaining (margin) last samples will be handled by compensation.
@ -126,20 +126,20 @@ sc_audio_player_frame_sink_push(struct sc_frame_sink *sink,
// Since this function is the only writer, the current available space is
// at least the previous available space. In practice, it should almost
// always be possible to write without lock.
bool lockless_write = samples_written <= ap->previous_write_avail;
bool lockless_write = samples_written <= ap->previous_can_write;
if (lockless_write) {
sc_audiobuf_prepare_write(&ap->buf, swr_buf, samples_written);
}
SDL_LockAudioDevice(ap->device);
uint32_t buffered_samples = sc_audiobuf_read_available(&ap->buf);
uint32_t buffered_samples = sc_audiobuf_can_read(&ap->buf);
if (lockless_write) {
sc_audiobuf_commit_write(&ap->buf, samples_written);
} else {
uint32_t write_avail = sc_audiobuf_write_available(&ap->buf);
if (samples_written > write_avail) {
uint32_t can_write = sc_audiobuf_can_write(&ap->buf);
if (samples_written > can_write) {
// Entering this branch is very unlikely, the audio buffer is
// allocated with a size sufficient to store 1 second more than the
// target buffering. If this happens, though, we have to skip old
@ -155,9 +155,9 @@ sc_audio_player_frame_sink_push(struct sc_frame_sink *sink,
samples_written = cap;
}
assert(samples_written >= write_avail);
if (samples_written > write_avail) {
uint32_t skip_samples = samples_written - write_avail;
assert(samples_written >= can_write);
if (samples_written > can_write) {
uint32_t skip_samples = samples_written - can_write;
assert(buffered_samples >= skip_samples);
sc_audiobuf_skip(&ap->buf, skip_samples);
buffered_samples -= skip_samples;
@ -169,14 +169,14 @@ sc_audio_player_frame_sink_push(struct sc_frame_sink *sink,
// It should remain exactly the expected size to write the new
// samples.
assert(sc_audiobuf_write_available(&ap->buf) == samples_written);
assert(sc_audiobuf_can_write(&ap->buf) == samples_written);
}
sc_audiobuf_write(&ap->buf, swr_buf, samples_written);
}
buffered_samples += samples_written;
assert(buffered_samples == sc_audiobuf_read_available(&ap->buf));
assert(buffered_samples == sc_audiobuf_can_read(&ap->buf));
// Read with lock held, to be used after unlocking
bool played = ap->played;
@ -221,7 +221,7 @@ sc_audio_player_frame_sink_push(struct sc_frame_sink *sink,
}
}
ap->previous_write_avail = sc_audiobuf_write_available(&ap->buf);
ap->previous_can_write = sc_audiobuf_can_write(&ap->buf);
ap->received = true;
SDL_UnlockAudioDevice(ap->device);
@ -349,7 +349,7 @@ sc_audio_player_frame_sink_open(struct sc_frame_sink *sink,
}
ap->swr_buf_alloc_size = initial_swr_buf_size;
ap->previous_write_avail = sc_audiobuf_write_available(&ap->buf);
ap->previous_can_write = sc_audiobuf_can_write(&ap->buf);
// Samples are produced and consumed by blocks, so the buffering must be
// smoothed to get a relatively stable value.

2
app/src/audio_player.h
View file

@ -33,7 +33,7 @@ struct sc_audio_player {
// The previous empty space in the buffer (only used by the receiver
// thread)
uint32_t previous_write_avail;
uint32_t previous_can_write;
// Resampler (only used from the receiver thread)
struct SwrContext *swr_ctx;

8
app/src/util/audiobuf.h
View file

@ -69,14 +69,14 @@ sc_audiobuf_commit_write(struct sc_audiobuf *buf, uint32_t samples) {
}
static inline uint32_t
sc_audiobuf_read_available(struct sc_audiobuf *buf) {
size_t bytes = sc_bytebuf_read_available(&buf->buf);
sc_audiobuf_can_read(struct sc_audiobuf *buf) {
size_t bytes = sc_bytebuf_can_read(&buf->buf);
return sc_audiobuf_to_samples(buf, bytes);
}
static inline uint32_t
sc_audiobuf_write_available(struct sc_audiobuf *buf) {
size_t bytes = sc_bytebuf_write_available(&buf->buf);
sc_audiobuf_can_write(struct sc_audiobuf *buf) {
size_t bytes = sc_bytebuf_can_write(&buf->buf);
return sc_audiobuf_to_samples(buf, bytes);
}

8
app/src/util/bytebuf.c
View file

@ -30,7 +30,7 @@ sc_bytebuf_destroy(struct sc_bytebuf *buf) {
void
sc_bytebuf_read(struct sc_bytebuf *buf, uint8_t *to, size_t len) {
assert(len);
assert(len <= sc_bytebuf_read_available(buf));
assert(len <= sc_bytebuf_can_read(buf));
assert(buf->tail != buf->head); // the buffer could not be empty
size_t right_limit = buf->tail < buf->head ? buf->head : buf->alloc_size;
@ -50,7 +50,7 @@ sc_bytebuf_read(struct sc_bytebuf *buf, uint8_t *to, size_t len) {
void
sc_bytebuf_skip(struct sc_bytebuf *buf, size_t len) {
assert(len);
assert(len <= sc_bytebuf_read_available(buf));
assert(len <= sc_bytebuf_can_read(buf));
assert(buf->tail != buf->head); // the buffer could not be empty
buf->tail = (buf->tail + len) % buf->alloc_size;
@ -78,7 +78,7 @@ sc_bytebuf_write_step1(struct sc_bytebuf *buf, size_t len) {
void
sc_bytebuf_write(struct sc_bytebuf *buf, const uint8_t *from, size_t len) {
assert(len);
assert(len <= sc_bytebuf_write_available(buf));
assert(len <= sc_bytebuf_can_write(buf));
sc_bytebuf_write_step0(buf, from, len);
sc_bytebuf_write_step1(buf, len);
@ -99,6 +99,6 @@ sc_bytebuf_prepare_write(struct sc_bytebuf *buf, const uint8_t *from,
void
sc_bytebuf_commit_write(struct sc_bytebuf *buf, size_t len) {
assert(len <= sc_bytebuf_write_available(buf));
assert(len <= sc_bytebuf_can_write(buf));
sc_bytebuf_write_step1(buf, len);
}

6
app/src/util/bytebuf.h
View file

@ -86,7 +86,7 @@ sc_bytebuf_commit_write(struct sc_bytebuf *buf, size_t len);
* It is an error to read more bytes than available.
*/
static inline size_t
sc_bytebuf_read_available(struct sc_bytebuf *buf) {
sc_bytebuf_can_read(struct sc_bytebuf *buf) {
return (buf->alloc_size + buf->head - buf->tail) % buf->alloc_size;
}
@ -96,12 +96,12 @@ sc_bytebuf_read_available(struct sc_bytebuf *buf) {
* It is an error to write more bytes than available.
*/
static inline size_t
sc_bytebuf_write_available(struct sc_bytebuf *buf) {
sc_bytebuf_can_write(struct sc_bytebuf *buf) {
return (buf->alloc_size + buf->tail - buf->head - 1) % buf->alloc_size;
}
/**
* Return the actual capacity of the buffer (read available + write available)
* Return the actual capacity of the buffer (can_read() + can_write())
*/
static inline size_t
sc_bytebuf_capacity(struct sc_bytebuf *buf) {

46
app/tests/test_bytebuf.c
View file

@ -13,23 +13,23 @@ void test_bytebuf_simple(void) {
assert(ok);
sc_bytebuf_write(&buf, (uint8_t *) "hello", sizeof("hello") - 1);
assert(sc_bytebuf_read_available(&buf) == 5);
assert(sc_bytebuf_can_read(&buf) == 5);
sc_bytebuf_read(&buf, data, 4);
assert(!strncmp((char *) data, "hell", 4));
sc_bytebuf_write(&buf, (uint8_t *) " world", sizeof(" world") - 1);
assert(sc_bytebuf_read_available(&buf) == 7);
assert(sc_bytebuf_can_read(&buf) == 7);
sc_bytebuf_write(&buf, (uint8_t *) "!", 1);
assert(sc_bytebuf_read_available(&buf) == 8);
assert(sc_bytebuf_can_read(&buf) == 8);
sc_bytebuf_read(&buf, &data[4], 8);
assert(sc_bytebuf_read_available(&buf) == 0);
assert(sc_bytebuf_can_read(&buf) == 0);
data[12] = '\0';
assert(!strcmp((char *) data, "hello world!"));
assert(sc_bytebuf_read_available(&buf) == 0);
assert(sc_bytebuf_can_read(&buf) == 0);
sc_bytebuf_destroy(&buf);
}
@ -42,31 +42,31 @@ void test_bytebuf_boundaries(void) {
assert(ok);
sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
assert(sc_bytebuf_read_available(&buf) == 6);
assert(sc_bytebuf_can_read(&buf) == 6);
sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
assert(sc_bytebuf_read_available(&buf) == 12);
assert(sc_bytebuf_can_read(&buf) == 12);
sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
assert(sc_bytebuf_read_available(&buf) == 18);
assert(sc_bytebuf_can_read(&buf) == 18);
sc_bytebuf_read(&buf, data, 9);
assert(!strncmp((char *) data, "hello hel", 9));
assert(sc_bytebuf_read_available(&buf) == 9);
assert(sc_bytebuf_can_read(&buf) == 9);
sc_bytebuf_write(&buf, (uint8_t *) "world", sizeof("world") - 1);
assert(sc_bytebuf_read_available(&buf) == 14);
assert(sc_bytebuf_can_read(&buf) == 14);
sc_bytebuf_write(&buf, (uint8_t *) "!", 1);
assert(sc_bytebuf_read_available(&buf) == 15);
assert(sc_bytebuf_can_read(&buf) == 15);
sc_bytebuf_skip(&buf, 3);
assert(sc_bytebuf_read_available(&buf) == 12);
assert(sc_bytebuf_can_read(&buf) == 12);
sc_bytebuf_read(&buf, data, 12);
data[12] = '\0';
assert(!strcmp((char *) data, "hello world!"));
assert(sc_bytebuf_read_available(&buf) == 0);
assert(sc_bytebuf_can_read(&buf) == 0);
sc_bytebuf_destroy(&buf);
}
@ -79,37 +79,37 @@ void test_bytebuf_two_steps_write(void) {
assert(ok);
sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
assert(sc_bytebuf_read_available(&buf) == 6);
assert(sc_bytebuf_can_read(&buf) == 6);
sc_bytebuf_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
assert(sc_bytebuf_read_available(&buf) == 12);
assert(sc_bytebuf_can_read(&buf) == 12);
sc_bytebuf_prepare_write(&buf, (uint8_t *) "hello ", sizeof("hello ") - 1);
assert(sc_bytebuf_read_available(&buf) == 12); // write not committed yet
assert(sc_bytebuf_can_read(&buf) == 12); // write not committed yet
sc_bytebuf_read(&buf, data, 9);
assert(!strncmp((char *) data, "hello hel", 3));
assert(sc_bytebuf_read_available(&buf) == 3);
assert(sc_bytebuf_can_read(&buf) == 3);
sc_bytebuf_commit_write(&buf, sizeof("hello ") - 1);
assert(sc_bytebuf_read_available(&buf) == 9);
assert(sc_bytebuf_can_read(&buf) == 9);
sc_bytebuf_prepare_write(&buf, (uint8_t *) "world", sizeof("world") - 1);
assert(sc_bytebuf_read_available(&buf) == 9); // write not committed yet
assert(sc_bytebuf_can_read(&buf) == 9); // write not committed yet
sc_bytebuf_commit_write(&buf, sizeof("world") - 1);
assert(sc_bytebuf_read_available(&buf) == 14);
assert(sc_bytebuf_can_read(&buf) == 14);
sc_bytebuf_write(&buf, (uint8_t *) "!", 1);
assert(sc_bytebuf_read_available(&buf) == 15);
assert(sc_bytebuf_can_read(&buf) == 15);
sc_bytebuf_skip(&buf, 3);
assert(sc_bytebuf_read_available(&buf) == 12);
assert(sc_bytebuf_can_read(&buf) == 12);
sc_bytebuf_read(&buf, data, 12);
data[12] = '\0';
assert(!strcmp((char *) data, "hello world!"));
assert(sc_bytebuf_read_available(&buf) == 0);
assert(sc_bytebuf_can_read(&buf) == 0);
sc_bytebuf_destroy(&buf);
}