From 3aea95d518b502e60d26f3f8100af2c20a9004ba Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Thu, 9 Oct 2008 20:45:03 +0200 Subject: Split latency paramters into "overall" and "immutable" latency --- src/common.c | 127 ++++++++++++++++++++++++++++++++++++++++++----------------- 1 file changed, 91 insertions(+), 36 deletions(-) (limited to 'src/common.c') diff --git a/src/common.c b/src/common.c index 5a50f9e..0a7093d 100644 --- a/src/common.c +++ b/src/common.c @@ -50,7 +50,8 @@ */ -#define DEFAULT_LATENCY_USEC (2000000ULL) /* 2s */ +#define DEFAULT_BUFFER_LATENCY_USEC (2000000ULL) /* 2s */ +#define DEFAULT_IMMUTABLE_LATENCY_USEC (500000ULL) /* 500ms */ #define DEFAULT_PROCESS_TIME_USEC (20000ULL) /* 20ms */ static int stream_alloc(sa_stream **_s) { @@ -180,27 +181,50 @@ fail: return ret; } -static int fix_latency(sa_stream *s, size_t *latency_nbytes, size_t *process_time_nbytes) { +static int fix_latency( + sa_stream *s, + size_t *buffer_latency_nbytes, + size_t *immutable_latency_nbytes, + size_t *process_time_nbytes) { sa_return_val_if_fail(s, SA_ERROR_INVALID); - sa_return_val_if_fail(latency_nbytes, SA_ERROR_INVALID); + sa_return_val_if_fail(buffer_latency_nbytes, SA_ERROR_INVALID); sa_return_val_if_fail(process_time_nbytes, SA_ERROR_INVALID); - if (*latency_nbytes <= 0) - *latency_nbytes = sa_stream_usec_to_bytes(s, DEFAULT_LATENCY_USEC, 0); + if (*buffer_latency_nbytes <= 0) + *buffer_latency_nbytes = sa_stream_usec_to_bytes(s, DEFAULT_BUFFER_LATENCY_USEC, 0); - if (*process_time_nbytes <= 0) { + if (immutable_latency_nbytes && *immutable_latency_nbytes <= 0) { size_t n, m; - n = sa_stream_frames_to_bytes(s, sa_stream_bytes_to_frames(s, *latency_nbytes, 1)/2); + n = sa_stream_frames_to_bytes(s, sa_stream_bytes_to_frames(s, *buffer_latency_nbytes, 0)/2); + m = sa_stream_usec_to_bytes(s, DEFAULT_IMMUTABLE_LATENCY_USEC, 0); + + *immutable_latency_nbytes = SA_MIN(n, m); + } + + if (*process_time_nbytes <= 0) { + size_t l, n, m; + + l = immutable_latency_nbytes ? *immutable_latency_nbytes : *buffer_latency_nbytes; + + n = sa_stream_frames_to_bytes(s, sa_stream_bytes_to_frames(s, l, 1)/2); m = sa_stream_usec_to_bytes(s, DEFAULT_PROCESS_TIME_USEC, 0); *process_time_nbytes = SA_MIN(n, m); } - sa_return_val_if_fail(*latency_nbytes > 0, SA_ERROR_INVALID); - sa_return_val_if_fail(*process_time_nbytes >= *latency_nbytes, SA_ERROR_INVALID); - sa_return_val_if_fail(sa_stream_frame_aligned(s, (int64_t) *latency_nbytes), SA_ERROR_INVALID); + if (immutable_latency_nbytes) { + sa_return_val_if_fail(*immutable_latency_nbytes > 0, SA_ERROR_INVALID); + sa_return_val_if_fail(*immutable_latency_nbytes <= *buffer_latency_nbytes, SA_ERROR_INVALID); + sa_return_val_if_fail(*process_time_nbytes <= *immutable_latency_nbytes, SA_ERROR_INVALID); + sa_return_val_if_fail(sa_stream_frame_aligned(s, (int64_t) *immutable_latency_nbytes), SA_ERROR_INVALID); + } + + sa_return_val_if_fail(*buffer_latency_nbytes > 0, SA_ERROR_INVALID); + sa_return_val_if_fail(*process_time_nbytes > 0, SA_ERROR_INVALID); + sa_return_val_if_fail(*process_time_nbytes <= *buffer_latency_nbytes, SA_ERROR_INVALID); + sa_return_val_if_fail(sa_stream_frame_aligned(s, (int64_t) *buffer_latency_nbytes), SA_ERROR_INVALID); sa_return_val_if_fail(sa_stream_frame_aligned(s, (int64_t) *process_time_nbytes), SA_ERROR_INVALID); return SA_SUCCESS; @@ -219,11 +243,11 @@ static int stream_open_unlocked(sa_stream *s) { return SA_SUCCESS; if (s->mode & SA_MODE_RDONLY) - if ((ret = fix_latency(s, &s->read_latency, &s->read_process_time)) < 0) + if ((ret = fix_latency(s, &s->read_overall_latency, NULL, &s->read_process_time)) < 0) return ret; if (s->mode & SA_MODE_WRONLY) - if ((ret = fix_latency(s, &s->write_latency, &s->write_process_time)) < 0) + if ((ret = fix_latency(s, &s->write_overall_latency, &s->write_immutable_latency, &s->write_process_time)) < 0) return ret; if ((ret = driver_open(s)) == SA_SUCCESS) @@ -276,22 +300,23 @@ int sa_stream_destroy(sa_stream *s) { return ret; } -int sa_stream_change_write_latency(sa_stream *s, size_t latency_nbytes, size_t process_time_nbytes) { +int sa_stream_change_write_latency(sa_stream *s, size_t overall_latency_nbytes, size_t immutable_latency_nbytes, size_t process_time_nbytes) { int ret; sa_return_val_if_fail(s, SA_ERROR_INVALID); sa_return_val_if_fail(s->mode & SA_MODE_WRONLY, SA_ERROR_STATE); - if ((ret = fix_latency(s, &latency_nbytes, &process_time_nbytes)) < 0) + if ((ret = fix_latency(s, &overall_latency_nbytes, &immutable_latency_nbytes, &process_time_nbytes)) < 0) return ret; sa_mutex_lock(s->mutex); sa_return_val_if_fail_unlock(s->state != SA_STATE_DEAD, SA_ERROR_STATE, s->mutex); - ret = s->state == SA_STATE_INIT ? SA_SUCCESS : driver_change_write_latency(s, &latency_nbytes, &process_time_nbytes); + ret = s->state == SA_STATE_INIT ? SA_SUCCESS : driver_change_write_latency(s, &overall_latency_nbytes, &immutable_latency_nbytes, &process_time_nbytes); if (ret == SA_SUCCESS) { - s->write_latency = latency_nbytes; + s->write_overall_latency = overall_latency_nbytes; + s->write_immutable_latency = immutable_latency_nbytes; s->write_process_time = process_time_nbytes; } @@ -300,22 +325,22 @@ int sa_stream_change_write_latency(sa_stream *s, size_t latency_nbytes, size_t p return ret; } -int sa_stream_change_read_latency(sa_stream *s, size_t latency_nbytes, size_t process_time_nbytes) { +int sa_stream_change_read_latency(sa_stream *s, size_t overall_latency_nbytes, size_t process_time_nbytes) { int ret; sa_return_val_if_fail(s, SA_ERROR_INVALID); sa_return_val_if_fail(s->mode & SA_MODE_RDONLY, SA_ERROR_STATE); - if ((ret = fix_latency(s, &latency_nbytes, &process_time_nbytes)) < 0) + if ((ret = fix_latency(s, &overall_latency_nbytes, NULL, &process_time_nbytes)) < 0) return ret; sa_mutex_lock(s->mutex); sa_return_val_if_fail_unlock(s->state != SA_STATE_DEAD, SA_ERROR_STATE, s->mutex); - ret = s->state == SA_STATE_INIT ? SA_SUCCESS : driver_change_read_latency(s, &latency_nbytes, &process_time_nbytes); + ret = s->state == SA_STATE_INIT ? SA_SUCCESS : driver_change_read_latency(s, &overall_latency_nbytes, &process_time_nbytes); if (ret == SA_SUCCESS) { - s->read_latency = latency_nbytes; + s->read_overall_latency = overall_latency_nbytes; s->read_process_time = process_time_nbytes; } @@ -748,8 +773,8 @@ int sa_stream_get_codec(sa_stream *s, char **codec) { return SA_SUCCESS; } -int sa_stream_get_write_latency(sa_stream *s, size_t *nbytes) { - size_t latency, process_time; +int sa_stream_get_write_overall_latency(sa_stream *s, size_t *nbytes) { + size_t overall_latency, immutable_latency, process_time; int ret; sa_return_val_if_fail(s, SA_ERROR_INVALID); @@ -758,16 +783,17 @@ int sa_stream_get_write_latency(sa_stream *s, size_t *nbytes) { sa_mutex_lock(s->mutex); - latency = s->write_latency; + overall_latency = s->write_overall_latency; + immutable_latency = s->write_immutable_latency; process_time = s->write_process_time; /* In case the latency is not fixated yet, we calculate what it * would be fixated to */ - if ((ret = fix_latency(s, &latency, &process_time)) < 0) + if ((ret = fix_latency(s, &overall_latency, &immutable_latency, &process_time)) < 0) goto fail; - *nbytes = latency; + *nbytes = overall_latency; ret = SA_SUCCESS; fail: @@ -775,8 +801,8 @@ fail: return ret; } -int sa_stream_get_read_latency(sa_stream *s, size_t *nbytes) { - size_t latency, process_time; +int sa_stream_get_read_overall_latency(sa_stream *s, size_t *nbytes) { + size_t overall_latency, process_time; int ret; sa_return_val_if_fail(s, SA_ERROR_INVALID); @@ -785,16 +811,44 @@ int sa_stream_get_read_latency(sa_stream *s, size_t *nbytes) { sa_mutex_lock(s->mutex); - latency = s->read_latency; + overall_latency = s->read_overall_latency; process_time = s->read_process_time; /* In case the latency is not fixated yet, we calculate what it * would be fixated to */ - if ((ret = fix_latency(s, &latency, &process_time)) < 0) + if ((ret = fix_latency(s, &overall_latency, NULL, &process_time)) < 0) + goto fail; + + *nbytes = overall_latency; + ret = SA_SUCCESS; + +fail: + sa_mutex_unlock(s->mutex); + return ret; +} + +int sa_stream_get_write_immutable_latency(sa_stream *s, size_t *nbytes) { + size_t overall_latency, immutable_latency, process_time; + int ret; + + sa_return_val_if_fail(s, SA_ERROR_INVALID); + sa_return_val_if_fail(nbytes, SA_ERROR_INVALID); + sa_return_val_if_fail(s->mode & SA_MODE_WRONLY, SA_ERROR_STATE); + + sa_mutex_lock(s->mutex); + + overall_latency = s->write_overall_latency; + immutable_latency = s->write_immutable_latency; + process_time = s->write_process_time; + + /* In case the latency is not fixated yet, we calculate what it + * would be fixated to */ + + if ((ret = fix_latency(s, &overall_latency, &immutable_latency, &process_time)) < 0) goto fail; - *nbytes = latency; + *nbytes = immutable_latency; ret = SA_SUCCESS; fail: @@ -803,7 +857,7 @@ fail: } int sa_stream_get_write_process_time(sa_stream *s, size_t *nbytes) { - size_t latency, process_time; + size_t overall_latency, immutable_latency, process_time; int ret; sa_return_val_if_fail(s, SA_ERROR_INVALID); @@ -812,13 +866,14 @@ int sa_stream_get_write_process_time(sa_stream *s, size_t *nbytes) { sa_mutex_lock(s->mutex); - latency = s->write_latency; + overall_latency = s->write_overall_latency; + immutable_latency = s->write_immutable_latency; process_time = s->write_process_time; /* In case the latency is not fixated yet, we calculate what it * would be fixated to */ - if ((ret = fix_latency(s, &latency, &process_time)) < 0) + if ((ret = fix_latency(s, &overall_latency, &immutable_latency, &process_time)) < 0) goto fail; *nbytes = process_time; @@ -830,7 +885,7 @@ fail: } int sa_stream_get_read_process_time(sa_stream *s, size_t *nbytes) { - size_t latency, process_time; + size_t overall_latency, process_time; int ret; sa_return_val_if_fail(s, SA_ERROR_INVALID); @@ -839,13 +894,13 @@ int sa_stream_get_read_process_time(sa_stream *s, size_t *nbytes) { sa_mutex_lock(s->mutex); - latency = s->read_latency; + overall_latency = s->read_overall_latency; process_time = s->read_process_time; /* In case the latency is not fixated yet, we calculate what it * would be fixated to */ - if ((ret = fix_latency(s, &latency, &process_time)) < 0) + if ((ret = fix_latency(s, &overall_latency, NULL, &process_time)) < 0) goto fail; *nbytes = process_time; -- cgit