updated protoview

applications/plugins/protoview/raw_samples.c

@@ -0,0 +1,96 @@
+/* Copyright (C) 2022-2023 Salvatore Sanfilippo -- All Rights Reserved
+ * See the LICENSE file for information about the license. */
+
+#include <inttypes.h>
+#include <furi/core/string.h>
+#include <furi.h>
+#include <furi_hal.h>
+#include "raw_samples.h"
+
+/* Allocate and initialize a samples buffer. */
+RawSamplesBuffer *raw_samples_alloc(void) {
+    RawSamplesBuffer *buf = malloc(sizeof(*buf));
+    buf->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    raw_samples_reset(buf);
+    return buf;
+}
+
+/* Free a sample buffer. Should be called when the mutex is released. */
+void raw_samples_free(RawSamplesBuffer *s) {
+    furi_mutex_free(s->mutex);
+    free(s);
+}
+
+/* This just set all the samples to zero and also resets the internal
+ * index. There is no need to call it after raw_samples_alloc(), but only
+ * when one wants to reset the whole buffer of samples. */
+void raw_samples_reset(RawSamplesBuffer *s) {
+    furi_mutex_acquire(s->mutex,FuriWaitForever);
+    s->total = RAW_SAMPLES_NUM;
+    s->idx = 0;
+    s->short_pulse_dur = 0;
+    memset(s->samples,0,sizeof(s->samples));
+    furi_mutex_release(s->mutex);
+}
+
+/* Set the raw sample internal index so that what is currently at
+ * offset 'offset', will appear to be at 0 index. */
+void raw_samples_center(RawSamplesBuffer *s, uint32_t offset) {
+    s->idx = (s->idx+offset) % RAW_SAMPLES_NUM;
+}
+
+/* Add the specified sample in the circular buffer. */
+void raw_samples_add(RawSamplesBuffer *s, bool level, uint32_t dur) {
+    furi_mutex_acquire(s->mutex,FuriWaitForever);
+    s->samples[s->idx].level = level;
+    s->samples[s->idx].dur = dur;
+    s->idx = (s->idx+1) % RAW_SAMPLES_NUM;
+    furi_mutex_release(s->mutex);
+}
+
+/* This is like raw_samples_add(), however in case a sample of the
+ * same level of the previous one is added, the duration of the last
+ * sample is updated instead. Needed mainly for the decoders build_message()
+ * methods: it is simpler to write an encoder of a signal like that,
+ * just creating messages piece by piece.
+ *
+ * This function is a bit slower so the internal data sampling should
+ * be performed with raw_samples_add(). */
+void raw_samples_add_or_update(RawSamplesBuffer *s, bool level, uint32_t dur) {
+    furi_mutex_acquire(s->mutex,FuriWaitForever);
+    uint32_t previdx = (s->idx-1) % RAW_SAMPLES_NUM;
+    if (s->samples[previdx].level == level &&
+        s->samples[previdx].dur != 0)
+    {
+        /* Update the last sample: it has the same level. */
+        s->samples[previdx].dur += dur;
+    } else {
+        /* Add a new sample. */
+        s->samples[s->idx].level = level;
+        s->samples[s->idx].dur = dur;
+        s->idx = (s->idx+1) % RAW_SAMPLES_NUM;
+    }
+    furi_mutex_release(s->mutex);
+}
+
+/* Get the sample from the buffer. It is possible to use out of range indexes
+ * as 'idx' because the modulo operation will rewind back from the start. */
+void raw_samples_get(RawSamplesBuffer *s, uint32_t idx, bool *level, uint32_t *dur)
+{
+    furi_mutex_acquire(s->mutex,FuriWaitForever);
+    idx = (s->idx + idx) % RAW_SAMPLES_NUM;
+    *level = s->samples[idx].level;
+    *dur = s->samples[idx].dur;
+    furi_mutex_release(s->mutex);
+}
+
+/* Copy one buffer to the other, including current index. */
+void raw_samples_copy(RawSamplesBuffer *dst, RawSamplesBuffer *src) {
+    furi_mutex_acquire(src->mutex,FuriWaitForever);
+    furi_mutex_acquire(dst->mutex,FuriWaitForever);
+    dst->idx = src->idx;
+    dst->short_pulse_dur = src->short_pulse_dur;
+    memcpy(dst->samples,src->samples,sizeof(dst->samples));
+    furi_mutex_release(src->mutex);
+    furi_mutex_release(dst->mutex);
+}