REFAC: Remove dead code

Author: Hartmnt

src/_renamenoise_fft_guts.h

@@ -31,9 +31,6 @@
 #ifndef RENAMENOISE_FFT_GUTS_H
 #define RENAMENOISE_FFT_GUTS_H
 
-#define RENAMENOISE_MIN(a, b) ((a) < (b) ? (a) : (b))
-#define RENAMENOISE_MAX(a, b) ((a) > (b) ? (a) : (b))
-
 /**
   renamenoise_fft.h
   Defines renamenoise_fft_scalar as either short or a float type
@@ -49,7 +46,6 @@
   Explanation of macros dealing with complex math:
 
    C_MUL(m,a,b)         : m = a*b
-   C_FIXDIV( c , div )  : if a fixed point impl., c /= div. noop otherwise
    C_SUB( res, a,b)     : res = a - b
    C_SUBFROM( res , a)  : res -= a
    C_ADDTO( res , a)    : res += a
@@ -71,8 +67,6 @@
 
 #define RENAMENOISE_C_MUL4(m, a, b) RENAMENOISE_C_MUL(m, a, b)
 
-#define RENAMENOISE_C_FIXDIV(c, div) /* NOOP */
-
 #define RENAMENOISE_C_MULBYSCALAR(c, s) \
 	do {                                \
 		(c).r *= (s);                   \
@@ -117,15 +111,9 @@
 		} while (0)
 #endif /* !RENAMENOISE_C_ADD defined */
 
-#ifdef USE_SIMD
-#	define RENAMENOISE_FFT_COS(phase) _mm_set1_ps(cos(phase))
-#	define RENAMENOISE_FFT_SIN(phase) _mm_set1_ps(sin(phase))
-#	define RENAMENOISE_HALF_OF(x) ((x) *_mm_set1_ps(.5f))
-#else
-#	define RENAMENOISE_FFT_COS(phase) (renamenoise_fft_scalar) cos(phase)
-#	define RENAMENOISE_FFT_SIN(phase) (renamenoise_fft_scalar) sin(phase)
-#	define RENAMENOISE_HALF_OF(x) ((x) *.5f)
-#endif
+#define RENAMENOISE_FFT_COS(phase) (renamenoise_fft_scalar) cos(phase)
+#define RENAMENOISE_FFT_SIN(phase) (renamenoise_fft_scalar) sin(phase)
+#define RENAMENOISE_HALF_OF(x) ((x) *.5f)
 
 #define renamenoise_kf_cexp(x, phase)        \
 	do {                                     \

src/arch.h

@@ -49,8 +49,6 @@
 #	endif
 #endif
 
-#define RENAMENOISE_SIG_SCALE 32768.f
-
 #ifndef M_PI
 #	define M_PI (3.14159265358979323846)
 #endif
@@ -94,41 +92,18 @@ _renamenoise_fatal(const char *str, const char *file, int line) {
 
 #endif /* !ENABLE_ASSERTIONS defined */
 
-#define RENAMENOISE_IMUL32(a, b) ((a) * (b))
-
-#define RENAMENOISE_MIN16(a, b) ((a) < (b) ? (a) : (b)) // Minimum 16-bit value.
-
-#define RENAMENOISE_MAX16(a, b) ((a) > (b) ? (a) : (b)) // Maximum 16-bit value.
-
-#define RENAMENOISE_MIN32(a, b) ((a) < (b) ? (a) : (b)) // Minimum 32-bit value.
-
-#define RENAMENOISE_MAX32(a, b) ((a) > (b) ? (a) : (b)) // Maximum 32-bit value.
+#define RENAMENOISE_MIN16(a, b) ((a) < (b) ? (a) : (b))
 
-#define RENAMENOISE_IMIN(a, b) ((a) < (b) ? (a) : (b))  // Minimum int value.
+#define RENAMENOISE_MAX16(a, b) ((a) > (b) ? (a) : (b))
 
-#define RENAMENOISE_IMAX(a, b) ((a) > (b) ? (a) : (b))  // Maximum int value.
+#define RENAMENOISE_MIN32(a, b) ((a) < (b) ? (a) : (b))
 
-#define RENAMENOISE_UADD32(a, b) ((a) + (b))
-#define RENAMENOISE_USUB32(a, b) ((a) - (b))
-
-// Set this if renamenoise_int64 is a native type of the CPU.
-// Assume that all LP64 architectures have fast 64-bit types;
-// also x86_64 (which can be ILP32 for x32) and Win64 (which is LLP64).
-#if defined(__x86_64__) || defined(__LP64__) || defined(_WIN64)
-#	define RENAMENOISE_FAST_INT64 1
-#else
-#	define RENAMENOISE_FAST_INT64 0
-#endif
-
-#define PRINT_MIPS(file)
+#define RENAMENOISE_MAX32(a, b) ((a) > (b) ? (a) : (b))
 
 typedef float renamenoise_val16;
 typedef float renamenoise_val32;
-typedef float renamenoise_val64;
 
 typedef float renamenoise_sig;
-typedef float renamenoise_norm;
-typedef float renamenoise_ener;
 
 #ifdef RENAMENOISE_FLOAT_APPROX
 // This code should reliably detect NaN/inf even when -ffast-math is used.
@@ -150,50 +125,27 @@ static RENAMENOISE_INLINE int renamenoise_isnan(float x) {
 
 #define RENAMENOISE_Q15ONE 1.0f
 
-#define RENAMENOISE_NORM_SCALING 1.f
-
 #define RENAMENOISE_EPSILON 1e-15f
 #define RENAMENOISE_VERY_SMALL 1e-30f
 #define RENAMENOISE_VERY_LARGE16 1e15f
-#define RENAMENOISE_Q15_ONE ((renamenoise_val16) 1.f)
-
-// This appears to be the same speed as C99's fabsf() but it's more portable.
-#define RENAMENOISE_ABS16(x) ((float) fabs(x))
-#define RENAMENOISE_ABS32(x) ((float) fabs(x))
 
 #define RENAMENOISE_QCONST16(x, bits) (x)
-#define RENAMENOISE_QCONST32(x, bits) (x)
 
-#define RENAMENOISE_NEG16(x) (-(x))
-#define RENAMENOISE_NEG32(x) (-(x))
 #define RENAMENOISE_NEG32_ovflw(x) (-(x))
 #define RENAMENOISE_EXTRACT16(x) (x)
 #define RENAMENOISE_EXTEND32(x) (x)
-#define RENAMENOISE_SHR16(a, shift) (a)
-#define RENAMENOISE_SHL16(a, shift) (a)
 #define RENAMENOISE_SHR32(a, shift) (a)
 #define RENAMENOISE_SHL32(a, shift) (a)
-#define RENAMENOISE_PSHR32(a, shift) (a)
 #define RENAMENOISE_VSHR32(a, shift) (a)
 
-#define RENAMENOISE_PSHR(a, shift) (a)
-#define RENAMENOISE_SHR(a, shift) (a)
-#define RENAMENOISE_SHL(a, shift) (a)
-#define RENAMENOISE_SATURATE(x, a) (x)
-#define RENAMENOISE_SATURATE16(x) (x)
-
 #define RENAMENOISE_ROUND16(a, shift) (a)
-#define RENAMENOISE_SROUND16(a, shift) (a)
 #define RENAMENOISE_HALF16(x) (.5f * (x))
 #define RENAMENOISE_HALF32(x) (.5f * (x))
 
-#define RENAMENOISE_ADD16(a, b) ((a) + (b))
-#define RENAMENOISE_SUB16(a, b) ((a) - (b))
 #define RENAMENOISE_ADD32(a, b) ((a) + (b))
 #define RENAMENOISE_SUB32(a, b) ((a) - (b))
 #define RENAMENOISE_ADD32_ovflw(a, b) ((a) + (b))
 #define RENAMENOISE_SUB32_ovflw(a, b) ((a) - (b))
-#define RENAMENOISE_MULT16_16_16(a, b) ((a) * (b))
 
 #define RENAMENOISE_MULT16_16(a, b) ((renamenoise_val32) (a) * (renamenoise_val32) (b))
 
@@ -204,31 +156,7 @@ static RENAMENOISE_INLINE int renamenoise_isnan(float x) {
 
 #define RENAMENOISE_MULT32_32_Q31(a, b) ((a) * (b))
 
-#define RENAMENOISE_MAC16_32_Q15(c, a, b) ((c) + (a) * (b))
-#define RENAMENOISE_MAC16_32_Q16(c, a, b) ((c) + (a) * (b))
-
-#define RENAMENOISE_MULT16_16_Q11_32(a, b) ((a) * (b))
-#define RENAMENOISE_MULT16_16_Q11(a, b) ((a) * (b))
-#define RENAMENOISE_MULT16_16_Q13(a, b) ((a) * (b))
-#define RENAMENOISE_MULT16_16_Q14(a, b) ((a) * (b))
 #define RENAMENOISE_MULT16_16_Q15(a, b) ((a) * (b))
-#define RENAMENOISE_MULT16_16_P15(a, b) ((a) * (b))
-#define RENAMENOISE_MULT16_16_P13(a, b) ((a) * (b))
-#define RENAMENOISE_MULT16_16_P14(a, b) ((a) * (b))
-#define RENAMENOISE_MULT16_32_P16(a, b) ((a) * (b))
-
-#define RENAMENOISE_DIV32_16(a, b) (((renamenoise_val32) (a)) / (renamenoise_val16) (b))
-
-#define RENAMENOISE_DIV32(a, b) (((renamenoise_val32) (a)) / (renamenoise_val32) (b))
-
-#define RENAMENOISE_SCALEIN(a) ((a) *RENAMENOISE_SIG_SCALE)
-#define RENAMENOISE_SCALEOUT(a) ((a) * (1 / RENAMENOISE_SIG_SCALE))
-
-#define RENAMENOISE_SIG2WORD16(x) (x)
-
-#ifndef RENAMENOISE_GLOBAL_STACK_SIZE
-#	define RENAMENOISE_GLOBAL_STACK_SIZE 120000
-#endif
 
 #if __STDC_VERSION__ < 199901L || (__STDC_VERSION__ > 201000L && __STDC_NO_VLA__ == 1)
 #	define RENAMENOISE_NO_VLA

src/common.h

@@ -36,20 +36,6 @@
 
 #define RENAMENOISE_INLINE inline
 
-/** ReNameNoise wrapper for malloc(). To do your own dynamic allocation, all you need to do is replace this function and renamenoise_free */
-#ifndef OVERRIDE_RENAMENOISE_ALLOC
-static RENAMENOISE_INLINE void *renamenoise_alloc(size_t size) {
-	return malloc(size);
-}
-#endif
-
-/** ReNameNoise wrapper for free(). To do your own dynamic allocation, all you need to do is replace this function and renamenoise_alloc */
-#ifndef OVERRIDE_RENAMENOISE_FREE
-static RENAMENOISE_INLINE void renamenoise_free(void *ptr) {
-	free(ptr);
-}
-#endif
-
 /** Copy n elements from src to dst. The 0* term provides compile-time type checking  */
 #ifndef OVERRIDE_RENAMENOISE_COPY
 #	define RENAMENOISE_COPY(dst, src, n) (memcpy((dst), (src), (n) * sizeof(*(dst)) + 0 * ((dst) - (src))))

src/denoise.c

@@ -198,21 +198,6 @@ static void renamenoise_dct(float *out, const float *in) {
 	}
 }
 
-#if 0
-static void renamenoise_idct(float *out, const float *in) {
-  int i;
-  renamenoise_check_init();
-  for (i=0;i<RENAMENOISE_NB_BANDS;i++) {
-    int j;
-    float sum = 0;
-    for (j=0;j<RENAMENOISE_NB_BANDS;j++) {
-      sum += in[j] * renamenoise_common.dct_table[i*RENAMENOISE_NB_BANDS + j];
-    }
-    out[i] = sum*sqrt(2./22);
-  }
-}
-#endif
-
 static void renamenoise_forward_transform(renamenoise_fft_cpx *out, const float *in) {
 	int i;
 	renamenoise_fft_cpx x[RENAMENOISE_WINDOW_SIZE];
@@ -442,18 +427,12 @@ void renamenoise_pitch_filter(renamenoise_fft_cpx *X, const renamenoise_fft_cpx
 	float r[RENAMENOISE_NB_BANDS];
 	float rf[RENAMENOISE_FREQ_SIZE] = {0};
 	for (i = 0; i < RENAMENOISE_NB_BANDS; i++) {
-#if 0
-    if (Exp[i]>g[i]) r[i] = 1;
-    else r[i] = Exp[i]*(1-g[i])/(.001 + g[i]*(1-Exp[i]));
-    r[i] = RENAMENOISE_MIN16(1, RENAMENOISE_MAX16(0, r[i]));
-#else
 		if (Exp[i] > g[i]) {
 			r[i] = 1;
 		} else {
 			r[i] = RENAMENOISE_SQUARE(Exp[i]) * (1 - RENAMENOISE_SQUARE(g[i])) / (.001 + RENAMENOISE_SQUARE(g[i]) * (1 - RENAMENOISE_SQUARE(Exp[i])));
 		}
 		r[i] = sqrt(RENAMENOISE_MIN16(1, RENAMENOISE_MAX16(0, r[i])));
-#endif
 		r[i] *= sqrt(Ex[i] / (1e-8 + Ep[i]));
 	}
 	renamenoise_interp_band_gain(rf, r);
@@ -501,12 +480,10 @@ float renamenoise_process_frame(ReNameNoiseDenoiseState *st, float *out, const f
 			st->lastg[i] = g[i];
 		}
 		renamenoise_interp_band_gain(gf, g);
-#if 1
 		for (i = 0; i < RENAMENOISE_FREQ_SIZE; i++) {
 			X[i].r *= gf[i];
 			X[i].i *= gf[i];
 		}
-#endif
 	}
 
 	renamenoise_frame_synthesis(st, out, X);
@@ -688,12 +665,10 @@ int main(int argc, char **argv) {
 			}
 		}
 		count++;
-#	if 1
 		fwrite(features, sizeof(float), RENAMENOISE_NB_FEATURES, stdout);
 		fwrite(g, sizeof(float), RENAMENOISE_NB_BANDS, stdout);
 		fwrite(Ln, sizeof(float), RENAMENOISE_NB_BANDS, stdout);
 		fwrite(&vad, sizeof(float), 1, stdout);
-#	endif
 	}
 	fprintf(stderr, "matrix size: %d x %d\n", count, RENAMENOISE_NB_FEATURES + 2 * RENAMENOISE_NB_BANDS + 1);
 	fclose(f1);

src/pitch.c

@@ -42,9 +42,6 @@
 #include "pitch.h"
 
 #include "common.h"
-// #include "modes.h"
-// #include "stack_alloc.h"
-// #include "mathops.h"
 #include "math.h"
 #include "renamenoise_lpc.h"
 
@@ -170,17 +167,8 @@ void renamenoise_pitch_downsample(renamenoise_sig *x[], renamenoise_val16 *x_lp,
 }
 
 void renamenoise_pitch_xcorr(const renamenoise_val16 *_x, const renamenoise_val16 *_y, renamenoise_val32 *xcorr, int len, int max_pitch) {
-#if 0 // This is a simple version of the pitch correlation that should work well on DSPs like Blackfin and TI C5x/C6x
-   int i, j;
-   for (i=0;i<max_pitch;i++)
-   {
-      renamenoise_val32 sum = 0;
-      for (j=0;j<len;j++)
-         sum = RENAMENOISE_MAC16_16(sum, _x[j], _y[i+j]);
-      xcorr[i] = sum;
-   }
-
-#else // Unrolled version of the pitch correlation -- runs faster on x86 and ARM
+	// Unrolled version of the pitch correlation -- runs faster on x86 and ARM
+
 	int i;
 	// The EDSP version requires that max_pitch is at least 1,
 	// and that _x is 32-bit aligned.
@@ -201,7 +189,6 @@ void renamenoise_pitch_xcorr(const renamenoise_val16 *_x, const renamenoise_val1
 		sum = renamenoise_inner_prod(_x, _y + i, len);
 		xcorr[i] = sum;
 	}
-#endif
 }
 
 void renamenoise_pitch_search(const renamenoise_val16 *x_lp, renamenoise_val16 *y, int len, int max_pitch, int *pitch) {

src/pitch.h

@@ -38,8 +38,6 @@
 #ifndef PITCH_H
 #define PITCH_H
 
-// #include "modes.h"
-// #include "cpu_support.h"
 #include "arch.h"
 
 void renamenoise_pitch_downsample(renamenoise_sig *x[], renamenoise_val16 *x_lp, int len, int C);