hexwave_generate_samples()

void fl::third_party::hexwave::hexwave_generate_samples	(	float *	output,
		int32_t	num_samples,
		HexWave *	hex,
		float	freq )

Generate audio samples.

Parameters

output	Buffer where the library will store generated floating point audio samples
num_samples	The number of audio samples to generate
hex	Pointer to a HexWave initialized with hexwave_create
freq	Frequency of the oscillator divided by the sample rate

The output samples will continue from where the samples generated by the previous hexwave_generate_samples() on this oscillator ended.

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

{
   HexWaveEngine *engine = hex->engine;
   hexvert vert[9];
   int32_t pass,i,j;
   float t = hex->t;
   float temp_output[2*FL_STB_HEXWAVE_MAX_BLEP_LENGTH];
   int32_t buffered_length = static_cast<int32_t>(sizeof(float)*engine->width);
   float dt = (float) fabs(freq);
   float recip_dt = (dt == 0.0f) ? 0.0f : 1.0f / dt;
 
   int32_t halfw = engine->width/2;
   // all sample times are biased by halfw to leave room for BLEP/BLAMP to go back in time
 
   if (num_samples <= 0)
      return;
 
   // convert parameters to times and slopes
   hexwave_generate_linesegs(vert, hex, dt);
 
   if (hex->prev_dt != dt) {
      // if frequency changes, add a fixup at the derivative discontinuity starting at now
      float slope;
      for (j=1; j < 6; ++j)
         if (t < vert[j].t)
            break;
      slope = vert[j].s;
      if (slope != 0)
         hex_blamp(output, 0, (dt - hex->prev_dt)*slope, engine);
      hex->prev_dt = dt;
   }
 
   // copy the buffered data from last call and clear the rest of the output array
   memset(output, 0, sizeof(float)*num_samples);
   memset(temp_output, 0, 2*engine->width*sizeof(float));
 
   if (num_samples >= engine->width) {
      memcpy(output, hex->buffer, buffered_length);
   } else {
      // if the output is shorter than engine->width, we do all synthesis to temp_output
      memcpy(temp_output, hex->buffer, buffered_length);
   }
 
   for (pass=0; pass < 2; ++pass) {
      int32_t i0,i1;
      float *out;
 
      // we want to simulate having one buffer that is num_output + engine->width
      // samples long, without putting that requirement on the user, and without
      // allocating a temp buffer that's as long as the whole thing. so we use two
      // overlapping buffers, one the user's buffer and one a fixed-length temp
      // buffer.
 
      if (pass == 0) {
         if (num_samples < engine->width)
            continue;
         // run as far as we can without overwriting the end of the user's buffer
         out = output;
         i0 = 0;
         i1 = num_samples - engine->width;
      } else {
         // generate the rest into a temp buffer
         out = temp_output;
         i0 = 0;
         if (num_samples >= engine->width)
            i1 = engine->width;
         else
            i1 = num_samples;
      }
 
      // determine current segment
      for (j=0; j < 8; ++j)
         if (t < vert[j+1].t)
            break;
 
      i = i0;
      for(;;) {
         while (t < vert[j+1].t) {
            if (i == i1)
               goto done;
            out[i+halfw] += vert[j].v + vert[j].s*(t - vert[j].t);
            t += dt;
            ++i;
         }
         // transition from lineseg starting at j to lineseg starting at j+1
 
         if (vert[j].t == vert[j+1].t)
            hex_blep(out+i, recip_dt*(t-vert[j+1].t), (vert[j+1].v - vert[j].v), engine);
         hex_blamp(out+i, recip_dt*(t-vert[j+1].t), dt*(vert[j+1].s - vert[j].s), engine);
         ++j;
 
         if (j == 8) {
            // change to different waveform if there's a change pending
            j = 0;
            t -= 1.0f; // t was >= 1.f if j==8
            if (hex->have_pending) {
               float prev_s0 = vert[j].s;
               float prev_v0 = vert[j].v;
               hex->current = hex->pending;
               hex->have_pending = 0;
               hexwave_generate_linesegs(vert, hex, dt);
               // the following never occurs with this oscillator, but it makes
               // the code work in more general cases
               if (vert[j].v != prev_v0)
                  hex_blep (out+i, recip_dt*t,    (vert[j].v - prev_v0), engine);
               if (vert[j].s != prev_s0)
                  hex_blamp(out+i, recip_dt*t, dt*(vert[j].s - prev_s0), engine);
            }
         }
      }
     done:
      ;
   }
 
   // at this point, we've written output[] and temp_output[]
   if (num_samples >= engine->width) {
      // the first half of temp[] overlaps the end of output, the second half will be the new start overlap
      for (i=0; i < engine->width; ++i)
         output[num_samples-engine->width + i] += temp_output[i];
      memcpy(hex->buffer, temp_output+engine->width, buffered_length);
   } else {
      for (i=0; i < num_samples; ++i)
         output[i] = temp_output[i];
      memcpy(hex->buffer, temp_output+num_samples, buffered_length);
   }
 
   hex->t = t;
}

References done, fabs(), FL_NOEXCEPT, FL_STB_HEXWAVE_MAX_BLEP_LENGTH, fl::hex, hex_blamp(), hex_blep(), hexwave_generate_linesegs(), memcpy(), memset(), fl::third_party::hexwave::hexvert::s, fl::t, fl::third_party::hexwave::hexvert::t, fl::third_party::hexwave::hexvert::v, fl::third_party::hexwave::HexWaveEngine::width, and fl::width.

Here is the call graph for this function: