<br />
<b>Warning</b>:  session_start(): open(/var/lib/php/sessions/sess_mbnoiqncr85h9dou7rbr0l56ic, O_RDWR) failed: No space left on device (28) in <b>/var/www/tb-usercake/models/config.php</b> on line <b>51</b><br />
<br />
<b>Warning</b>:  session_start(): Failed to read session data: files (path: /var/lib/php/sessions) in <b>/var/www/tb-usercake/models/config.php</b> on line <b>51</b><br />
// For audio recognition, we need a double-precision (16 bit)
// integral image. We simply turn the sample data into pixels and
// have ourselves a verybig*1 image.
sclass AudioRecognizer {
  IAudioSample mainSample;
  
  double defaultInputSampleRate() { ret 44100; }
  
  interface IAudioSample {
    int channels();
    double length();
    double sampleRate();
    
    // result is in the range -32768*(end-start) to 32767*(end-start)
    double sampleSum(int channel, double start, double end);
    
    // range is -1 to 1
    default double getPixel(int channel, double start, double end) {
      ret doubleRatio(sampleSum(channel, start, end), (end-start)*32768);
    }
    
    default BufferedImage render() {
      int w = iceil(length()), h = channels();
      ret imageFromFunction(w, h, (x, y) -> {
        int channel = y;
        double value = sampleSum(channel, x, x+1);
        
        // lose lower 8 bits and shift to 0 to 255
        int digital = ifloor(value/256)+128;
        
        //if (x < 20) printVars(+value, +digital);
        
        ret rgbIntFullAlpha(digital, digital, digital);
      });
    }
   
    // h = height per channel
    default BufferedImage graph(int h) {
      int w = iceil(length());
      ret mergeBufferedImagesVertically(
        countIterator(channels(), c ->
          simpleGraph(w, h, x -> sampleSum(0, x, x+1), -32768, 32767)));
    }
   
    // going pixel-by-pixel 
    default double maxAmplitude() {
      int n = iceil(length()), channels = channels();
      double max = 0;
      for i to n:
        for c to channels: 
          max = max(max, abs(sampleSum(c, i, i+1)));
      ret min(32767, max);
    }
    
    default IAudioSample gain(double factor) {
      ret factor == 1 ? this : new Gain(factor, this);
    }
    
    default IAudioSample normalize() {
      ret gain(doubleRatio(32767, maxAmplitude()));
    }
  }
  
  // the 16 bit per channel 1D integral image
  // we use to represent audio samples
  sclass AudioSample implements IAudioSample {
    int channels;
    int length;
    long[] data;
    double sampleRate;

    public double sampleRate() { ret sampleRate; }
    public int channels() { ret channels; }
    public double length() { ret length; }
    
    // result is in the range -32768*(end-start) to 32767*(end-start)
    public double sampleSum(int channel, double start, double end) {
      int a = ifloor(start), b = ifloor(end);
      ret getEntry(channel, b)-getEntry(channel, a-1);
    }
    
    // get an entry of the sum table
    long getEntry(int channel, int i) {
      if (i < 0) ret 0;
      i = min(i, length-1);
      ret data[i*channels+channel];
    }
    
    *(L<short[]> samples, int *channels, double *sampleRate) {
      length = lengthLevel2_shortArrays(samples);
      data = new long[length*channels];
      long[] sums = new[channels];
      int iSample = 0, iChunk = 0, iInArray = 0;
      short[] chunk = null;
      for i to length: {
        if (chunk == null || iInArray >= chunk.length) {
          chunk = samples.get(iChunk++);
          iInArray = 0;
        }
        
        for c to channels:
          data[iSample++] = (sums[c] += chunk[iInArray++]);
      }
    }
  }

  srecord noeq Gain(double factor, IAudioSample original) implements IAudioSample {
    public double sampleRate() { ret original.sampleRate(); }
    public int channels() { ret original.channels(); }
    public double length() { ret original.length(); }
    
    public double sampleSum(int channel, double start, double end) {
      ret original.sampleSum(channel, start, end)*factor;
    }
    
    // optimize double gain
    public IAudioSample gain(double factor) {
      ret original.gain(this.factor*factor);
    }
  }
  
  sclass SpeedUp implements IAudioSample {
    double factor, invFactor;
    IAudioSample original;

    *(double *factor, IAudioSample *original) {
      invFactor = 1/factor;
    }
    
    public double sampleRate() { ret original.sampleRate()*invFactor; }
    public int channels() { ret original.channels(); }
    public double length() { ret original.length()*invFactor; }
    
    public double sampleSum(int channel, double start, double end) {
      ret original.sampleSum(channel, start*factor, end*factor)*invFactor;
    }
  }
  
  *() {}
  *(short[] samples, int channels) {
    this(ll(samples), channels);
  }
  
  *(L<short[]> samples, int channels) {
    mainSample = new AudioSample(samples, channels, defaultInputSampleRate());
  }
  
  void applyGain(double factor) {
    mainSample = mainSample.gain(factor);
  }
  
  void normalize { mainSample = mainSample.normalize(); }
  
  void speedUp(double factor) {
    mainSample = new SpeedUp(factor, mainSample);
  }
}