output/srzip: decorate read pointer as const for awareness

[libsigrok.git] / src / output / srzip.c

diff --git a/src/output/srzip.c b/src/output/srzip.c
index fb6d5a392e979c9cd894e70693c01366c5429701..e3b57e3eeb16c3e03766a6de8125f3735f331712 100644 (file)
--- a/src/output/srzip.c
+++ b/src/output/srzip.c
@@ -61,7 +61,7 @@ static int init(struct sr_output *o, GHashTable *options)
                return SR_ERR_ARG;
        }
 
-       outc = g_malloc0(sizeof(struct out_context));
+       outc = g_malloc0(sizeof(*outc));
        outc->filename = g_strdup(o->filename);
        o->priv = outc;
 
@@ -158,7 +158,7 @@ static int zip_create(const struct sr_output *o)
        g_key_file_set_integer(meta, devgroup, "total analog", enabled_analog_channels);
 
        outc->analog_ch_count = enabled_analog_channels;
-       alloc_size = sizeof(gint) * outc->analog_ch_count;
+       alloc_size = sizeof(gint) * outc->analog_ch_count + 1;
        outc->analog_index_map = g_malloc0(alloc_size);
 
        index = 0;
@@ -197,6 +197,11 @@ static int zip_create(const struct sr_output *o)
         * archive update calls, and decouple the srzip output module
         * from implementation details in other acquisition device
         * drivers and input modules.
+        *
+        * Avoid allocating zero bytes, to not depend on platform
+        * specific malloc(0) return behaviour. Avoid division by zero,
+        * holding a local buffer won't harm when no data is seen later
+        * during execution. This simplifies other locations.
         */
        alloc_size = CHUNK_SIZE;
        outc->logic_buff.unit_size = logic_channels;
@@ -205,11 +210,12 @@ static int zip_create(const struct sr_output *o)
        outc->logic_buff.samples = g_try_malloc0(alloc_size);
        if (!outc->logic_buff.samples)
                return SR_ERR_MALLOC;
-       alloc_size /= outc->logic_buff.unit_size;
+       if (outc->logic_buff.unit_size)
+               alloc_size /= outc->logic_buff.unit_size;
        outc->logic_buff.alloc_size = alloc_size;
        outc->logic_buff.fill_size = 0;
 
-       alloc_size = sizeof(outc->analog_buff[0]) * outc->analog_ch_count;
+       alloc_size = sizeof(outc->analog_buff[0]) * outc->analog_ch_count + 1;
        outc->analog_buff = g_malloc0(alloc_size);
        for (index = 0; index < outc->analog_ch_count; index++) {
                alloc_size = CHUNK_SIZE;
@@ -390,25 +396,28 @@ static int zip_append(const struct sr_output *o,
  * @returns SR_OK et al error codes.
  */
 static int zip_append_queue(const struct sr_output *o,
-       uint8_t *buf, size_t unitsize, size_t length, gboolean flush)
+       const uint8_t *buf, size_t unitsize, size_t length, gboolean flush)
 {
        struct out_context *outc;
        struct logic_buff *buff;
        size_t send_size, remain, copy_size;
-       uint8_t *wrptr, *rdptr;
+       const uint8_t *rdptr;
+       uint8_t *wrptr;
        int ret;
 
        outc = o->priv;
        buff = &outc->logic_buff;
-       if (length && unitsize != buff->unit_size)
+       if (length && unitsize != buff->unit_size) {
+               sr_warn("Unexpected unit size, discarding logic data.");
                return SR_ERR_ARG;
+       }
 
        /*
         * Queue most recently received samples to the local buffer.
         * Flush to the ZIP archive when the buffer space is exhausted.
         */
        rdptr = buf;
-       send_size = length / buff->unit_size;
+       send_size = buff->unit_size ? length / buff->unit_size : 0;
        while (send_size) {
                remain = buff->alloc_size - buff->fill_size;
                if (remain) {