shithub: opus

Info  •  Files  •  Log  •  Branches

Replacing RNN_ macros with existing OPUS_ ones

--- a/dnn/common.h

+++ b/dnn/common.h

@@ -6,16 +6,12 @@

 #include <stdlib.h>

 #include <string.h>

 #include <math.h>

+#include "opus_defines.h"

-#define RNN_INLINE inline

-#ifndef OPUS_INLINE

-#define OPUS_INLINE inline

-#endif

-

 float lpc_from_cepstrum(float *lpc, const float *cepstrum);

 #define LOG256 5.5451774445f

-static RNN_INLINE float log2_approx(float x)

+static OPUS_INLINE float log2_approx(float x)

 {

    int integer;

    float frac;

@@ -34,7 +30,7 @@

 #define log_approx(x) (0.69315f*log2_approx(x))

-static RNN_INLINE float ulaw2lin(float u)

+static OPUS_INLINE float ulaw2lin(float u)

 {

     float s;

     float scale_1 = 32768.f/255.f;

@@ -44,7 +40,7 @@

     return s*scale_1*(exp(u/128.*LOG256)-1);

 }

-static RNN_INLINE int lin2ulaw(float x)

+static OPUS_INLINE int lin2ulaw(float x)

 {

     float u;

     float scale = 255.f/32768.f;

@@ -56,40 +52,6 @@

     if (u > 255) u = 255;

     return (int)floor(.5 + u);

 }

-

-

-/** RNNoise wrapper for malloc(). To do your own dynamic allocation, all you need t

-o do is replace this function and rnnoise_free */

-#ifndef OVERRIDE_RNNOISE_ALLOC

-static RNN_INLINE void *rnnoise_alloc (size_t size)

-{

-   return malloc(size);

-}

-#endif

-

-/** RNNoise wrapper for free(). To do your own dynamic allocation, all you need to do is replace this function and rnnoise_alloc */

-#ifndef OVERRIDE_RNNOISE_FREE

-static RNN_INLINE void rnnoise_free (void *ptr)

-{

-   free(ptr);

-}

-#endif

-

-/** Copy n elements from src to dst. The 0* term provides compile-time type checking  */

-#ifndef OVERRIDE_RNN_COPY

-#define RNN_COPY(dst, src, n) (memcpy((dst), (src), (n)*sizeof(*(dst)) + 0*((dst)-(src)) ))

-#endif

-

-/** Copy n elements from src to dst, allowing overlapping regions. The 0* term

-    provides compile-time type checking */

-#ifndef OVERRIDE_RNN_MOVE

-#define RNN_MOVE(dst, src, n) (memmove((dst), (src), (n)*sizeof(*(dst)) + 0*((dst)-(src)) ))

-#endif

-

-/** Set n elements of dst to zero */

-#ifndef OVERRIDE_RNN_CLEAR

-#define RNN_CLEAR(dst, n) (memset((dst), 0, (n)*sizeof(*(dst))))

-#endif

--- a/dnn/dred_rdovae_dec.c

+++ b/dnn/dred_rdovae_dec.c

@@ -32,8 +32,8 @@

 #include "common.h"

 #include "dred_rdovae_dec.h"

 #include "dred_rdovae_constants.h"

+#include "os_support.h"

-

 void dred_rdovae_dec_init_states(

     RDOVAEDecState *h,            /* io: state buffer handle */

     const RDOVAEDec *model,

@@ -65,7 +65,7 @@

     output_index += DEC_DENSE1_OUT_SIZE;

     compute_gruB(&model->dec_dense2, zero_vector, dec_state->dense2_state, &buffer[input_index]);

-    RNN_COPY(&buffer[output_index], dec_state->dense2_state, DEC_DENSE2_OUT_SIZE);

+    OPUS_COPY(&buffer[output_index], dec_state->dense2_state, DEC_DENSE2_OUT_SIZE);

     input_index = output_index;

     output_index += DEC_DENSE2_OUT_SIZE;

@@ -74,7 +74,7 @@

     output_index += DEC_DENSE3_OUT_SIZE;

     compute_gruB(&model->dec_dense4, zero_vector, dec_state->dense4_state, &buffer[input_index]);

-    RNN_COPY(&buffer[output_index], dec_state->dense4_state, DEC_DENSE4_OUT_SIZE);

+    OPUS_COPY(&buffer[output_index], dec_state->dense4_state, DEC_DENSE4_OUT_SIZE);

     input_index = output_index;

     output_index += DEC_DENSE4_OUT_SIZE;

@@ -83,7 +83,7 @@

     output_index += DEC_DENSE5_OUT_SIZE;

     compute_gruB(&model->dec_dense6, zero_vector, dec_state->dense6_state, &buffer[input_index]);

-    RNN_COPY(&buffer[output_index], dec_state->dense6_state, DEC_DENSE6_OUT_SIZE);

+    OPUS_COPY(&buffer[output_index], dec_state->dense6_state, DEC_DENSE6_OUT_SIZE);

     input_index = output_index;

     output_index += DEC_DENSE6_OUT_SIZE;

--- a/dnn/dred_rdovae_enc.c

+++ b/dnn/dred_rdovae_enc.c

@@ -34,6 +34,7 @@

 #include "dred_rdovae_enc.h"

 #include "common.h"

+#include "os_support.h"

 void dred_rdovae_encode_dframe(

     RDOVAEEncState *enc_state,           /* io: encoder state */

@@ -54,7 +55,7 @@

     output_index += ENC_DENSE1_OUT_SIZE;

     compute_gruB(&model->enc_dense2, zero_vector, enc_state->dense2_state, &buffer[input_index]);

-    RNN_COPY(&buffer[output_index], enc_state->dense2_state, ENC_DENSE2_OUT_SIZE);

+    OPUS_COPY(&buffer[output_index], enc_state->dense2_state, ENC_DENSE2_OUT_SIZE);

     input_index = output_index;

     output_index += ENC_DENSE2_OUT_SIZE;

@@ -63,7 +64,7 @@

     output_index += ENC_DENSE3_OUT_SIZE;

     compute_gruB(&model->enc_dense4, zero_vector, enc_state->dense4_state, &buffer[input_index]);

-    RNN_COPY(&buffer[output_index], enc_state->dense4_state, ENC_DENSE4_OUT_SIZE);

+    OPUS_COPY(&buffer[output_index], enc_state->dense4_state, ENC_DENSE4_OUT_SIZE);

     input_index = output_index;

     output_index += ENC_DENSE4_OUT_SIZE;

@@ -72,7 +73,7 @@

     output_index += ENC_DENSE5_OUT_SIZE;

     compute_gruB(&model->enc_dense6, zero_vector, enc_state->dense6_state, &buffer[input_index]);

-    RNN_COPY(&buffer[output_index], enc_state->dense6_state, ENC_DENSE6_OUT_SIZE);

+    OPUS_COPY(&buffer[output_index], enc_state->dense6_state, ENC_DENSE6_OUT_SIZE);

     input_index = output_index;

     output_index += ENC_DENSE6_OUT_SIZE;

--- a/dnn/dump_data.c

+++ b/dnn/dump_data.c

@@ -41,6 +41,7 @@

 #include <assert.h>

 #include "lpcnet.h"

 #include "lpcnet_private.h"

+#include "os_support.h"

 static void biquad(float *y, float mem[2], const float *x, const float *b, const float *a, int N) {

@@ -98,7 +99,7 @@

     e += noise[i];

     e = IMIN(255, IMAX(0, e));

-    RNN_MOVE(&st->sig_mem[1], &st->sig_mem[0], LPC_ORDER-1);

+    OPUS_MOVE(&st->sig_mem[1], &st->sig_mem[0], LPC_ORDER-1);

     st->sig_mem[0] = p + ulaw2lin(e);

     st->exc_mem = e;

   }

--- a/dnn/freq.c

+++ b/dnn/freq.c

@@ -39,6 +39,7 @@

 #include "arch.h"

 #include "burg.h"

 #include <assert.h>

+#include "os_support.h"

 #define SQUARE(x) ((x)*(x))

@@ -94,8 +95,8 @@

    opus_val32 r;

    opus_val32 error = ac[0];

-   RNN_CLEAR(lpc, p);

-   RNN_CLEAR(rc, p);

+   OPUS_CLEAR(lpc, p);

+   OPUS_CLEAR(rc, p);

    if (ac[0] != 0)

    {

       for (i = 0; i < p; i++) {

@@ -169,7 +170,7 @@

   for (i=0;i<len-1;i++) burg_in[i] = pcm[i+1] - PREEMPHASIS*pcm[i];

   g = silk_burg_analysis(burg_lpc, burg_in, 1e-3, len-1, 1, order);

   g /= len - 2*(order-1);

-  RNN_CLEAR(x, WINDOW_SIZE);

+  OPUS_CLEAR(x, WINDOW_SIZE);

   x[0] = 1;

   for (i=0;i<order;i++) x[i+1] = -burg_lpc[i]*pow(.995, i+1);

   forward_transform(LPC, x);

@@ -283,7 +284,7 @@

    float x_auto[WINDOW_SIZE];

    interp_band_gain(Xr, Ex);

    Xr[FREQ_SIZE-1] = 0;

-   RNN_CLEAR(X_auto, FREQ_SIZE);

+   OPUS_CLEAR(X_auto, FREQ_SIZE);

    for (i=0;i<FREQ_SIZE;i++) X_auto[i].r = Xr[i];

    inverse_transform(x_auto, X_auto);

    for (i=0;i<LPC_ORDER+1;i++) ac[i] = x_auto[i];

@@ -312,7 +313,7 @@

    int i;

    float Ex[NB_BANDS];

    float tmp[NB_BANDS];

-   RNN_COPY(tmp, cepstrum, NB_BANDS);

+   OPUS_COPY(tmp, cepstrum, NB_BANDS);

    tmp[0] += 4;

    idct(Ex, tmp);

    for (i=0;i<NB_BANDS;i++) Ex[i] = pow(10.f, Ex[i])*compensation[i];

--- a/dnn/lpcnet.c

+++ b/dnn/lpcnet.c

@@ -36,6 +36,7 @@

 #include "arch.h"

 #include "lpcnet.h"

 #include "lpcnet_private.h"

+#include "os_support.h"

 #define PREEMPH 0.85f

@@ -59,7 +60,7 @@

   int i, j, k;

   float tmp[LPC_ORDER];

   float ntmp[LPC_ORDER] = {0.0};

-  RNN_COPY(tmp, rc, LPC_ORDER);

+  OPUS_COPY(tmp, rc, LPC_ORDER);

   for(i = 0; i < LPC_ORDER ; i++)

     {

         for(j = 0; j <= i-1; j++)

@@ -93,15 +94,15 @@

     pitch = (int)floor(.1 + 50*features[NB_BANDS]+100);

     pitch = IMIN(255, IMAX(33, pitch));

     net = &lpcnet->nnet;

-    RNN_COPY(in, features, NB_FEATURES);

+    OPUS_COPY(in, features, NB_FEATURES);

     compute_embedding(&lpcnet->model.embed_pitch, &in[NB_FEATURES], pitch);

     compute_conv1d(&lpcnet->model.feature_conv1, conv1_out, net->feature_conv1_state, in);

-    if (lpcnet->frame_count < FEATURE_CONV1_DELAY) RNN_CLEAR(conv1_out, FEATURE_CONV1_OUT_SIZE);

+    if (lpcnet->frame_count < FEATURE_CONV1_DELAY) OPUS_CLEAR(conv1_out, FEATURE_CONV1_OUT_SIZE);

     compute_conv1d(&lpcnet->model.feature_conv2, conv2_out, net->feature_conv2_state, conv1_out);

-    if (lpcnet->frame_count < FEATURES_DELAY) RNN_CLEAR(conv2_out, FEATURE_CONV2_OUT_SIZE);

+    if (lpcnet->frame_count < FEATURES_DELAY) OPUS_CLEAR(conv2_out, FEATURE_CONV2_OUT_SIZE);

     _lpcnet_compute_dense(&lpcnet->model.feature_dense1, dense1_out, conv2_out);

     _lpcnet_compute_dense(&lpcnet->model.feature_dense2, condition, dense1_out);

-    RNN_COPY(rc, condition, LPC_ORDER);

+    OPUS_COPY(rc, condition, LPC_ORDER);

     _lpcnet_compute_dense(&lpcnet->model.gru_a_dense_feature, gru_a_condition, condition);

     _lpcnet_compute_dense(&lpcnet->model.gru_b_dense_feature, gru_b_condition, condition);

 #ifdef END2END

@@ -124,11 +125,11 @@

     int max_buffer_size = lpcnet->model.feature_conv1.kernel_size + lpcnet->model.feature_conv2.kernel_size - 2;

     celt_assert(max_buffer_size <= MAX_FEATURE_BUFFER_SIZE);

     if (lpcnet->feature_buffer_fill == max_buffer_size) {

-        RNN_MOVE(lpcnet->feature_buffer, &lpcnet->feature_buffer[NB_FEATURES],  (max_buffer_size-1)*NB_FEATURES);

+        OPUS_MOVE(lpcnet->feature_buffer, &lpcnet->feature_buffer[NB_FEATURES],  (max_buffer_size-1)*NB_FEATURES);

     } else {

       lpcnet->feature_buffer_fill++;

     }

-    RNN_COPY(&lpcnet->feature_buffer[(lpcnet->feature_buffer_fill-1)*NB_FEATURES], features, NB_FEATURES);

+    OPUS_COPY(&lpcnet->feature_buffer[(lpcnet->feature_buffer_fill-1)*NB_FEATURES], features, NB_FEATURES);

 }

 void run_frame_network_flush(LPCNetState *lpcnet)

@@ -153,7 +154,7 @@

 #if 1

     compute_gru_a_input(gru_a_input, gru_a_condition, GRU_A_STATE_SIZE, &lpcnet->model.gru_a_embed_sig, last_sig, &lpcnet->model.gru_a_embed_pred, pred, &lpcnet->model.gru_a_embed_exc, last_exc);

 #else

-    RNN_COPY(gru_a_input, gru_a_condition, 3*GRU_A_STATE_SIZE);

+    OPUS_COPY(gru_a_input, gru_a_condition, 3*GRU_A_STATE_SIZE);

     accum_embedding(&lpcnet->model.gru_a_embed_sig, gru_a_input, last_sig);

     accum_embedding(&lpcnet->model.gru_a_embed_pred, gru_a_input, pred);

     accum_embedding(&lpcnet->model.gru_a_embed_exc, gru_a_input, last_exc);

@@ -160,8 +161,8 @@

 #endif

     /*compute_gru3(&gru_a, net->gru_a_state, gru_a_input);*/

     compute_sparse_gru(&lpcnet->model.sparse_gru_a, net->gru_a_state, gru_a_input);

-    RNN_COPY(in_b, net->gru_a_state, GRU_A_STATE_SIZE);

-    RNN_COPY(gru_b_input, gru_b_condition, 3*GRU_B_STATE_SIZE);

+    OPUS_COPY(in_b, net->gru_a_state, GRU_A_STATE_SIZE);

+    OPUS_COPY(gru_b_input, gru_b_condition, 3*GRU_B_STATE_SIZE);

     compute_gruB(&lpcnet->model.gru_b, gru_b_input, net->gru_b_state, in_b);

     return sample_mdense(&lpcnet->model.dual_fc, net->gru_b_state, sampling_logit_table, rng);

 }

@@ -174,7 +175,7 @@

 void lpcnet_reset(LPCNetState *lpcnet)

 {

     const char* rng_string="LPCNet";

-    RNN_CLEAR((char*)&lpcnet->LPCNET_RESET_START,

+    OPUS_CLEAR((char*)&lpcnet->LPCNET_RESET_START,

             sizeof(LPCNetState)-

             ((char*)&lpcnet->LPCNET_RESET_START - (char*)lpcnet));

     lpcnet->last_exc = lin2ulaw(0.f);

@@ -227,9 +228,9 @@

 {

     lpcnet->deemph_mem = 0;

     lpcnet->last_exc = lin2ulaw(0.f);

-    RNN_CLEAR(lpcnet->last_sig, LPC_ORDER);

-    RNN_CLEAR(lpcnet->nnet.gru_a_state, GRU_A_STATE_SIZE);

-    RNN_CLEAR(lpcnet->nnet.gru_b_state, GRU_B_STATE_SIZE);

+    OPUS_CLEAR(lpcnet->last_sig, LPC_ORDER);

+    OPUS_CLEAR(lpcnet->nnet.gru_a_state, GRU_A_STATE_SIZE);

+    OPUS_CLEAR(lpcnet->nnet.gru_b_state, GRU_B_STATE_SIZE);

 }

 void lpcnet_synthesize_tail_impl(LPCNetState *lpcnet, opus_int16 *output, int N, int preload)

@@ -238,7 +239,7 @@

     if (lpcnet->frame_count <= FEATURES_DELAY)

     {

-        RNN_CLEAR(output, N);

+        OPUS_CLEAR(output, N);

         return;

     }

     for (i=0;i<N;i++)

@@ -259,7 +260,7 @@

         } else {

           pcm = pred + ulaw2lin(exc);

         }

-        RNN_MOVE(&lpcnet->last_sig[1], &lpcnet->last_sig[0], LPC_ORDER-1);

+        OPUS_MOVE(&lpcnet->last_sig[1], &lpcnet->last_sig[0], LPC_ORDER-1);

         lpcnet->last_sig[0] = pcm;

         lpcnet->last_exc = exc;

         pcm += PREEMPH*lpcnet->deemph_mem;

--- a/dnn/lpcnet_demo.c

+++ b/dnn/lpcnet_demo.c

@@ -36,6 +36,7 @@

 #include "arch.h"

 #include "lpcnet.h"

 #include "freq.h"

+#include "os_support.h"

 #ifdef USE_WEIGHTS_FILE

 # if __unix__

@@ -179,7 +180,7 @@

             size_t ret;

             ret = fread(in_features, sizeof(features[0]), NB_TOTAL_FEATURES, fin);

             if (feof(fin) || ret != NB_TOTAL_FEATURES) break;

-            RNN_COPY(features, in_features, NB_FEATURES);

+            OPUS_COPY(features, in_features, NB_FEATURES);

             lpcnet_synthesize(net, features, pcm, LPCNET_FRAME_SIZE);

             fwrite(pcm, sizeof(pcm[0]), LPCNET_FRAME_SIZE, fout);

         }

--- a/dnn/lpcnet_enc.c

+++ b/dnn/lpcnet_enc.c

@@ -40,6 +40,7 @@

 #include <assert.h>

 #include "lpcnet_private.h"

 #include "lpcnet.h"

+#include "os_support.h"

 int lpcnet_encoder_get_size() {

@@ -65,9 +66,9 @@

 static void frame_analysis(LPCNetEncState *st, kiss_fft_cpx *X, float *Ex, const float *in) {

   float x[WINDOW_SIZE];

-  RNN_COPY(x, st->analysis_mem, OVERLAP_SIZE);

-  RNN_COPY(&x[OVERLAP_SIZE], in, FRAME_SIZE);

-  RNN_COPY(st->analysis_mem, &in[FRAME_SIZE-OVERLAP_SIZE], OVERLAP_SIZE);

+  OPUS_COPY(x, st->analysis_mem, OVERLAP_SIZE);

+  OPUS_COPY(&x[OVERLAP_SIZE], in, FRAME_SIZE);

+  OPUS_COPY(st->analysis_mem, &in[FRAME_SIZE-OVERLAP_SIZE], OVERLAP_SIZE);

   apply_window(x);

   forward_transform(X, x);

   lpcn_compute_band_energy(Ex, X);

@@ -85,7 +86,7 @@

   float ener0;

   int sub;

   float ener;

-  RNN_COPY(aligned_in, &st->analysis_mem[OVERLAP_SIZE-TRAINING_OFFSET], TRAINING_OFFSET);

+  OPUS_COPY(aligned_in, &st->analysis_mem[OVERLAP_SIZE-TRAINING_OFFSET], TRAINING_OFFSET);

   frame_analysis(st, X, Ex, in);

   logMax = -2;

   follow = -2;

@@ -100,14 +101,14 @@

   st->features[0] -= 4;

   lpc_from_cepstrum(st->lpc, st->features);

   for (i=0;i<LPC_ORDER;i++) st->features[NB_BANDS+2+i] = st->lpc[i];

-  RNN_MOVE(st->exc_buf, &st->exc_buf[FRAME_SIZE], PITCH_MAX_PERIOD);

-  RNN_COPY(&aligned_in[TRAINING_OFFSET], in, FRAME_SIZE-TRAINING_OFFSET);

+  OPUS_MOVE(st->exc_buf, &st->exc_buf[FRAME_SIZE], PITCH_MAX_PERIOD);

+  OPUS_COPY(&aligned_in[TRAINING_OFFSET], in, FRAME_SIZE-TRAINING_OFFSET);

   for (i=0;i<FRAME_SIZE;i++) {

     int j;

     float sum = aligned_in[i];

     for (j=0;j<LPC_ORDER;j++)

       sum += st->lpc[j]*st->pitch_mem[j];

-    RNN_MOVE(st->pitch_mem+1, st->pitch_mem, LPC_ORDER-1);

+    OPUS_MOVE(st->pitch_mem+1, st->pitch_mem, LPC_ORDER-1);

     st->pitch_mem[0] = aligned_in[i];

     st->exc_buf[PITCH_MAX_PERIOD+i] = sum + .7f*st->pitch_filt;

     st->pitch_filt = sum;

@@ -192,7 +193,7 @@

     for (i=0;i<PITCH_MAX_PERIOD-PITCH_MIN_PERIOD;i++) st->pitch_max_path[1][i] -= max_path_all;

     /*for (i=0;i<PITCH_MAX_PERIOD-PITCH_MIN_PERIOD;i++) printf("%f ", st->pitch_max_path[1][i]);

     printf("\n");*/

-    RNN_COPY(&st->pitch_max_path[0][0], &st->pitch_max_path[1][0], PITCH_MAX_PERIOD);

+    OPUS_COPY(&st->pitch_max_path[0][0], &st->pitch_max_path[1][0], PITCH_MAX_PERIOD);

     st->pitch_max_path_all = max_path_all;

     st->best_i = best_i;

   }

@@ -226,7 +227,7 @@

   preemphasis(x, &st->mem_preemph, x, PREEMPHASIS, FRAME_SIZE);

   compute_frame_features(st, x);

   process_single_frame(st, NULL);

-  RNN_COPY(features, &st->features[0], NB_TOTAL_FEATURES);

+  OPUS_COPY(features, &st->features[0], NB_TOTAL_FEATURES);

   return 0;

 }

--- a/dnn/lpcnet_plc.c

+++ b/dnn/lpcnet_plc.c

@@ -31,6 +31,7 @@

 #include "lpcnet_private.h"

 #include "lpcnet.h"

 #include "plc_data.h"

+#include "os_support.h"

 #ifndef M_PI

 #define M_PI 3.141592653

@@ -44,12 +45,12 @@

 }

 void lpcnet_plc_reset(LPCNetPLCState *st) {

-  RNN_CLEAR((char*)&st->LPCNET_PLC_RESET_START,

+  OPUS_CLEAR((char*)&st->LPCNET_PLC_RESET_START,

           sizeof(LPCNetPLCState)-

           ((char*)&st->LPCNET_PLC_RESET_START - (char*)st));

   lpcnet_reset(&st->lpcnet);

   lpcnet_encoder_init(&st->enc);

-  RNN_CLEAR(st->pcm, PLC_BUF_SIZE);

+  OPUS_CLEAR(st->pcm, PLC_BUF_SIZE);

   st->pcm_fill = PLC_BUF_SIZE;

   st->skip_analysis = 0;

   st->blend = 0;

@@ -110,12 +111,12 @@

       fprintf(stderr, "FEC buffer full\n");

       return;

     }

-    RNN_MOVE(&st->fec[0][0], &st->fec[st->fec_keep_pos][0], (st->fec_fill_pos-st->fec_keep_pos)*NB_FEATURES);

+    OPUS_MOVE(&st->fec[0][0], &st->fec[st->fec_keep_pos][0], (st->fec_fill_pos-st->fec_keep_pos)*NB_FEATURES);

     st->fec_fill_pos = st->fec_fill_pos-st->fec_keep_pos;

     st->fec_read_pos -= st->fec_keep_pos;

     st->fec_keep_pos = 0;

   }

-  RNN_COPY(&st->fec[st->fec_fill_pos][0], features, NB_FEATURES);

+  OPUS_COPY(&st->fec[st->fec_fill_pos][0], features, NB_FEATURES);

   st->fec_fill_pos++;

 }

@@ -140,12 +141,12 @@

   if (st->fec_read_pos != st->fec_fill_pos && st->fec_skip==0) {

     float plc_features[2*NB_BANDS+NB_FEATURES+1] = {0};

     float discard[NB_FEATURES];

-    RNN_COPY(out, &st->fec[st->fec_read_pos][0], NB_FEATURES);

+    OPUS_COPY(out, &st->fec[st->fec_read_pos][0], NB_FEATURES);

     st->fec_read_pos++;

     /* Make sure we can rewind a few frames back at resync time. */

     st->fec_keep_pos = IMAX(0, IMAX(st->fec_keep_pos, st->fec_read_pos-FEATURES_DELAY-1));

     /* Update PLC state using FEC, so without Burg features. */

-    RNN_COPY(&plc_features[2*NB_BANDS], out, NB_FEATURES);

+    OPUS_COPY(&plc_features[2*NB_BANDS], out, NB_FEATURES);

     plc_features[2*NB_BANDS+NB_FEATURES] = -1;

     compute_plc_pred(st, discard, plc_features);

     return 1;

@@ -165,11 +166,11 @@

 }

 void clear_state(LPCNetPLCState *st) {

-  RNN_CLEAR(st->lpcnet.last_sig, LPC_ORDER);

+  OPUS_CLEAR(st->lpcnet.last_sig, LPC_ORDER);

   st->lpcnet.last_exc = lin2ulaw(0.f);

   st->lpcnet.deemph_mem = 0;

-  RNN_CLEAR(st->lpcnet.nnet.gru_a_state, GRU_A_STATE_SIZE);

-  RNN_CLEAR(st->lpcnet.nnet.gru_b_state, GRU_B_STATE_SIZE);

+  OPUS_CLEAR(st->lpcnet.nnet.gru_a_state, GRU_A_STATE_SIZE);

+  OPUS_CLEAR(st->lpcnet.nnet.gru_b_state, GRU_B_STATE_SIZE);

 }

 /* In this causal version of the code, the DNN model implemented by compute_plc_pred()

@@ -188,7 +189,7 @@

     if (st->blend) {

       opus_int16 tmp[FRAME_SIZE-TRAINING_OFFSET];

       float zeros[2*NB_BANDS+NB_FEATURES+1] = {0};

-      RNN_COPY(zeros, plc_features, 2*NB_BANDS);

+      OPUS_COPY(zeros, plc_features, 2*NB_BANDS);

       zeros[2*NB_BANDS+NB_FEATURES] = 1;

       if (st->enable_blending) {

         LPCNetState copy;

@@ -213,14 +214,14 @@

 #ifdef PLC_SKIP_UPDATES

         lpcnet_reset_signal(&st->lpcnet);

 #else

-        RNN_COPY(tmp, pcm, FRAME_SIZE-TRAINING_OFFSET);

+        OPUS_COPY(tmp, pcm, FRAME_SIZE-TRAINING_OFFSET);

         lpcnet_synthesize_tail_impl(&st->lpcnet, tmp, FRAME_SIZE-TRAINING_OFFSET, FRAME_SIZE-TRAINING_OFFSET);

 #endif

       }

-      RNN_COPY(st->pcm, &pcm[FRAME_SIZE-TRAINING_OFFSET], TRAINING_OFFSET);

+      OPUS_COPY(st->pcm, &pcm[FRAME_SIZE-TRAINING_OFFSET], TRAINING_OFFSET);

       st->pcm_fill = TRAINING_OFFSET;

     } else {

-      RNN_COPY(&st->pcm[st->pcm_fill], pcm, FRAME_SIZE);

+      OPUS_COPY(&st->pcm[st->pcm_fill], pcm, FRAME_SIZE);

       st->pcm_fill += FRAME_SIZE;

     }

   }

@@ -231,7 +232,7 @@

   compute_frame_features(&st->enc, x);

   process_single_frame(&st->enc, NULL);

   if (!st->blend) {

-    RNN_COPY(&plc_features[2*NB_BANDS], st->enc.features, NB_FEATURES);

+    OPUS_COPY(&plc_features[2*NB_BANDS], st->enc.features, NB_FEATURES);

     plc_features[2*NB_BANDS+NB_FEATURES] = 1;

     compute_plc_pred(st, st->features, plc_features);

     /* Discard an FEC frame that we know we will no longer need. */

@@ -247,7 +248,7 @@

     st->skip_analysis--;

   } else {

     for (i=0;i<FRAME_SIZE;i++) st->pcm[PLC_BUF_SIZE+i] = pcm[i];

-    RNN_COPY(output, &st->pcm[0], FRAME_SIZE);

+    OPUS_COPY(output, &st->pcm[0], FRAME_SIZE);

 #ifdef PLC_SKIP_UPDATES

     {

       run_frame_network_deferred(&st->lpcnet, st->enc.features);

@@ -255,7 +256,7 @@

 #else

     lpcnet_synthesize_impl(&st->lpcnet, st->enc.features, output, FRAME_SIZE, FRAME_SIZE);

 #endif

-    RNN_MOVE(st->pcm, &st->pcm[FRAME_SIZE], PLC_BUF_SIZE);

+    OPUS_MOVE(st->pcm, &st->pcm[FRAME_SIZE], PLC_BUF_SIZE);

   }

   st->loss_count = 0;

   st->blend = 0;

@@ -273,16 +274,16 @@

     /*fprintf(stderr, "update state for PLC %d\n", st->pcm_fill);*/

     int update_count;

     update_count = IMIN(st->pcm_fill, FRAME_SIZE);

-    RNN_COPY(output, &st->pcm[0], update_count);

-    RNN_MOVE(&st->plc_copy[1], &st->plc_copy[0], FEATURES_DELAY);

+    OPUS_COPY(output, &st->pcm[0], update_count);

+    OPUS_MOVE(&st->plc_copy[1], &st->plc_copy[0], FEATURES_DELAY);

     st->plc_copy[0] = st->plc_net;

     get_fec_or_pred(st, st->features);

     lpcnet_synthesize_impl(&st->lpcnet, &st->features[0], output, update_count, update_count);

-    RNN_MOVE(st->pcm, &st->pcm[FRAME_SIZE], PLC_BUF_SIZE);

+    OPUS_MOVE(st->pcm, &st->pcm[FRAME_SIZE], PLC_BUF_SIZE);

     st->pcm_fill -= update_count;

     st->skip_analysis++;

   }

-  RNN_MOVE(&st->plc_copy[1], &st->plc_copy[0], FEATURES_DELAY);

+  OPUS_MOVE(&st->plc_copy[1], &st->plc_copy[0], FEATURES_DELAY);

   st->plc_copy[0] = st->plc_net;

   lpcnet_synthesize_tail_impl(&st->lpcnet, pcm, FRAME_SIZE-TRAINING_OFFSET, 0);

   if (get_fec_or_pred(st, st->features)) st->loss_count = 0;

--- a/dnn/nnet.c

+++ b/dnn/nnet.c

@@ -40,6 +40,7 @@

 #include "nnet_data.h"

 #include "dred_rdovae_constants.h"

 #include "plc_data.h"

+#include "os_support.h"

 #ifdef NO_OPTIMIZATIONS

 #if defined(_MSC_VER)

@@ -99,7 +100,7 @@

          output[i] = relu(input[i]);

    } else if (activation == ACTIVATION_SOFTMAX) {

 #ifdef SOFTMAX_HACK

-      RNN_COPY(output, input, N);

+      OPUS_COPY(output, input, N);

       /*for (i=0;i<N;i++)

          output[i] = input[i];*/

 #else

@@ -390,7 +391,7 @@

    celt_assert(input != state);

    celt_assert(gru->reset_after);

    stride = 3*N;

-   RNN_COPY(zrh, input, 3*N);

+   OPUS_COPY(zrh, input, 3*N);

    for (i=0;i<3*N;i++)

       recur[i] = gru->bias[3*N + i];

    sgemv_accum8x4(recur, gru->recurrent_weights, 3*N, N, stride, state);

@@ -457,8 +458,8 @@

    float tmp[MAX_CONV_INPUTS_ALL];

    celt_assert(input != output);

    celt_assert(layer->nb_inputs*layer->kernel_size <= MAX_CONV_INPUTS_ALL);

-   RNN_COPY(tmp, mem, layer->nb_inputs*(layer->kernel_size-1));

-   RNN_COPY(&tmp[layer->nb_inputs*(layer->kernel_size-1)], input, layer->nb_inputs);

+   OPUS_COPY(tmp, mem, layer->nb_inputs*(layer->kernel_size-1));

+   OPUS_COPY(&tmp[layer->nb_inputs*(layer->kernel_size-1)], input, layer->nb_inputs);

    M = layer->nb_inputs*layer->kernel_size;

    N = layer->nb_neurons;

    stride = N;

@@ -466,7 +467,7 @@

       output[i] = layer->bias[i];

    sgemv_accum(output, layer->input_weights, N, M, stride, tmp);

    compute_activation(output, output, N, layer->activation);

-   RNN_COPY(mem, &tmp[layer->nb_inputs], layer->nb_inputs*(layer->kernel_size-1));

+   OPUS_COPY(mem, &tmp[layer->nb_inputs], layer->nb_inputs*(layer->kernel_size-1));

 }

 void compute_embedding(const EmbeddingLayer *layer, float *output, int input)

--- a/dnn/write_lpcnet_weights.c

+++ b/dnn/write_lpcnet_weights.c

@@ -33,6 +33,7 @@

 #include <stddef.h>

 #include "nnet.h"

 #include "common.h"

+#include "os_support.h"

 /* This is a bit of a hack because we need to build nnet_data.c and plc_data.c without USE_WEIGHTS_FILE,

    but USE_WEIGHTS_FILE is defined in config.h. */

@@ -56,7 +57,7 @@

     h.type = list[i].type;

     h.size = list[i].size;

     h.block_size = (h.size+WEIGHT_BLOCK_SIZE-1)/WEIGHT_BLOCK_SIZE*WEIGHT_BLOCK_SIZE;

-    RNN_CLEAR(h.name, sizeof(h.name));

+    OPUS_CLEAR(h.name, sizeof(h.name));

     strncpy(h.name, list[i].name, sizeof(h.name));

     h.name[sizeof(h.name)-1] = 0;

     celt_assert(sizeof(h) == WEIGHT_BLOCK_SIZE);

--- a/silk/dred_encoder.c

+++ b/silk/dred_encoder.c

@@ -56,7 +56,7 @@

 void dred_encoder_reset(DREDEnc* enc)

 {

-    RNN_CLEAR((char*)&enc->DREDENC_RESET_START,

+    OPUS_CLEAR((char*)&enc->DREDENC_RESET_START,

               sizeof(DREDEnc)-

               ((char*)&enc->DREDENC_RESET_START - (char*)enc));

     enc->input_buffer_fill = DRED_SILK_ENCODER_DELAY;

-- 

⑨