Using OPUS_ macros for <string.h> operations

Removes a bunch of system #include <...> in the process

10 files changed, 78 insertions, 82 deletions

diff --git a/libcelt/celt.c b/libcelt/celt.c
index dce42ec3..d5abb8a8 100644
--- a/libcelt/celt.c
+++ b/libcelt/celt.c
@@ -115,6 +115,7 @@ static int resampling_factor(opus_int32 rate)
       break;
    default:
       ret = 0;
+      break;
    }
    return ret;
 }
@@ -248,7 +249,7 @@ CELTEncoder *celt_encoder_init_custom(CELTEncoder *st, const CELTMode *mode, int
       return NULL;
    }
 
-   CELT_MEMSET((char*)st, 0, celt_encoder_get_size_custom(mode, channels));
+   OPUS_CLEAR((char*)st, celt_encoder_get_size_custom(mode, channels));
 
    st->mode = mode;
    st->overlap = mode->overlap;
@@ -440,7 +441,7 @@ static void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig *X
          B = shortBlocks;
       }
       /* Prevents problems from the imdct doing the overlap-add */
-      CELT_MEMSET(x, 0, overlap);
+      OPUS_CLEAR(x, overlap);
 
       for (b=0;b<B;b++)
       {
@@ -1084,8 +1085,8 @@ int celt_encode_with_ec(CELTEncoder * restrict st, const opus_val16 * pcm, int f
             silence = silence && *inp == 0;
             inp++;
          }
-         CELT_COPY(pre[c], prefilter_mem+c*COMBFILTER_MAXPERIOD, COMBFILTER_MAXPERIOD);
-         CELT_COPY(pre[c]+COMBFILTER_MAXPERIOD, in+c*(N+st->overlap)+st->overlap, N);
+         OPUS_COPY(pre[c], prefilter_mem+c*COMBFILTER_MAXPERIOD, COMBFILTER_MAXPERIOD);
+         OPUS_COPY(pre[c]+COMBFILTER_MAXPERIOD, in+c*(N+st->overlap)+st->overlap, N);
       } while (++c<CC);
 
 #ifdef FUZZING
@@ -1194,7 +1195,7 @@ int celt_encode_with_ec(CELTEncoder * restrict st, const opus_val16 * pcm, int f
       c=0; do {
          int offset = st->mode->shortMdctSize-st->mode->overlap;
          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
-         CELT_COPY(in+c*(N+st->overlap), st->in_mem+c*(st->overlap), st->overlap);
+         OPUS_COPY(in+c*(N+st->overlap), st->in_mem+c*(st->overlap), st->overlap);
          if (offset)
             comb_filter(in+c*(N+st->overlap)+st->overlap, pre[c]+COMBFILTER_MAXPERIOD,
                   st->prefilter_period, st->prefilter_period, offset, -st->prefilter_gain, -st->prefilter_gain,
@@ -1203,14 +1204,14 @@ int celt_encode_with_ec(CELTEncoder * restrict st, const opus_val16 * pcm, int f
          comb_filter(in+c*(N+st->overlap)+st->overlap+offset, pre[c]+COMBFILTER_MAXPERIOD+offset,
                st->prefilter_period, pitch_index, N-offset, -st->prefilter_gain, -gain1,
                st->prefilter_tapset, prefilter_tapset, st->mode->window, st->mode->overlap);
-         CELT_COPY(st->in_mem+c*(st->overlap), in+c*(N+st->overlap)+N, st->overlap);
+         OPUS_COPY(st->in_mem+c*(st->overlap), in+c*(N+st->overlap)+N, st->overlap);
 
          if (N>COMBFILTER_MAXPERIOD)
          {
-            CELT_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, pre[c]+N, COMBFILTER_MAXPERIOD);
+            OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, pre[c]+N, COMBFILTER_MAXPERIOD);
          } else {
-            CELT_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, prefilter_mem+c*COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD-N);
-            CELT_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD+COMBFILTER_MAXPERIOD-N, pre[c]+COMBFILTER_MAXPERIOD, N);
+            OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, prefilter_mem+c*COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD-N);
+            OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD+COMBFILTER_MAXPERIOD-N, pre[c]+COMBFILTER_MAXPERIOD, N);
          }
       } while (++c<CC);
 
@@ -1559,9 +1560,9 @@ int celt_encode_with_ec(CELTEncoder * restrict st, const opus_val16 * pcm, int f
       /* Synthesis */
       denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
 
-      CELT_MOVE(st->syn_mem[0], st->syn_mem[0]+N, MAX_PERIOD);
+      OPUS_MOVE(st->syn_mem[0], st->syn_mem[0]+N, MAX_PERIOD);
       if (CC==2)
-         CELT_MOVE(st->syn_mem[1], st->syn_mem[1]+N, MAX_PERIOD);
+         OPUS_MOVE(st->syn_mem[1], st->syn_mem[1]+N, MAX_PERIOD);
 
       c=0; do
          for (i=0;i<M*st->mode->eBands[st->start];i++)
@@ -1809,7 +1810,7 @@ int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
       break;
       case CELT_RESET_STATE:
       {
-         CELT_MEMSET((char*)&st->ENCODER_RESET_START, 0,
+         OPUS_CLEAR((char*)&st->ENCODER_RESET_START,
                celt_encoder_get_size_custom(st->mode, st->channels)-
                ((char*)&st->ENCODER_RESET_START - (char*)st));
          st->vbr_offset = 0;
@@ -1972,7 +1973,7 @@ CELTDecoder *celt_decoder_init_custom(CELTDecoder *st, const CELTMode *mode, int
       return NULL;
    }
 
-   CELT_MEMSET((char*)st, 0, celt_decoder_get_size_custom(mode, channels));
+   OPUS_CLEAR((char*)st, celt_decoder_get_size_custom(mode, channels));
 
    st->mode = mode;
    st->overlap = mode->overlap;
@@ -2519,9 +2520,9 @@ int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, in
    /* Synthesis */
    denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
 
-   CELT_MOVE(decode_mem[0], decode_mem[0]+N, DECODE_BUFFER_SIZE-N);
+   OPUS_MOVE(decode_mem[0], decode_mem[0]+N, DECODE_BUFFER_SIZE-N);
    if (CC==2)
-      CELT_MOVE(decode_mem[1], decode_mem[1]+N, DECODE_BUFFER_SIZE-N);
+      OPUS_MOVE(decode_mem[1], decode_mem[1]+N, DECODE_BUFFER_SIZE-N);
 
    c=0; do
       for (i=0;i<M*st->mode->eBands[st->start];i++)
@@ -2730,7 +2731,7 @@ int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
       break;
       case CELT_RESET_STATE:
       {
-         CELT_MEMSET((char*)&st->DECODER_RESET_START, 0,
+         OPUS_CLEAR((char*)&st->DECODER_RESET_START,
                celt_decoder_get_size_custom(st->mode, st->channels)-
                ((char*)&st->DECODER_RESET_START - (char*)st));
       }
diff --git a/libcelt/cwrs.c b/libcelt/cwrs.c
index 4adf428d..38051655 100644
--- a/libcelt/cwrs.c
+++ b/libcelt/cwrs.c
@@ -32,8 +32,6 @@
 #endif
 
 #include "os_support.h"
-#include <stdlib.h>
-#include <string.h>
 #include "cwrs.h"
 #include "mathops.h"
 #include "arch.h"
@@ -616,7 +614,8 @@ void encode_pulses(const int *_y,int _n,int _k,ec_enc *_enc){
       ec_enc_uint(_enc,i,nc);
       RESTORE_STACK;
 #ifndef SMALL_FOOTPRINT
-    };
+    }
+    break;
   }
 #endif
 }
@@ -629,7 +628,7 @@ void decode_pulses(int *_y,int _n,int _k,ec_dec *_dec)
     case 2:cwrsi2(_k,ec_dec_uint(_dec,ncwrs2(_k)),_y);break;
     case 3:cwrsi3(_k,ec_dec_uint(_dec,ncwrs3(_k)),_y);break;
     case 4:cwrsi4(_k,ec_dec_uint(_dec,ncwrs4(_k)),_y);break;
-      default:
+    default:
     {
 #endif
       VARDECL(opus_uint32,u);
@@ -639,6 +638,7 @@ void decode_pulses(int *_y,int _n,int _k,ec_dec *_dec)
       RESTORE_STACK;
 #ifndef SMALL_FOOTPRINT
     }
+    break;
   }
 #endif
 }
diff --git a/libcelt/entenc.c b/libcelt/entenc.c
index 62462edb..68aee104 100644
--- a/libcelt/entenc.c
+++ b/libcelt/entenc.c
@@ -235,7 +235,7 @@ void ec_enc_patch_initial_bits(ec_enc *_this,unsigned _val,unsigned _nbits){
 
 void ec_enc_shrink(ec_enc *_this,opus_uint32 _size){
   celt_assert(_this->offs+_this->end_offs<=_size);
-  CELT_MOVE(_this->buf+_size-_this->end_offs,
+  OPUS_MOVE(_this->buf+_size-_this->end_offs,
    _this->buf+_this->storage-_this->end_offs,_this->end_offs);
   _this->storage=_size;
 }
@@ -273,7 +273,7 @@ void ec_enc_done(ec_enc *_this){
   }
   /*Clear any excess space and add any remaining extra bits to the last byte.*/
   if(!_this->error){
-    CELT_MEMSET(_this->buf+_this->offs,0,
+    OPUS_CLEAR(_this->buf+_this->offs,
      _this->storage-_this->offs-_this->end_offs);
     if(used>0){
       /*If there's no range coder data at all, give up.*/
diff --git a/libcelt/os_support.h b/libcelt/os_support.h
index ad76a26f..2484f0b2 100644
--- a/libcelt/os_support.h
+++ b/libcelt/os_support.h
@@ -40,7 +40,7 @@
 #include <stdlib.h>
 
 /** Opus wrapper for malloc(). To do your own dynamic allocation, all you need to do is replace this function and opus_free */
-#ifndef OVERRIDE_CELT_ALLOC
+#ifndef OVERRIDE_OPUS_ALLOC
 static inline void *opus_alloc (size_t size)
 {
    return malloc(size);
@@ -48,7 +48,7 @@ static inline void *opus_alloc (size_t size)
 #endif
 
 /** Same as celt_alloc(), except that the area is only needed inside a CELT call (might cause problem with wideband though) */
-#ifndef OVERRIDE_CELT_ALLOC_SCRATCH
+#ifndef OVERRIDE_OPUS_ALLOC_SCRATCH
 static inline void *opus_alloc_scratch (size_t size)
 {
    /* Scratch space doesn't need to be cleared */
@@ -57,7 +57,7 @@ static inline void *opus_alloc_scratch (size_t size)
 #endif
 
 /** Opus wrapper for free(). To do your own dynamic allocation, all you need to do is replace this function and opus_alloc */
-#ifndef OVERRIDE_CELT_FREE
+#ifndef OVERRIDE_OPUS_FREE
 static inline void opus_free (void *ptr)
 {
    free(ptr);
@@ -65,19 +65,19 @@ static inline void opus_free (void *ptr)
 #endif
 
 /** Copy n bytes of memory from src to dst. The 0* term provides compile-time type checking  */
-#ifndef OVERRIDE_CELT_COPY
-#define CELT_COPY(dst, src, n) (memcpy((dst), (src), (n)*sizeof(*(dst)) + 0*((dst)-(src)) ))
+#ifndef OVERRIDE_OPUS_COPY
+#define OPUS_COPY(dst, src, n) (memcpy((dst), (src), (n)*sizeof(*(dst)) + 0*((dst)-(src)) ))
 #endif
 
 /** Copy n bytes of memory from src to dst, allowing overlapping regions. The 0* term
     provides compile-time type checking */
-#ifndef OVERRIDE_CELT_MOVE
-#define CELT_MOVE(dst, src, n) (memmove((dst), (src), (n)*sizeof(*(dst)) + 0*((dst)-(src)) ))
+#ifndef OVERRIDE_OPUS_MOVE
+#define OPUS_MOVE(dst, src, n) (memmove((dst), (src), (n)*sizeof(*(dst)) + 0*((dst)-(src)) ))
 #endif
 
-/** Set n bytes of memory to value of c, starting at address s */
-#ifndef OVERRIDE_CELT_MEMSET
-#define CELT_MEMSET(dst, c, n) (memset((dst), (c), (n)*sizeof(*(dst))))
+/** Set n elements of dst to zero, starting at address s */
+#ifndef OVERRIDE_OPUS_CLEAR
+#define OPUS_CLEAR(dst, n) (memset((dst), 0, (n)*sizeof(*(dst))))
 #endif
 
 /*#ifdef __GNUC__
diff --git a/libcelt/quant_bands.c b/libcelt/quant_bands.c
index 2e7e14d9..9a14314c 100644
--- a/libcelt/quant_bands.c
+++ b/libcelt/quant_bands.c
@@ -295,7 +295,7 @@ void quant_coarse_energy(const CELTMode *m, int start, int end, int effEnd,
 
    ALLOC(oldEBands_intra, C*m->nbEBands, opus_val16);
    ALLOC(error_intra, C*m->nbEBands, opus_val16);
-   CELT_COPY(oldEBands_intra, oldEBands, C*m->nbEBands);
+   OPUS_COPY(oldEBands_intra, oldEBands, C*m->nbEBands);
 
    if (two_pass || intra)
    {
@@ -320,7 +320,7 @@ void quant_coarse_energy(const CELTMode *m, int start, int end, int effEnd,
       nintra_bytes = ec_range_bytes(&enc_intra_state);
       ALLOC(intra_bits, nintra_bytes-nstart_bytes, unsigned char);
       /* Copy bits from intra bit-stream */
-      CELT_COPY(intra_bits,
+      OPUS_COPY(intra_bits,
             ec_get_buffer(&enc_intra_state) + nstart_bytes,
             nintra_bytes - nstart_bytes);
 
@@ -333,15 +333,15 @@ void quant_coarse_energy(const CELTMode *m, int start, int end, int effEnd,
       {
          *enc = enc_intra_state;
          /* Copy intra bits to bit-stream */
-         CELT_COPY(ec_get_buffer(&enc_intra_state) + nstart_bytes,
+         OPUS_COPY(ec_get_buffer(&enc_intra_state) + nstart_bytes,
                intra_bits, nintra_bytes - nstart_bytes);
-         CELT_COPY(oldEBands, oldEBands_intra, C*m->nbEBands);
-         CELT_COPY(error, error_intra, C*m->nbEBands);
+         OPUS_COPY(oldEBands, oldEBands_intra, C*m->nbEBands);
+         OPUS_COPY(error, error_intra, C*m->nbEBands);
          intra = 1;
       }
    } else {
-      CELT_COPY(oldEBands, oldEBands_intra, C*m->nbEBands);
-      CELT_COPY(error, error_intra, C*m->nbEBands);
+      OPUS_COPY(oldEBands, oldEBands_intra, C*m->nbEBands);
+      OPUS_COPY(error, error_intra, C*m->nbEBands);
    }
 
    if (intra)
diff --git a/src/opus_decoder.c b/src/opus_decoder.c
index b1e990bb..074b9d6e 100644
--- a/src/opus_decoder.c
+++ b/src/opus_decoder.c
@@ -29,9 +29,6 @@
 #include "config.h"
 #endif
 
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
 #include <stdarg.h>
 #include "celt.h"
 #include "opus.h"
@@ -94,7 +91,7 @@ int opus_decoder_init(OpusDecoder *st, int Fs, int channels)
 
 	if (channels<1 || channels > 2)
 	    return OPUS_BAD_ARG;
-	memset(st, 0, opus_decoder_get_size(channels));
+	OPUS_CLEAR((char*)st, opus_decoder_get_size(channels));
 	/* Initialize SILK encoder */
     ret = silk_Get_Decoder_Size( &silkDecSizeBytes );
     if( ret ) {
@@ -254,7 +251,7 @@ static int opus_decode_frame(OpusDecoder *st, const unsigned char *data,
     }
     if (audiosize > frame_size)
     {
-        fprintf(stderr, "PCM buffer too small: %d vs %d (mode = %d)\n", audiosize, frame_size, mode);
+        /*fprintf(stderr, "PCM buffer too small: %d vs %d (mode = %d)\n", audiosize, frame_size, mode);*/
         RESTORE_STACK;
         return OPUS_BAD_ARG;
     } else {
@@ -743,31 +740,33 @@ int opus_decode_float(OpusDecoder *st, const unsigned char *data,
 
 int opus_decoder_ctl(OpusDecoder *st, int request, ...)
 {
-    va_list ap;
+   int ret = OPUS_OK;
+   va_list ap;
 
-    va_start(ap, request);
+   va_start(ap, request);
 
-    switch (request)
-    {
-        case OPUS_GET_BANDWIDTH_REQUEST:
-        {
-            opus_int32 *value = va_arg(ap, opus_int32*);
-            *value = st->bandwidth;
-        }
-        break;
-        case OPUS_GET_FINAL_RANGE_REQUEST:
-        {
-            opus_uint32 *value = va_arg(ap, opus_uint32*);
-            *value = st->rangeFinal;
-        }
-        break;
-        default:
-            fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);
-            break;
-    }
+   switch (request)
+   {
+   case OPUS_GET_BANDWIDTH_REQUEST:
+   {
+      opus_int32 *value = va_arg(ap, opus_int32*);
+      *value = st->bandwidth;
+   }
+   break;
+   case OPUS_GET_FINAL_RANGE_REQUEST:
+   {
+      opus_uint32 *value = va_arg(ap, opus_uint32*);
+      *value = st->rangeFinal;
+   }
+   break;
+   default:
+      /*fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);*/
+      ret = OPUS_BAD_ARG;
+      break;
+   }
 
-    va_end(ap);
-    return OPUS_OK;
+   va_end(ap);
+   return ret;
 }
 
 void opus_decoder_destroy(OpusDecoder *st)
diff --git a/src/opus_encoder.c b/src/opus_encoder.c
index d0ecea01..cafdb8d9 100644
--- a/src/opus_encoder.c
+++ b/src/opus_encoder.c
@@ -29,9 +29,6 @@
 #include "config.h"
 #endif
 
-#include <string.h>
-#include <stdlib.h>
-#include <stdio.h>
 #include <stdarg.h>
 #include "celt.h"
 #include "entenc.h"
@@ -125,7 +122,7 @@ int opus_encoder_init(OpusEncoder* st, int Fs, int channels, int application)
     if (Fs != 8000 && Fs != 12000 && Fs != 16000 && Fs != 24000 && Fs != 48000)
         return OPUS_BAD_ARG;
 
-    memset(st, 0, opus_encoder_get_size(channels));
+    OPUS_CLEAR((char*)st, opus_encoder_get_size(channels));
     /* Create SILK encoder */
     ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
     if (ret)
@@ -552,8 +549,9 @@ int opus_encode_float(OpusEncoder *st, const opus_val16 *pcm, int frame_size,
 #endif
         ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
         if( ret ) {
-            fprintf (stderr, "SILK encode error: %d\n", ret);
+            /*fprintf (stderr, "SILK encode error: %d\n", ret);*/
             /* Handle error */
+           return OPUS_INTERNAL_ERROR;
         }
         if (nBytes==0)
         {
@@ -810,9 +808,11 @@ int opus_encode(OpusEncoder *st, const opus_int16 *pcm, int frame_size,
 
 int opus_encoder_ctl(OpusEncoder *st, int request, ...)
 {
+    int ret;
     CELTEncoder *celt_enc;
     va_list ap;
 
+    ret = OPUS_OK;
     va_start(ap, request);
 
     celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset);
@@ -999,11 +999,12 @@ int opus_encoder_ctl(OpusEncoder *st, int request, ...)
         }
         break;
         default:
-            fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);
+            /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
+            ret = OPUS_BAD_ARG;
             break;
     }
     va_end(ap);
-    return OPUS_OK;
+    return ret;
 bad_arg:
     va_end(ap);
     return OPUS_BAD_ARG;
diff --git a/src/opus_multistream.c b/src/opus_multistream.c
index 697cf5b1..49e3d0f8 100644
--- a/src/opus_multistream.c
+++ b/src/opus_multistream.c
@@ -33,9 +33,6 @@
 #include "opus.h"
 #include "opus_private.h"
 #include "stack_alloc.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
 #include <stdarg.h>
 #include "float_cast.h"
 #include "os_support.h"
@@ -297,7 +294,7 @@ int opus_multistream_encode_float(
       }
       /* IMPORTANT: Here we assume that the encoder only returned one frame */
       tot_size += len;
-      memcpy(data, &tmp_data[1], len-1);
+      OPUS_COPY(data, &tmp_data[1], len-1);
    }
    RESTORE_STACK;
    return tot_size;
diff --git a/src/repacketizer.c b/src/repacketizer.c
index 4ef8e1ba..ac4a616c 100644
--- a/src/repacketizer.c
+++ b/src/repacketizer.c
@@ -29,10 +29,6 @@
 #include "config.h"
 #endif
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
 #include "opus.h"
 #include "opus_private.h"
 #include "os_support.h"
@@ -181,11 +177,12 @@ int opus_repacketizer_out_range(OpusRepacketizer *rp, int begin, int end, unsign
          *data++ = count;
       }
    }
+   break;
    }
    /* Copy the actual data */
    for (i=0;i<count;i++)
    {
-      memcpy(data, frames[i], len[i]);
+      OPUS_COPY(data, frames[i], len[i]);
       data += len[i];
    }
    return tot_size;
diff --git a/src/test_opus.c b/src/test_opus.c
index 3a84fafc..7ec1e059 100644
--- a/src/test_opus.c
+++ b/src/test_opus.c
@@ -318,6 +318,7 @@ int main(int argc, char *argv[])
          break;
     default:
          bandwidth_string = "unknown";
+         break;
     }
 
     fprintf(stderr, "Encoding %d Hz input at %.3f kb/s in %s mode with %d-sample frames.\n", sampling_rate, bitrate_bps*0.001, bandwidth_string, frame_size);