sclass AudioSampleOps {

  // implementation of gain modifier

  srecord noeq Gain(double factor, IAudioSample original) implements IAudioSample {

    public double sampleRate() { ret original.sampleRate(); }

    public int channels() { ret original.channels(); }

    public DoubleRange bounds() { ret original.bounds(); }

    public double sampleSum(int channel, double start, double end) {

      ret original.sampleSum(channel, start, end)*factor;

    }

    // coalesce consecutive gains

    public IAudioSample gain(double factor) {

      ret original.gain(this.factor*factor);

    }

  }

  // Implementation of the time-shift modifier.

  // moves the input <shift> samples to the left (cuts off beginning).

  // Shift can be fractional - we're in integral image (audio) wonderland after all

  // where a traditional pixel has no meaning.

  srecord noeq TimeShift(double shift, IAudioSample original) implements IAudioSample {

    public double sampleRate() { ret original.sampleRate(); }

    public int channels() { ret original.channels(); }

    public DoubleRange bounds() { ret shiftDoubleRange(original.bounds(), -shift); }

    public double sampleSum(int channel, double start, double end) {

      ret original.sampleSum(channel, start+shift, end+shift);

    }

    // coalesce consecutive time-shifts

    public IAudioSample timeShift(double shift) {

      ret original.timeShift(this.shift+shift);

    }

  }

  // Implementation of the speed-up modifier which transforms every frequency f to f*factor.

  // This is for convenience, you could also just call sampleSum() directly with larger intervals.

  sclass SpeedUp implements IAudioSample {

    double factor, invFactor;

    IAudioSample original;

    *(double *factor, IAudioSample *original) {

      if (factor < 1) fail("Can't slow down. " + factor);

      invFactor = 1/factor;

    }

    public double sampleRate() { ret original.sampleRate()*invFactor; }

    public int channels() { ret original.channels(); }

    public DoubleRange bounds() { ret scaleDoubleRange(original.bounds(), invFactor); }

    public double sampleSum(int channel, double start, double end) {

      ret original.sampleSum(channel, start*factor, end*factor)*invFactor;

    }

    // coalesce consecutive speed-ups

    public IAudioSample speedUp(double factor) {

      ret original.speedUp(this.factor*factor);

    }

  }

}