More fixes for Coverity issues

libs/spandsp/src/spandsp/private/super_tone_tx.h

@@ -28,7 +28,7 @@
 
 struct super_tone_tx_step_s
 {
-    tone_gen_tone_descriptor_t tone[4];
+    tone_gen_tone_descriptor_t tone[SUPER_TONE_TX_MAX_TONES];
     int tone_on;
     int length;
     int cycles;
@@ -38,12 +38,12 @@ struct super_tone_tx_step_s
 
 struct super_tone_tx_state_s
 {
-    tone_gen_tone_descriptor_t tone[4];
-    uint32_t phase[4];
+    tone_gen_tone_descriptor_t tone[SUPER_TONE_TX_MAX_TONES];
+    uint32_t phase[SUPER_TONE_TX_MAX_TONES];
     int current_position;
     int level;
-    super_tone_tx_step_t *levels[4];
-    int cycles[4];
+    super_tone_tx_step_t *levels[SUPER_TONE_TX_MAX_LEVELS];
+    int cycles[SUPER_TONE_TX_MAX_LEVELS];
 };
 
 #endif

libs/spandsp/src/spandsp/super_tone_tx.h

@@ -39,6 +39,9 @@ complex cadence patterns.
 
 */
 
+#define SUPER_TONE_TX_MAX_LEVELS    4
+#define SUPER_TONE_TX_MAX_TONES     4
+
 typedef struct super_tone_tx_step_s super_tone_tx_step_t;
 
 typedef struct super_tone_tx_state_s super_tone_tx_state_t;

libs/spandsp/src/spandsp/vector_int.h

@@ -49,6 +49,24 @@ static __inline__ void vec_copyi32(int32_t z[], const int32_t x[], int n)
 }
 /*- End of function --------------------------------------------------------*/
 
+static __inline__ void vec_movei(int z[], const int x[], int n)
+{
+    memmove(z, x, n*sizeof(z[0]));
+}
+/*- End of function --------------------------------------------------------*/
+
+static __inline__ void vec_movei16(int16_t z[], const int16_t x[], int n)
+{
+    memmove(z, x, n*sizeof(z[0]));
+}
+/*- End of function --------------------------------------------------------*/
+
+static __inline__ void vec_movei32(int32_t z[], const int32_t x[], int n)
+{
+    memmove(z, x, n*sizeof(z[0]));
+}
+/*- End of function --------------------------------------------------------*/
+
 static __inline__ void vec_zeroi(int z[], int n)
 {
     memset(z, 0, n*sizeof(z[0]));

libs/spandsp/src/super_tone_tx.c

@@ -170,7 +170,7 @@ SPAN_DECLARE(int) super_tone_tx(super_tone_tx_state_t *s, int16_t amp[], int max
     float xamp;
     super_tone_tx_step_t *tree;
 
-    if (s->level < 0  ||  s->level > 3)
+    if (s->level < 0  ||  s->level >= SUPER_TONE_TX_MAX_LEVELS)
         return 0;
     samples = 0;
     tree = s->levels[s->level];
@@ -182,7 +182,7 @@ SPAN_DECLARE(int) super_tone_tx(super_tone_tx_state_t *s, int16_t amp[], int max
             if (s->current_position == 0)
             {
                 /* New step - prepare the tone generator */
-                for (i = 0;  i < 4;  i++)
+                for (i = 0;  i < SUPER_TONE_TX_MAX_TONES;  i++)
                     s->tone[i] = tree->tone[i];
             }
             len = tree->length - s->current_position;
@@ -216,7 +216,7 @@ SPAN_DECLARE(int) super_tone_tx(super_tone_tx_state_t *s, int16_t amp[], int max
                 for (limit = len + samples;  samples < limit;  samples++)
                 {
                     xamp = 0.0f;
-                    for (i = 0;  i < 4;  i++)
+                    for (i = 0;  i < SUPER_TONE_TX_MAX_TONES;  i++)
                     {
                         if (s->tone[i].phase_rate == 0)
                             break;
@@ -251,9 +251,14 @@ SPAN_DECLARE(int) super_tone_tx(super_tone_tx_state_t *s, int16_t amp[], int max
         /* Nesting has priority... */
         if (tree->nest)
         {
-            tree = tree->nest;
-            s->levels[++s->level] = tree;
-            s->cycles[s->level] = tree->cycles;
+            if (s->level < SUPER_TONE_TX_MAX_LEVELS - 1)
+            {
+                /* TODO: We have stopped an over-range value being used, but we really
+                         ought to deal with the condition properly. */
+                tree = tree->nest;
+                s->levels[++s->level] = tree;
+                s->cycles[s->level] = tree->cycles;
+            }
         }
         else
         {

libs/spandsp/src/time_scale.c

@@ -52,8 +52,9 @@
 #include "spandsp/telephony.h"
 #include "spandsp/alloc.h"
 #include "spandsp/fast_convert.h"
-#include "spandsp/time_scale.h"
+#include "spandsp/vector_int.h"
 #include "spandsp/saturated.h"
+#include "spandsp/time_scale.h"
 
 #include "spandsp/private/time_scale.h"
 
@@ -190,46 +191,46 @@ SPAN_DECLARE(int) time_scale(time_scale_state_t *s, int16_t out[], int16_t in[],
     if (s->fill + len < s->buf_len)
     {
         /* Cannot continue without more samples */
-        memcpy(&s->buf[s->fill], in, sizeof(int16_t)*len);
+        vec_copyi16(&s->buf[s->fill], in, len);
         s->fill += len;
         return out_len;
     }
     k = s->buf_len - s->fill;
-    memcpy(&s->buf[s->fill], in, sizeof(int16_t)*k);
+    vec_copyi16(&s->buf[s->fill], in, k);
     in_len += k;
     s->fill = s->buf_len;
     while (s->fill == s->buf_len)
     {
         while (s->lcp >= s->buf_len)
         {
-            memcpy(&out[out_len], s->buf, sizeof(int16_t)*s->buf_len);
+            vec_copyi16(&out[out_len], s->buf, s->buf_len);
             out_len += s->buf_len;
             if (len - in_len < s->buf_len)
             {
                 /* Cannot continue without more samples */
-                memcpy(s->buf, &in[in_len], sizeof(int16_t)*(len - in_len));
+                vec_copyi16(s->buf, &in[in_len], len - in_len);
                 s->fill = len - in_len;
                 s->lcp -= s->buf_len;
                 return out_len;
             }
-            memcpy(s->buf, &in[in_len], sizeof(int16_t)*s->buf_len);
+            vec_copyi16(s->buf, &in[in_len], s->buf_len);
             in_len += s->buf_len;
             s->lcp -= s->buf_len;
         }
         if (s->lcp > 0)
         {
-            memcpy(&out[out_len], s->buf, sizeof(int16_t)*s->lcp);
+            vec_copyi16(&out[out_len], s->buf, s->lcp);
             out_len += s->lcp;
-            memmove(s->buf, &s->buf[s->lcp], sizeof(int16_t)*(s->buf_len - s->lcp));
+            vec_movei16(s->buf, &s->buf[s->lcp], s->buf_len - s->lcp);
             if (len - in_len < s->lcp)
             {
                 /* Cannot continue without more samples */
-                memcpy(&s->buf[s->buf_len - s->lcp], &in[in_len], sizeof(int16_t)*(len - in_len));
+                vec_copyi16(&s->buf[s->buf_len - s->lcp], &in[in_len], len - in_len);
                 s->fill = s->buf_len - s->lcp + len - in_len;
                 s->lcp = 0;
                 return out_len;
             }
-            memcpy(&s->buf[s->buf_len - s->lcp], &in[in_len], sizeof(int16_t)*s->lcp);
+            vec_copyi16(&s->buf[s->buf_len - s->lcp], &in[in_len], s->lcp);
             in_len += s->lcp;
             s->lcp = 0;
         }
@@ -259,21 +260,21 @@ SPAN_DECLARE(int) time_scale(time_scale_state_t *s, int16_t out[], int16_t in[],
             {
                 /* Speed up - drop a chunk of data */
                 overlap_add(s->buf, &s->buf[pitch], pitch);
-                memcpy(&s->buf[pitch], &s->buf[2*pitch], sizeof(int16_t)*(s->buf_len - 2*pitch));
+                vec_copyi16(&s->buf[pitch], &s->buf[2*pitch], s->buf_len - 2*pitch);
                 if (len - in_len < pitch)
                 {
                     /* Cannot continue without more samples */
-                    memcpy(&s->buf[s->buf_len - pitch], &in[in_len], sizeof(int16_t)*(len - in_len));
+                    vec_copyi16(&s->buf[s->buf_len - pitch], &in[in_len], len - in_len);
                     s->fill += (len - in_len - pitch);
                     return out_len;
                 }
-                memcpy(&s->buf[s->buf_len - pitch], &in[in_len], sizeof(int16_t)*pitch);
+                vec_copyi16(&s->buf[s->buf_len - pitch], &in[in_len], pitch);
                 in_len += pitch;
             }
             else
             {
                 /* Slow down - insert a chunk of data */
-                memcpy(&out[out_len], s->buf, sizeof(int16_t)*pitch);
+                vec_copyi16(&out[out_len], s->buf, pitch);
                 out_len += pitch;
                 overlap_add(&s->buf[pitch], s->buf, pitch);
             }

libs/spandsp/tests/t81_t82_arith_coding_tests.c

@@ -226,7 +226,7 @@ int main(int argc, char *argv[])
     }
     printf("Test passed\n");
     t81_t82_arith_encode_free(se);
-    t81_t82_arith_encode_free(sd);
+    t81_t82_arith_decode_free(sd);
     printf("Tests passed\n");
     return 0;
 }