X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Fsw_limits.c;h=1a9c4c58e123145d6ed2015e3eb2677d7084b053;hb=1e7468a8858768806a066f52d47d167a3721a8e4;hp=da98c66d7b8383eada5c0d25eff11973948989d8;hpb=580b94e4d762d21a018b3cf535fe8764c9cb1c6f;p=libsigrok.git diff --git a/src/sw_limits.c b/src/sw_limits.c index da98c66d..1a9c4c58 100644 --- a/src/sw_limits.c +++ b/src/sw_limits.c @@ -20,7 +20,6 @@ /** * @file * Software limits helper functions - * @internal */ #include @@ -31,6 +30,8 @@ #include #include "libsigrok-internal.h" +#define LOG_PREFIX "sw_limits" + /** * Initialize a software limit instance * @@ -42,8 +43,7 @@ */ SR_PRIV void sr_sw_limits_init(struct sr_sw_limits *limits) { - limits->limit_samples = 0; - limits->limit_msec = 0; + memset(limits, 0, sizeof(*limits)); } /** @@ -57,13 +57,16 @@ SR_PRIV void sr_sw_limits_init(struct sr_sw_limits *limits) * @param data config item data * @return SR_ERR_NA if @p key is not a supported limit, SR_OK otherwise */ -SR_PRIV int sr_sw_limits_config_get(struct sr_sw_limits *limits, uint32_t key, +SR_PRIV int sr_sw_limits_config_get(const struct sr_sw_limits *limits, uint32_t key, GVariant **data) { switch (key) { case SR_CONF_LIMIT_SAMPLES: *data = g_variant_new_uint64(limits->limit_samples); break; + case SR_CONF_LIMIT_FRAMES: + *data = g_variant_new_uint64(limits->limit_frames); + break; case SR_CONF_LIMIT_MSEC: *data = g_variant_new_uint64(limits->limit_msec / 1000); break; @@ -92,6 +95,9 @@ SR_PRIV int sr_sw_limits_config_set(struct sr_sw_limits *limits, uint32_t key, case SR_CONF_LIMIT_SAMPLES: limits->limit_samples = g_variant_get_uint64(data); break; + case SR_CONF_LIMIT_FRAMES: + limits->limit_frames = g_variant_get_uint64(data); + break; case SR_CONF_LIMIT_MSEC: limits->limit_msec = g_variant_get_uint64(data) * 1000; break; @@ -113,6 +119,7 @@ SR_PRIV int sr_sw_limits_config_set(struct sr_sw_limits *limits, uint32_t key, SR_PRIV void sr_sw_limits_acquisition_start(struct sr_sw_limits *limits) { limits->samples_read = 0; + limits->frames_read = 0; limits->start_time = g_get_monotonic_time(); } @@ -124,28 +131,123 @@ SR_PRIV void sr_sw_limits_acquisition_start(struct sr_sw_limits *limits) * * @param limits software limits instance * @returns TRUE if any of the software limits has been reached and the driver - * should stop data acquisition, otherwise FALSE. + * should stop data acquisition, otherwise FALSE. */ SR_PRIV gboolean sr_sw_limits_check(struct sr_sw_limits *limits) { if (limits->limit_samples) { - if (limits->samples_read >= limits->limit_samples) + if (limits->samples_read >= limits->limit_samples) { + sr_dbg("Requested number of samples (%" PRIu64 + ") reached.", limits->limit_samples); return TRUE; + } } - if (limits->limit_msec) { + if (limits->limit_frames) { + if (limits->frames_read >= limits->limit_frames) { + sr_dbg("Requested number of frames (%" PRIu64 + ") reached.", limits->limit_frames); + return TRUE; + } + } + + if (limits->limit_msec && limits->start_time) { guint64 now; now = g_get_monotonic_time(); if (now > limits->start_time && - now - limits->start_time > limits->limit_msec) + now - limits->start_time > limits->limit_msec) { + sr_dbg("Requested sampling time (%" PRIu64 + "ms) reached.", limits->limit_msec / 1000); return TRUE; + } } return FALSE; } /** - * Update the amount samples that have been read + * Get remaining counts until software limits are reached. + * + * This routine fills in those C language variables which callers + * requested, and provides the remaining value until a specified limit + * would be reached. + * + * The @ref sr_sw_limits_config_get() routine is suitable for rare + * configuration calls and interfaces nicely with Glib data types. The + * @ref sr_sw_limits_check() routine only provides a weak "exceeded" + * result. This @ref sr_sw_limits_get_remain() routine is suitable for + * additional checks and more eager limits enforcement in (potentially + * tight) acquisition code paths. Hardware compression may result in + * rather large "overshoots" when checks are done only late. + * + * @param[in] limits software limit instance + * @param[out] samples remaining samples count until the limit is reached + * @param[out] frames remaining frames count until the limit is reached + * @param[out] msecs remaining milliseconds until the limit is reached + * + * @return SR_ERR_* upon error, SR_OK otherwise + */ +SR_PRIV int sr_sw_limits_get_remain(const struct sr_sw_limits *limits, + uint64_t *samples, uint64_t *frames, uint64_t *msecs, + gboolean *exceeded) +{ + + if (!limits) + return SR_ERR_ARG; + + if (exceeded) + *exceeded = FALSE; + + if (samples) do { + *samples = 0; + if (!limits->limit_samples) + break; + if (limits->samples_read >= limits->limit_samples) { + if (exceeded) + *exceeded = TRUE; + break; + } + *samples = limits->limit_samples - limits->samples_read; + } while (0); + + if (frames) do { + *frames = 0; + if (!limits->limit_frames) + break; + if (limits->frames_read >= limits->limit_frames) { + if (exceeded) + *exceeded = TRUE; + break; + } + *frames = limits->limit_frames - limits->frames_read; + } while (0); + + if (msecs) do { + guint64 now, elapsed, remain; + + *msecs = 0; + if (!limits->limit_msec) + break; + if (!limits->start_time) + break; + now = g_get_monotonic_time(); + if (now < limits->start_time) + break; + elapsed = now - limits->start_time; + if (elapsed >= limits->limit_msec) { + if (exceeded) + *exceeded = TRUE; + break; + } + remain = limits->limit_msec - elapsed; + *msecs = remain / 1000; + } while (0); + + return SR_OK; +} + +/** + * Update the amount of samples that have been read * * Update the amount of samples that have been read in the current data * acquisition run. For each invocation @p samples_read will be accumulated and @@ -160,3 +262,20 @@ SR_PRIV void sr_sw_limits_update_samples_read(struct sr_sw_limits *limits, { limits->samples_read += samples_read; } + +/** + * Update the amount of frames that have been read + * + * Update the amount of frames that have been read in the current data + * acquisition run. For each invocation @p frames_read will be accumulated and + * once the configured frame limit has been reached sr_sw_limits_check() will + * return TRUE. + * + * @param limits software limits instance + * @param frames_read the amount of frames that have been read + */ +SR_PRIV void sr_sw_limits_update_frames_read(struct sr_sw_limits *limits, + uint64_t frames_read) +{ + limits->frames_read += frames_read; +}