NVIDIA-AI-Image-Scaling-SDK/samples/third_party/stb/stb_hexwave.h

// stb_hexwave - v0.5 - public domain, initial release 2021-04-01
//
// A flexible anti-aliased (bandlimited) digital audio oscillator.
//
// This library generates waveforms of a variety of shapes made of
// line segments. It does not do envelopes, LFO effects, etc.; it
// merely tries to solve the problem of generating an artifact-free
// morphable digital waveform with a variety of spectra, and leaves
// it to the user to rescale the waveform and mix multiple voices, etc.
//
// Compiling:
//
//   In one C/C++ file that #includes this file, do
//
//      #define STB_HEXWAVE_IMPLEMENTATION
//      #include "stb_hexwave.h"
//
//   Optionally, #define STB_HEXWAVE_STATIC before including
//   the header to cause the definitions to be private to the
//   implementation file (i.e. to be "static" instead of "extern").
//
// Notes:
//
//   Optionally performs memory allocation during initialization,
//   never allocates otherwise.
//
// License:
//
//   See end of file for license information.
//
// Usage:
//
//   Initialization:
//
//     hexwave_init(32,16,NULL); // read "header section" for alternatives
//
//   Create oscillator:
//
//     HexWave *osc = malloc(sizeof(*osc)); // or "new HexWave", or declare globally or on stack
//     hexwave_create(osc, reflect_flag, peak_time, half_height, zero_wait);
//       see "Waveform shapes" below for the meaning of these parameters
//
//   Generate audio:
//
//     hexwave_generate_samples(output, number_of_samples, osc, oscillator_freq)
//       where:
//         output is a buffer where the library will store floating point audio samples
//         number_of_samples is the number of audio samples to generate
//         osc is a pointer to a Hexwave
//         oscillator_freq is the 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.
//
//   Change oscillator waveform:
//
//     hexwave_change(osc, reflect_flag, peak_time, half_height, zero_wait);
//       can call in between calls to hexwave_generate_samples
//
// Waveform shapes:
//
//   All waveforms generated by hexwave are constructed from six line segments
//   characterized by 3 parameters.
//
//   See demonstration: https://www.youtube.com/watch?v=hsUCrAsDN-M
//
//                 reflect=0                          reflect=1
//
//           0-----P---1                        0-----P---1    peak_time = P
//                 .     1                            .     1
//                /\_    :                           /\_    :
//               /   \_  :                          /   \_  :
//              /      \.H                         /      \.H  half_height = H
//             /       | :                        /       | :
//       _____/        |_:___               _____/        | :       _____
//           .           :   \        |         .         | :      /
//           .           :    \       |         .         | :     /
//           .           :     \     _/         .         \_:    /
//           .           :      \  _/           .           :_  /
//           .          -1       \/             .          -1 \/
//       0 - Z - - - - 1                    0 - Z - - - - 1   zero_wait = Z
//
//    Classic waveforms:
//                               peak    half    zero
//                     reflect   time   height   wait
//      Sawtooth          1       0       0       0
//      Square            1       0       1       0
//      Triangle          1       0.5     0       0
//
//    Some waveforms can be produced in multiple ways, which is useful when morphing
//    into other waveforms, and there are a few more notable shapes:
//
//                               peak    half    zero
//                     reflect   time   height   wait
//      Sawtooth          1       1      any      0
//      Sawtooth (8va)    1       0      -1       0
//      Triangle          1       0.5     0       0
//      Square            1       0       1       0
//      Square            0       0       1       0
//      Triangle          0       0.5     0       0
//      Triangle          0       0      -1       0
//      AlternatingSaw    0       0       0       0
//      AlternatingSaw    0       1      any      0
//      Stairs            0       0       1       0.5
//
//    The "Sawtooth (8va)" waveform is identical to a sawtooth wave with 2x the
//    frequency, but when morphed with other values, it becomes an overtone of
//    the base frequency.
//
//  Morphing waveforms:
//
//    Sweeping peak_time morphs the waveform while producing various spectra.
//    Sweeping half_height effectively crossfades between two waveforms; useful, but less exciting.
//    Sweeping zero_wait produces a similar effect no matter the reset of the waveform,
//        a sort of high-pass/PWM effect where the wave becomes silent at zero_wait=1.
//
//    You can trivially morph between any two waveforms from the above table
//    which only differ in one column.
//
//    Crossfade between classic waveforms:
//                                            peak     half    zero
//        Start         End         reflect   time    height   wait
//        -----         ---         -------   ----    ------   ----
//        Triangle      Square         0       0      -1..1    0
//        Saw           Square         1       0       0..1    0
//        Triangle      Saw            1       0.5     0..2    0
//
//    The last morph uses uses half-height values larger than 1, which means it will
//    be louder and the output should be scaled down by half to compensate, or better
//    by dynamically tracking the morph: volume_scale = 1 - half_height/4
//
//    Non-crossfade morph between classic waveforms, most require changing
//    two parameters at the same time:
//                                           peak     half    zero
//      Start         End         reflect    time    height   wait
//      -----         ---         -------    ----    ------   ----
//      Square        Triangle      any      0..0.5   1..0     0
//      Square        Saw            1       0..1     1..any   0
//      Triangle      Saw            1     0.5..1     0..-1    0
//
//    Other noteworthy morphs between simple shapes:
//                                                            peak     half    zero
//      Start           Halfway       End          reflect    time    height   wait
//      -----           ---------     ---          -------    ----    ------   ----
//      Saw (8va,neg)                Saw (pos)        1       0..1      -1      0
//      Saw (neg)                    Saw (pos)        1       0..1       0      0
//      Triangle                     AlternatingSaw   0       0..1      -1      0
//      AlternatingSaw  Triangle     AlternatingSaw   0       0..1       0      0
//      Square                       AlternatingSaw   0       0..1       1      0
//      Triangle        Triangle     AlternatingSaw   0       0..1    -1..1     0
//      Square                       AlternatingSaw   0       0..1     1..0     0
//      Saw (8va)       Triangle     Saw              1       0..1    -1..1     0
//      Saw (neg)                    Saw (pos)        1       0..1     0..1     0
//      AlternatingSaw               AlternatingSaw   0       0..1     0..any   0
//
//   The last entry is noteworthy because the morph from the halfway point to either
//   endpoint sounds very different. For example, an LFO sweeping back and forth over
//   the whole range will morph between the middle timbre and the AlternatingSaw
//   timbre in two different ways, alternating.
//
//   Entries with "any" for half_height are whole families of morphs, as you can pick
//   any value you want as the endpoint for half_height.
//
//   You can always morph between any two waveforms with the same value of 'reflect'
//   by just sweeping the parameters simultaneously. There will never be artifacts
//   and the result will always be useful, if not necessarily what you want.
//
//   You can vary the sound of two-parameter morphs by ramping them differently,
//   e.g. if the morph goes from t=0..1, then square-to-triangle looks like:
//        peak_time   = lerp(t, 0, 0.5)
//        half_height = lerp(t, 1, 0  )
//   but you can also do things like:
//        peak_time   = lerp(smoothstep(t), 0, 0.5)
//        half_height = cos(PI/2 * t)
//
// How it works:
//
//   hexwave use BLEP to bandlimit discontinuities and BLAMP
//   to bandlimit C1 discontinuities. This is not polyBLEP
//   (polynomial BLEP), it is table-driven BLEP. It is
//   also not minBLEP (minimum-phase BLEP), as that complicates
//   things for little benefit once BLAMP is involved.
//
//   The previous oscillator frequency is remembered, and when
//   the frequency changes, a BLAMP is generated to remove the
//   C1 discontinuity, which reduces artifacts for sweeps/LFO.
//
//   Changes to an oscillator timbre using hexwave_change() actually
//   wait until the oscillator finishes its current cycle. All
//   waveforms with non-zero "zero_wait" settings pass through 0
//   and have 0-slope at the start of a cycle, which means changing
//   the settings is artifact free at that time. (If zero_wait is 0,
//   the code still treats it as passing through 0 with 0-slope; it'll
//   apply the necessary fixups to make it artifact free as if it does
//   transition to 0 with 0-slope vs. the waveform at the end of
//   the cycle, then adds the fixups for a non-0 and non-0 slope
//   at the start of the cycle, which cancels out if zero_wait is 0,
//   and still does the right thing if zero_wait is 0 when the
//   settings are updated.)
//
//   BLEP/BLAMP normally requires overlapping buffers, but this
//   is hidden from the user by generating the waveform to a
//   temporary buffer and saving the overlap regions internally
//   between calls. (It is slightly more complicated; see code.)
//
//   By design all shapes have 0 DC offset; this is one reason
//   hexwave uses zero_wait instead of standard PWM.
//
//   The internals of hexwave could support any arbitrary shape
//   made of line segments, but I chose not to expose this
//   generality in favor of a simple, easy-to-use API.

#ifndef STB_INCLUDE_STB_HEXWAVE_H
#define STB_INCLUDE_STB_HEXWAVE_H

#ifndef STB_HEXWAVE_MAX_BLEP_LENGTH
#define STB_HEXWAVE_MAX_BLEP_LENGTH   64 // good enough for anybody
#endif

#ifdef STB_HEXWAVE_STATIC
#define STB_HEXWAVE_DEF static
#else
#define STB_HEXWAVE_DEF extern
#endif

typedef struct HexWave HexWave;

STB_HEXWAVE_DEF void hexwave_init(int width, int oversample, float *user_buffer);
//         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 library is used
//                technically it only needs:   8*( width * (oversample  + 1))
//                                           + 8*((width *  oversample) + 1)  bytes
//
// width can be larger than 64 if you define STB_HEXWAVE_MAX_BLEP_LENGTH to a larger value

STB_HEXWAVE_DEF void hexwave_shutdown(float *user_buffer);
//       user_buffer: pass in same parameter as passed to hexwave_init

STB_HEXWAVE_DEF void hexwave_create(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait);
// see docs above for description
//
//   reflect is tested as 0 or non-zero
//   peak_time is clamped to 0..1
//   half_height is not clamped
//   zero_wait is clamped to 0..1

STB_HEXWAVE_DEF void hexwave_change(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait);
// see docs

STB_HEXWAVE_DEF void hexwave_generate_samples(float *output, int num_samples, HexWave *hex, float freq);
//            output: buffer where the library will store generated floating point audio samples
// number_of_samples: the number of audio samples to generate
//               osc: pointer to a Hexwave initialized with 'hexwave_create'
//   oscillator_freq: frequency of the oscillator divided by the sample rate

// private:
typedef struct
{
   int   reflect;
   float peak_time;
   float zero_wait;
   float half_height;
} HexWaveParameters;

struct HexWave
{
   float t, prev_dt;
   HexWaveParameters current, pending;
   int have_pending;
   float buffer[STB_HEXWAVE_MAX_BLEP_LENGTH];
}; 
#endif

#ifdef STB_HEXWAVE_IMPLEMENTATION

#ifndef STB_HEXWAVE_NO_ALLOCATION
#include <stdlib.h> // malloc,free
#endif

#include <string.h> // memset,memcpy,memmove
#include <math.h>   // sin,cos,fabs

#define hexwave_clamp(v,a,b)   ((v) < (a) ? (a) : (v) > (b) ? (b) : (v))

STB_HEXWAVE_DEF void hexwave_change(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait)
{
   hex->pending.reflect     = reflect;
   hex->pending.peak_time   = hexwave_clamp(peak_time,0,1);
   hex->pending.half_height = half_height;
   hex->pending.zero_wait   = hexwave_clamp(zero_wait,0,1);
   // put a barrier here to allow changing from a different thread than the generator
   hex->have_pending        = 1;
}

STB_HEXWAVE_DEF void hexwave_create(HexWave *hex, int reflect, float peak_time, float half_height, float zero_wait)
{
   memset(hex, 0, sizeof(*hex));
   hexwave_change(hex, reflect, peak_time, half_height, zero_wait);
   hex->current = hex->pending;
   hex->have_pending = 0;
   hex->t = 0;
   hex->prev_dt = 0;
}

static struct
{
   int width;       // width of fixup in samples
   int oversample;  // number of oversampled versions (there's actually one more to allow lerpign)
   float *blep;
   float *blamp;
} hexblep;

static void hex_add_oversampled_bleplike(float *output, float time_since_transition, float scale, float *data)
{
   float *d1,*d2;
   float lerpweight;
   int i, bw = hexblep.width;

   int slot = (int) (time_since_transition * hexblep.oversample);
   if (slot >= hexblep.oversample)
      slot = hexblep.oversample-1; // clamp in case the floats overshoot

   d1 = &data[ slot   *bw];
   d2 = &data[(slot+1)*bw];

   lerpweight = time_since_transition * hexblep.oversample - slot;
   for (i=0; i < bw; ++i)
      output[i] += scale * (d1[i] + (d2[i]-d1[i])*lerpweight);
}

static void hex_blep (float *output, float time_since_transition, float scale)
{
   hex_add_oversampled_bleplike(output, time_since_transition, scale, hexblep.blep);
}

static void hex_blamp(float *output, float time_since_transition, float scale)
{
   hex_add_oversampled_bleplike(output, time_since_transition, scale, hexblep.blamp);
}

typedef struct
{
   float t,v,s; // time, value, slope
} hexvert;

// each half of the waveform needs 4 vertices to represent 3 line
// segments, plus 1 more for wraparound
static void hexwave_generate_linesegs(hexvert vert[9], HexWave *hex, float dt)
{
   int j;
   float min_len = dt / 256.0f;

   vert[0].t = 0;
   vert[0].v = 0;
   vert[1].t = hex->current.zero_wait*0.5f;
   vert[1].v = 0;
   vert[2].t = 0.5f*hex->current.peak_time + vert[1].t*(1-hex->current.peak_time);
   vert[2].v = 1;
   vert[3].t = 0.5f;
   vert[3].v = hex->current.half_height;

   if (hex->current.reflect) {
      for (j=4; j <= 7; ++j) {
         vert[j].t = 1 -  vert[7-j].t;
         vert[j].v =    - vert[7-j].v;
      }
   } else {
      for (j=4; j <= 7; ++j) {
         vert[j].t =  0.5f +  vert[j-4].t;
         vert[j].v =        - vert[j-4].v;
      }
   }
   vert[8].t = 1;
   vert[8].v = 0;

   for (j=0; j < 8; ++j) {
      if (vert[j+1].t <= vert[j].t + min_len) {
          // if change takes place over less than a fraction of a sample treat as discontinuity
          //
          // otherwise the slope computation can blow up to arbitrarily large and we
          // try to generate a huge BLAMP and the result is wrong.
          // 
          // why does this happen if the math is right? i believe if done perfectly,
          // the two BLAMPs on either side of the slope would cancel out, but our
          // BLAMPs have only limited sub-sample precision and limited integration
          // accuracy. or maybe it's just the math blowing up w/ floating point precision
          // limits as we try to make x * (1/x) cancel out
          //
          // min_len verified artifact-free even near nyquist with only oversample=4
         vert[j+1].t = vert[j].t;
      }
   }

   if (vert[8].t != 1.0f) {
      // if the above fixup moved the endpoint away from 1.0, move it back,
      // along with any other vertices that got moved to the same time
      float t = vert[8].t;
      for (j=5; j <= 8; ++j)
         if (vert[j].t == t)
            vert[j].t = 1.0f;
   }

   // compute the exact slopes from the final fixed-up positions
   for (j=0; j < 8; ++j)
      if (vert[j+1].t == vert[j].t)
         vert[j].s = 0;
      else
         vert[j].s = (vert[j+1].v - vert[j].v) / (vert[j+1].t - vert[j].t);

   // wraparound at end
   vert[8].t = 1;
   vert[8].v = vert[0].v;
   vert[8].s = vert[0].s;
}

STB_HEXWAVE_DEF void hexwave_generate_samples(float *output, int num_samples, HexWave *hex, float freq)
{
   hexvert vert[9];
   int pass,i,j;
   float t = hex->t;
   float temp_output[2*STB_HEXWAVE_MAX_BLEP_LENGTH];
   int buffered_length = sizeof(float)*hexblep.width;
   float dt = (float) fabs(freq);
   float recip_dt = (dt == 0.0f) ? 0.0f : 1.0f / dt;

   int halfw = hexblep.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);
      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*hexblep.width*sizeof(float));

   if (num_samples >= hexblep.width) {
      memcpy(output, hex->buffer, buffered_length);
   } else {
      // if the output is shorter than hexblep.width, we do all synthesis to temp_output
      memcpy(temp_output, hex->buffer, buffered_length);
   }

   for (pass=0; pass < 2; ++pass) {
      int i0,i1;
      float *out;

      // we want to simulate having one buffer that is num_output + hexblep.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 < hexblep.width)
            continue;
         // run as far as we can without overwriting the end of the user's buffer 
         out = output;
         i0 = 0;
         i1 = num_samples - hexblep.width;
      } else {
         // generate the rest into a temp buffer
         out = temp_output;
         i0 = 0;
         if (num_samples >= hexblep.width)
            i1 = hexblep.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));
         hex_blamp(out+i, recip_dt*(t-vert[j+1].t), dt*(vert[j+1].s - vert[j].s));
         ++j;

         if (j == 8) {
            // change to different waveform if there's a change pending
            j = 0;
            t -= 1.0; // 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));
               if (vert[j].s != prev_s0)
                  hex_blamp(out+i, recip_dt*t, dt*(vert[j].s - prev_s0));
            }
         }
      }
     done:
      ;
   }

   // at this point, we've written output[] and temp_output[]
   if (num_samples >= hexblep.width) {
      // the first half of temp[] overlaps the end of output, the second half will be the new start overlap
      for (i=0; i < hexblep.width; ++i)
         output[num_samples-hexblep.width + i] += temp_output[i];
      memcpy(hex->buffer, temp_output+hexblep.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;
}

STB_HEXWAVE_DEF void hexwave_shutdown(float *user_buffer)
{
   #ifndef STB_HEXWAVE_NO_ALLOCATION
   if (user_buffer != 0) {
      free(hexblep.blep);
      free(hexblep.blamp);
   }
   #endif
}

// buffer should be NULL or must be 4*(width*(oversample+1)*2 + 
STB_HEXWAVE_DEF void hexwave_init(int width, int oversample, float *user_buffer)
{
   int halfwidth = width/2;
   int half = halfwidth*oversample;
   int blep_buffer_count = width*(oversample+1);
   int n = 2*half+1;
#ifdef STB_HEXWAVE_NO_ALLOCATION
   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;
   int i,j;

   if (width > STB_HEXWAVE_MAX_BLEP_LENGTH)
      width = STB_HEXWAVE_MAX_BLEP_LENGTH;

   if (user_buffer == 0) {
      #ifndef STB_HEXWAVE_NO_ALLOCATION
      blep_buffer  = (float *) malloc(sizeof(float)*blep_buffer_count);
      blamp_buffer = (float *) malloc(sizeof(float)*blep_buffer_count);
      #endif
   } else {
      blep_buffer  = ramp+n;
      blamp_buffer = blep_buffer + blep_buffer_count;
   }

   // compute BLEP and BLAMP by integerating 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(sinc_t) / (sinc_t);
         float wt     = 2.0f*3.1415926f * i / (n-1);
         float window = (float) (0.355768 - 0.487396*cos(wt) + 0.144232*cos(2*wt) - 0.012604*cos(3*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);
   }

   hexblep.blep  = blep_buffer;
   hexblep.blamp = blamp_buffer;
   hexblep.width = width;
   hexblep.oversample = oversample;

   #ifndef STB_HEXWAVE_NO_ALLOCATION
   if (user_buffer == 0)
      free(buffers);
   #endif
}
#endif // STB_HEXWAVE_IMPLEMENTATION

/*
------------------------------------------------------------------------------
This software is available under 2 licenses -- choose whichever you prefer.
------------------------------------------------------------------------------
ALTERNATIVE A - MIT License
Copyright (c) 2017 Sean Barrett
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
------------------------------------------------------------------------------
ALTERNATIVE B - Public Domain (www.unlicense.org)
This is free and unencumbered software released into the public domain.
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
software, either in source code form or as a compiled binary, for any purpose,
commercial or non-commercial, and by any means.
In jurisdictions that recognize copyright laws, the author or authors of this
software dedicate any and all copyright interest in the software to the public
domain. We make this dedication for the benefit of the public at large and to
the detriment of our heirs and successors. We intend this dedication to be an
overt act of relinquishment in perpetuity of all present and future rights to
this software under copyright law.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
------------------------------------------------------------------------------
*/