device: introduce common helpers for channel group allocation

[libsigrok.git] / src / sw_limits.c

diff --git a/src/sw_limits.c b/src/sw_limits.c
index 37c28667987df4f643e584466ae0b3e3eb15453f..1a9c4c58e123145d6ed2015e3eb2677d7084b053 100644 (file)
--- a/src/sw_limits.c
+++ b/src/sw_limits.c
@@ -43,9 +43,7 @@
  */
 SR_PRIV void sr_sw_limits_init(struct sr_sw_limits *limits)
 {
-       limits->limit_samples = 0;
-       limits->limit_frames = 0;
-       limits->limit_msec = 0;
+       memset(limits, 0, sizeof(*limits));
 }
 
 /**
@@ -59,7 +57,7 @@ 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) {
@@ -153,7 +151,7 @@ SR_PRIV gboolean sr_sw_limits_check(struct sr_sw_limits *limits)
                }
        }
 
-       if (limits->limit_msec) {
+       if (limits->limit_msec && limits->start_time) {
                guint64 now;
                now = g_get_monotonic_time();
                if (now > limits->start_time &&
@@ -167,6 +165,87 @@ SR_PRIV gboolean sr_sw_limits_check(struct sr_sw_limits *limits)
        return FALSE;
 }
 
+/**
+ * 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
  *