hexwave_engine_create()

HexWaveEngine * fl::third_party::hexwave::hexwave_engine_create	(	int32_t	width,
		int32_t	oversample,
		float *	user_buffer )

Create and initialize a new HexWaveEngine.

Parameters

width	Size of BLEP, from 4..64, larger is slower & more memory but less aliasing
oversample	2+, number of subsample positions, larger uses more memory but less noise
user_buffer	Optional, if provided the library will perform no allocations. 16*width*(oversample+1) bytes, must stay allocated as long as engine is used

Returns

Pointer to initialized engine, or nullptr on failure

Width can be larger than 64 if you define FL_STB_HEXWAVE_MAX_BLEP_LENGTH to a larger value

Definition at line 335 of file stb_hexwave.cpp.hpp.

{
   if (width > FL_STB_HEXWAVE_MAX_BLEP_LENGTH)
      width = FL_STB_HEXWAVE_MAX_BLEP_LENGTH;
 
   int32_t halfwidth = width/2;
   int32_t half = halfwidth*oversample;
   int32_t blep_buffer_count = width*(oversample+1);
   int32_t n = 2*half+1;
 
   #ifdef FL_STB_HEXWAVE_NO_ALLOCATION
   (void)blep_buffer_count;
   if (user_buffer == nullptr)
      return nullptr;  // Cannot allocate in no-allocation mode
   float *buffers = user_buffer;
   #else
   float *buffers = user_buffer ? user_buffer : (float *) malloc(sizeof(float) * n * 2);
   #endif
 
   float *step    = buffers+0*n;
   float *ramp    = buffers+1*n;
   float *blep_buffer, *blamp_buffer;
   double integrate_impulse=0, integrate_step=0;
   int32_t i,j;
 
   bool ownsBuffers = false;
   if (user_buffer == 0) {
      #ifndef FL_STB_HEXWAVE_NO_ALLOCATION
      blep_buffer  = (float *) malloc(sizeof(float)*blep_buffer_count);
      blamp_buffer = (float *) malloc(sizeof(float)*blep_buffer_count);
      ownsBuffers = true;
      #else
      blep_buffer = nullptr;
      blamp_buffer = nullptr;
      #endif
   } else {
      blep_buffer  = ramp+n;
      blamp_buffer = blep_buffer + blep_buffer_count;
   }
 
   // compute BLEP and BLAMP by integrating windowed sinc
   for (i=0; i < n; ++i) {
      for (j=0; j < 16; ++j) {
         float sinc_t = 3.141592f* (i-half) / oversample;
         float sinc   = (i==half) ? 1.0f : (float) sin(static_cast<double>(sinc_t)) / (sinc_t);
         float wt     = 2.0f*3.1415926f * i / (n-1);
         float window = (float) (0.355768 - 0.487396*cos(static_cast<double>(wt)) + 0.144232*cos(2*static_cast<double>(wt)) - 0.012604*cos(3*static_cast<double>(wt))); // Nuttall
         double value       =         window * sinc;
         integrate_impulse +=         value/16;
         integrate_step    +=         integrate_impulse/16;
      }
      step[i]            = (float) integrate_impulse;
      ramp[i]            = (float) integrate_step;
   }
 
   // renormalize
   for (i=0; i < n; ++i) {
      step[i] = step[i] * (float) (1.0       / step[n-1]); // step needs to reach to 1.0
      ramp[i] = ramp[i] * (float) (halfwidth / ramp[n-1]); // ramp needs to become a slope of 1.0 after oversampling
   }
 
   // deinterleave to allow efficient interpolation e.g. w/SIMD
   for (j=0; j <= oversample; ++j) {
      for (i=0; i < width; ++i) {
         blep_buffer [j*width+i] = step[j+i*oversample];
         blamp_buffer[j*width+i] = ramp[j+i*oversample];
      }
   }
 
   // subtract out the naive waveform; note we can't do this to the raw data
   // above, because we want the discontinuity to be in a different locations
   // for j=0 and j=oversample (which exists to provide something to interpolate against)
   for (j=0; j <= oversample; ++j) {
      // subtract step
      for (i=halfwidth; i < width; ++i)
         blep_buffer [j*width+i] -= 1.0f;
      // subtract ramp
      for (i=halfwidth; i < width; ++i)
         blamp_buffer[j*width+i] -= (j+i*oversample-half)*(1.0f/oversample);
   }
 
   // Allocate and initialize engine
   #ifndef FL_STB_HEXWAVE_NO_ALLOCATION
   HexWaveEngine *engine = (HexWaveEngine *) malloc(sizeof(HexWaveEngine));
   engine->blep  = blep_buffer;
   engine->blamp = blamp_buffer;
   engine->width = width;
   engine->oversample = oversample;
   engine->ownsBuffers = ownsBuffers;
 
   if (user_buffer == 0)
      free(buffers);
 
   return engine;
   #else
   (void)ownsBuffers;
   return nullptr;
   #endif
}

References fl::third_party::hexwave::HexWaveEngine::blamp, fl::third_party::hexwave::HexWaveEngine::blep, cos(), FL_NOEXCEPT, FL_STB_HEXWAVE_MAX_BLEP_LENGTH, free(), malloc(), fl::third_party::hexwave::HexWaveEngine::oversample, fl::third_party::hexwave::HexWaveEngine::ownsBuffers, sin(), fl::step(), fl::type_rank< T >::value, fl::third_party::hexwave::HexWaveEngine::width, and fl::width.

Referenced by hexwave_init().

Here is the call graph for this function:

Here is the caller graph for this function: