@blibliki/engine 0.5.1 → 0.9.0

package/src/modules/index.ts

@@ -5,27 +5,45 @@ import VoiceScheduler, {
   IVoiceSchedulerProps,
   voiceSchedulerPropSchema,
 } from "@/core/module/VoiceScheduler";
+import Chorus, { chorusPropSchema, IChorusProps } from "./Chorus";
 import Constant, { constantPropSchema, IConstantProps } from "./Constant";
-import Envelope, { envelopePropSchema, IEnvelopeProps } from "./Envelope";
+import Delay, { delayPropSchema, IDelayProps } from "./Delay";
+import Distortion, {
+  distortionPropSchema,
+  IDistortionProps,
+} from "./Distortion";
+import CustomEnvelope, {
+  customEnvelopePropSchema,
+  ICustomEnvelopeProps,
+} from "./Envelope";
 import Filter, { filterPropSchema, IFilterProps } from "./Filter";
 import Gain, { gainPropSchema, IGainProps } from "./Gain";
 import Inspector, { IInspectorProps, inspectorPropSchema } from "./Inspector";
+import LFO, { ILFOProps, lfoPropSchema } from "./LFO";
+import LegacyEnvelope, {
+  envelopePropSchema as legacyEnvelopePropSchema,
+  IEnvelopeProps as ILegacyEnvelopeProps,
+} from "./LegacyEnvelope";
 import Master, { IMasterProps, masterPropSchema } from "./Master";
+import MidiInput, { IMidiInputProps, midiInputPropSchema } from "./MidiInput";
 import MidiMapper, {
   IMidiMapperProps,
   midiMapperPropSchema,
 } from "./MidiMapper";
-import MidiSelector, {
-  IMidiSelectorProps,
-  midiSelectorPropSchema,
-} from "./MidiSelector";
+import MidiOutput, {
+  IMidiOutputProps,
+  midiOutputPropSchema,
+} from "./MidiOutput";
+import Noise, { INoiseProps, noisePropSchema } from "./Noise";
 import Oscillator, {
   IOscillatorProps,
   oscillatorPropSchema,
 } from "./Oscillator";
+import Reverb, { IReverbProps, reverbPropSchema } from "./Reverb";
 import Scale, { IScaleProps, scalePropSchema } from "./Scale";
 import StepSequencer, {
   IStepSequencerProps,
+  IStepSequencerState,
   stepSequencerPropSchema,
 } from "./StepSequencer";
 import StereoPanner, {
@@ -41,83 +59,157 @@ export enum ModuleType {
   Master = "Master",
   Oscillator = "Oscillator",
   Gain = "Gain",
-  MidiSelector = "MidiSelector",
+  MidiInput = "MidiInput",
+  MidiOutput = "MidiOutput",
+  LegacyEnvelope = "LegacyEnvelope", // BACKWARD_COMPAT: Legacy envelope for old patches
   Envelope = "Envelope",
   Filter = "Filter",
   Scale = "Scale",
   StereoPanner = "StereoPanner",
   Inspector = "Inspector",
+  Chorus = "Chorus",
   Constant = "Constant",
+  Delay = "Delay",
+  Distortion = "Distortion",
   MidiMapper = "MidiMapper",
   VirtualMidi = "VirtualMidi",
   StepSequencer = "StepSequencer",
   VoiceScheduler = "VoiceScheduler",
+  LFO = "LFO",
+  Noise = "Noise",
+  Reverb = "Reverb",
 }
 
 export type ModuleTypeToPropsMapping = {
   [ModuleType.Oscillator]: IOscillatorProps;
   [ModuleType.Gain]: IGainProps;
   [ModuleType.Master]: IMasterProps;
-  [ModuleType.MidiSelector]: IMidiSelectorProps;
-  [ModuleType.Envelope]: IEnvelopeProps;
+  [ModuleType.MidiInput]: IMidiInputProps;
+  [ModuleType.MidiOutput]: IMidiOutputProps;
+  [ModuleType.LegacyEnvelope]: ILegacyEnvelopeProps; // BACKWARD_COMPAT: Legacy envelope for old patches
+  [ModuleType.Envelope]: ICustomEnvelopeProps;
   [ModuleType.Filter]: IFilterProps;
   [ModuleType.Scale]: IScaleProps;
   [ModuleType.StereoPanner]: IStereoPannerProps;
   [ModuleType.Inspector]: IInspectorProps;
+  [ModuleType.Chorus]: IChorusProps;
   [ModuleType.Constant]: IConstantProps;
+  [ModuleType.Delay]: IDelayProps;
+  [ModuleType.Distortion]: IDistortionProps;
   [ModuleType.MidiMapper]: IMidiMapperProps;
   [ModuleType.VirtualMidi]: IVirtualMidiProps;
   [ModuleType.StepSequencer]: IStepSequencerProps;
   [ModuleType.VoiceScheduler]: IVoiceSchedulerProps;
+  [ModuleType.LFO]: ILFOProps;
+  [ModuleType.Noise]: INoiseProps;
+  [ModuleType.Reverb]: IReverbProps;
+};
+
+export type ModuleTypeToStateMapping = {
+  [ModuleType.Oscillator]: never;
+  [ModuleType.Gain]: never;
+  [ModuleType.Master]: never;
+  [ModuleType.MidiInput]: never;
+  [ModuleType.MidiOutput]: never;
+  [ModuleType.LegacyEnvelope]: never;
+  [ModuleType.Envelope]: never;
+  [ModuleType.Filter]: never;
+  [ModuleType.Scale]: never;
+  [ModuleType.StereoPanner]: never;
+  [ModuleType.Inspector]: never;
+  [ModuleType.Chorus]: never;
+  [ModuleType.Constant]: never;
+  [ModuleType.Delay]: never;
+  [ModuleType.Distortion]: never;
+  [ModuleType.MidiMapper]: never;
+  [ModuleType.VirtualMidi]: never;
+  [ModuleType.StepSequencer]: IStepSequencerState;
+  [ModuleType.VoiceScheduler]: never;
+  [ModuleType.LFO]: never;
+  [ModuleType.Noise]: never;
+  [ModuleType.Reverb]: never;
 };
 
 export type ModuleTypeToModuleMapping = {
   [ModuleType.Oscillator]: Oscillator;
   [ModuleType.Gain]: Gain;
   [ModuleType.Master]: Master;
-  [ModuleType.MidiSelector]: MidiSelector;
-  [ModuleType.Envelope]: Envelope;
+  [ModuleType.MidiInput]: MidiInput;
+  [ModuleType.MidiOutput]: MidiOutput;
+  [ModuleType.LegacyEnvelope]: LegacyEnvelope; // BACKWARD_COMPAT: Legacy envelope for old patches
+  [ModuleType.Envelope]: CustomEnvelope;
   [ModuleType.Filter]: Filter;
   [ModuleType.Scale]: Scale;
   [ModuleType.StereoPanner]: StereoPanner;
   [ModuleType.Inspector]: Inspector;
+  [ModuleType.Chorus]: Chorus;
   [ModuleType.Constant]: Constant;
+  [ModuleType.Delay]: Delay;
+  [ModuleType.Distortion]: Distortion;
   [ModuleType.MidiMapper]: MidiMapper;
   [ModuleType.VirtualMidi]: VirtualMidi;
   [ModuleType.StepSequencer]: StepSequencer;
   [ModuleType.VoiceScheduler]: VoiceScheduler;
+  [ModuleType.LFO]: LFO;
+  [ModuleType.Noise]: Noise;
+  [ModuleType.Reverb]: Reverb;
 };
 
 export const moduleSchemas = {
   [ModuleType.Oscillator]: oscillatorPropSchema,
   [ModuleType.Gain]: gainPropSchema,
   [ModuleType.Master]: masterPropSchema,
-  [ModuleType.MidiSelector]: midiSelectorPropSchema,
-  [ModuleType.Envelope]: envelopePropSchema,
+  [ModuleType.MidiInput]: midiInputPropSchema,
+  [ModuleType.MidiOutput]: midiOutputPropSchema,
+  [ModuleType.LegacyEnvelope]: legacyEnvelopePropSchema, // BACKWARD_COMPAT: Legacy envelope for old patches
+  [ModuleType.Envelope]: customEnvelopePropSchema,
   [ModuleType.Filter]: filterPropSchema,
   [ModuleType.Scale]: scalePropSchema,
   [ModuleType.StereoPanner]: stereoPannerPropSchema,
   [ModuleType.Inspector]: inspectorPropSchema,
+  [ModuleType.Chorus]: chorusPropSchema,
   [ModuleType.Constant]: constantPropSchema,
+  [ModuleType.Delay]: delayPropSchema,
+  [ModuleType.Distortion]: distortionPropSchema,
   [ModuleType.MidiMapper]: midiMapperPropSchema,
   [ModuleType.VirtualMidi]: virtualMidiPropSchema,
   [ModuleType.StepSequencer]: stepSequencerPropSchema,
   [ModuleType.VoiceScheduler]: voiceSchedulerPropSchema,
+  [ModuleType.LFO]: lfoPropSchema,
+  [ModuleType.Noise]: noisePropSchema,
+  [ModuleType.Reverb]: reverbPropSchema,
 };
 
 export type { IOscillator } from "./Oscillator";
 export { OscillatorWave } from "./Oscillator";
 export type { IGain } from "./Gain";
 export type { IMaster } from "./Master";
-export type { IMidiSelector } from "./MidiSelector";
+export type { IMidiInput, IMidiInputProps } from "./MidiInput";
+export type { IMidiOutput, IMidiOutputProps } from "./MidiOutput";
 export type { IStereoPanner } from "./StereoPanner";
 export type {
   IStepSequencer,
   IStepSequencerProps,
-  ISequence,
+  IStepSequencerState,
+  IStep,
+  IPage,
+  IPattern,
+  IStepNote,
+  IStepCC,
 } from "./StepSequencer";
+export { Resolution, PlaybackMode, stepPropSchema } from "./StepSequencer";
 export type { IMidiMapper, IMidiMapperProps, MidiMapping } from "./MidiMapper";
 export { MidiMappingMode } from "./MidiMapper";
+export type { ILFO, ILFOProps } from "./LFO";
+export { LFOWaveform } from "./LFO";
+export type { INoise } from "./Noise";
+export { NoiseType } from "./Noise";
+export type { IReverb, IReverbProps } from "./Reverb";
+export { ReverbType } from "./Reverb";
+export { DelayTimeMode } from "./Delay";
+export type { IDelay, IDelayProps } from "./Delay";
+export type { IDistortion, IDistortionProps } from "./Distortion";
+export type { IChorus, IChorusProps } from "./Chorus";
 
 export type AnyModule = Module<ModuleType>;
 export type IAnyModule = IModule<ModuleType>;
@@ -133,10 +225,14 @@ export type ModuleParams = {
   [K in ModuleType]: K extends
     | ModuleType.Oscillator
     | ModuleType.Gain
+    | ModuleType.LegacyEnvelope
     | ModuleType.Envelope
     | ModuleType.Filter
     | ModuleType.StereoPanner
     | ModuleType.VoiceScheduler
+    | ModuleType.Scale
+    | ModuleType.LFO
+    | ModuleType.Distortion
     ? IPolyModuleConstructor<K>
     : ICreateModule<K>;
 }[ModuleType];
@@ -147,33 +243,50 @@ export function createModule(
 ): ModuleTypeToModuleMapping[keyof ModuleTypeToModuleMapping] {
   switch (params.moduleType) {
     case ModuleType.Oscillator:
-      return new Oscillator(engineId, params);
+      return Oscillator.create(Oscillator, engineId, params);
     case ModuleType.Gain:
-      return new Gain(engineId, params);
+      return Gain.create(Gain, engineId, params);
     case ModuleType.Master:
-      return new Master(engineId, params);
-    case ModuleType.MidiSelector:
-      return new MidiSelector(engineId, params);
+      return Master.create(Master, engineId, params);
+    case ModuleType.MidiInput:
+      return MidiInput.create(MidiInput, engineId, params);
+    case ModuleType.MidiOutput:
+      return MidiOutput.create(MidiOutput, engineId, params);
+    // BACKWARD_COMPAT: Legacy envelope for old patches
+    case ModuleType.LegacyEnvelope:
+      return LegacyEnvelope.create(LegacyEnvelope, engineId, params);
     case ModuleType.Envelope:
-      return new Envelope(engineId, params);
+      return CustomEnvelope.create(CustomEnvelope, engineId, params);
     case ModuleType.Filter:
-      return new Filter(engineId, params);
+      return Filter.create(Filter, engineId, params);
     case ModuleType.Scale:
-      return new Scale(engineId, params);
+      return Scale.create(Scale, engineId, params);
     case ModuleType.StereoPanner:
-      return new StereoPanner(engineId, params);
+      return StereoPanner.create(StereoPanner, engineId, params);
     case ModuleType.Inspector:
-      return new Inspector(engineId, params);
+      return Inspector.create(Inspector, engineId, params);
+    case ModuleType.Chorus:
+      return Chorus.create(Chorus, engineId, params);
     case ModuleType.Constant:
-      return new Constant(engineId, params);
+      return Constant.create(Constant, engineId, params);
+    case ModuleType.Delay:
+      return Delay.create(Delay, engineId, params);
+    case ModuleType.Distortion:
+      return Distortion.create(Distortion, engineId, params);
     case ModuleType.MidiMapper:
-      return new MidiMapper(engineId, params);
+      return MidiMapper.create(MidiMapper, engineId, params);
     case ModuleType.VirtualMidi:
-      return new VirtualMidi(engineId, params);
+      return VirtualMidi.create(VirtualMidi, engineId, params);
     case ModuleType.StepSequencer:
-      return new StepSequencer(engineId, params);
+      return StepSequencer.create(StepSequencer, engineId, params);
     case ModuleType.VoiceScheduler:
-      return new VoiceScheduler(engineId, params);
+      return VoiceScheduler.create(VoiceScheduler, engineId, params);
+    case ModuleType.LFO:
+      return LFO.create(LFO, engineId, params);
+    case ModuleType.Noise:
+      return Noise.create(Noise, engineId, params);
+    case ModuleType.Reverb:
+      return Reverb.create(Reverb, engineId, params);
     default:
       assertNever(params);
   }

package/src/processors/custom-envelope-processor.ts

@@ -0,0 +1,125 @@
+export const customEnvelopeProcessorURL = URL.createObjectURL(
+  new Blob(
+    [
+      "(",
+      (() => {
+        class CustomEnvelopeProcessor extends AudioWorkletProcessor {
+          private _lasttrig = 0;
+          private _trig = 0;
+          private _phase = 0;
+          private _value = 0;
+
+          static get parameterDescriptors() {
+            return [
+              {
+                name: "attack",
+                defaultValue: 0.1,
+                minValue: 0,
+                maxValue: 60,
+                automationRate: "k-rate",
+              },
+              {
+                name: "attackcurve",
+                defaultValue: 0.5,
+                minValue: 0,
+                maxValue: 1,
+                automationRate: "k-rate",
+              },
+              {
+                name: "decay",
+                defaultValue: 0.1,
+                minValue: 0,
+                maxValue: 60,
+                automationRate: "k-rate",
+              },
+              {
+                name: "sustain",
+                defaultValue: 1,
+                minValue: 0,
+                maxValue: 1,
+                automationRate: "k-rate",
+              },
+              {
+                name: "release",
+                defaultValue: 0.1,
+                minValue: 0,
+                maxValue: 60,
+                automationRate: "k-rate",
+              },
+              {
+                name: "trigger",
+                defaultValue: 0,
+                minValue: 0,
+                maxValue: 1,
+                automationRate: "a-rate",
+              },
+            ];
+          }
+
+          process(
+            _inputs: Float32Array[][],
+            outputs: Float32Array[][],
+            parameters: Record<string, Float32Array>,
+          ) {
+            const output = outputs[0];
+            if (!output?.[0]) return true;
+
+            const trigs = parameters.trigger;
+            const atk = parameters.attack![0]!;
+            const dec = parameters.decay![0]!;
+            const sus = parameters.sustain![0]!;
+            const rel = parameters.release![0]!;
+            const atkmax = 1.01 / Math.max(0.01, parameters.attackcurve![0]!);
+            const atkRatio =
+              1 - Math.pow(1 - 1 / atkmax, 1 / (sampleRate * atk));
+            const decRatio = 1 - Math.pow(0.36787944, 1 / (sampleRate * dec));
+            const relRatio = 1 - Math.pow(0.36787944, 1 / (sampleRate * rel));
+
+            if (trigs?.length === 1) this._trig = trigs[0]!;
+
+            for (let i = 0; i < output[0].length; ++i) {
+              if (trigs && trigs.length > 1) this._trig = trigs[i]!;
+
+              // Trigger detection
+              if (this._trig >= 0.5) {
+                if (this._lasttrig < 0.5) this._phase = 1;
+              } else {
+                this._phase = 0;
+              }
+
+              // Attack phase
+              if (this._phase === 1) {
+                this._value += (atkmax - this._value) * atkRatio;
+                if (this._value >= 1.0) {
+                  this._value = 1.0;
+                  this._phase = 0;
+                }
+              }
+              // Decay phase (only while trigger is held)
+              else if (this._trig >= 0.5 && this._value > sus) {
+                this._value += (sus - this._value) * decRatio;
+              }
+
+              // Release phase
+              if (this._trig < 0.5) {
+                this._value += -this._value * relRatio;
+              }
+
+              for (const channel of output) {
+                channel[i] = this._value;
+              }
+
+              this._lasttrig = this._trig;
+            }
+
+            return true;
+          }
+        }
+
+        registerProcessor("custom-envelope-processor", CustomEnvelopeProcessor);
+      }).toString(),
+      ")()",
+    ],
+    { type: "application/javascript" },
+  ),
+);

package/src/processors/index.ts

@@ -1,15 +1,21 @@
 import { assertNever, Context } from "@blibliki/utils";
+import { customEnvelopeProcessorURL } from "./custom-envelope-processor";
 import { filterProcessorURL } from "./filter-processor";
+import { lfoProcessorURL } from "./lfo-processor";
 import { scaleProcessorURL } from "./scale-processor";
 
 export enum CustomWorklet {
   ScaleProcessor = "ScaleProcessor",
   FilterProcessor = "FilterProcessor",
+  LFOProcessor = "LFOProcessor",
+  CustomEnvelopeProcessor = "CustomEnvelopeProcessor",
 }
 
 export async function loadProcessors(context: Context) {
   await context.addModule(scaleProcessorURL);
   await context.addModule(filterProcessorURL);
+  await context.addModule(lfoProcessorURL);
+  await context.addModule(customEnvelopeProcessorURL);
 }
 
 export function newAudioWorklet(context: Context, worklet: CustomWorklet) {
@@ -18,6 +24,10 @@ export function newAudioWorklet(context: Context, worklet: CustomWorklet) {
       return context.newAudioWorklet("scale-processor");
     case CustomWorklet.FilterProcessor:
       return context.newAudioWorklet("filter-processor");
+    case CustomWorklet.LFOProcessor:
+      return context.newAudioWorklet("lfo-processor");
+    case CustomWorklet.CustomEnvelopeProcessor:
+      return context.newAudioWorklet("custom-envelope-processor");
     default:
       assertNever(worklet);
   }

package/src/processors/lfo-processor.ts

@@ -0,0 +1,123 @@
+export const lfoProcessorURL = URL.createObjectURL(
+  new Blob(
+    [
+      "(",
+      (() => {
+        class LFOProcessor extends AudioWorkletProcessor {
+          private phase = 0;
+          private randomValue = Math.random() * 2 - 1;
+
+          static get parameterDescriptors() {
+            return [
+              {
+                name: "frequency",
+                defaultValue: 1.0,
+                minValue: 0.01,
+                maxValue: 100,
+              },
+              {
+                name: "waveform",
+                defaultValue: 0, // 0=sine, 1=triangle, 2=square, 3=sawtooth, 4=rampDown, 5=random
+                minValue: 0,
+                maxValue: 5,
+              },
+              {
+                name: "phase",
+                defaultValue: 0.0,
+                minValue: 0.0,
+                maxValue: 1.0,
+              },
+            ];
+          }
+
+          process(
+            _inputs: Float32Array[][],
+            outputs: Float32Array[][],
+            parameters: Record<string, Float32Array>,
+          ) {
+            const output = outputs[0];
+            if (!output) return true;
+
+            const frequencyValues = parameters.frequency;
+            const waveformValues = parameters.waveform;
+            const phaseValues = parameters.phase;
+
+            if (!frequencyValues || !waveformValues || !phaseValues)
+              return true;
+
+            const blockSize = output[0]?.length ?? 128;
+
+            for (let i = 0; i < blockSize; i++) {
+              // Get parameter values (can be per-sample or per-block)
+              const frequency =
+                frequencyValues.length > 1
+                  ? (frequencyValues[i] ?? 1.0)
+                  : (frequencyValues[0] ?? 1.0);
+              const waveformIdx = Math.round(
+                waveformValues.length > 1
+                  ? (waveformValues[i] ?? 0)
+                  : (waveformValues[0] ?? 0),
+              );
+              const phaseOffset =
+                phaseValues.length > 1
+                  ? (phaseValues[i] ?? 0)
+                  : (phaseValues[0] ?? 0);
+
+              // Calculate current phase with offset
+              const currentPhase = (this.phase + phaseOffset) % 1.0;
+
+              // Generate sample based on waveform type
+              let sample = 0;
+              switch (waveformIdx) {
+                case 0: // Sine
+                  sample = Math.sin(2 * Math.PI * currentPhase);
+                  break;
+                case 1: // Triangle
+                  sample = 2 * Math.abs(2 * currentPhase - 1) - 1;
+                  break;
+                case 2: // Square
+                  sample = currentPhase < 0.5 ? 1 : -1;
+                  break;
+                case 3: // Sawtooth
+                  sample = 2 * currentPhase - 1;
+                  break;
+                case 4: // Ramp Down
+                  sample = 1 - 2 * currentPhase;
+                  break;
+                case 5: // Random (sample & hold)
+                  sample = this.randomValue;
+                  break;
+                default:
+                  sample = Math.sin(2 * Math.PI * currentPhase);
+              }
+
+              // Write to all output channels
+              for (const channel of output) {
+                channel[i] = sample;
+              }
+
+              // Update phase
+              const phaseIncrement = frequency / sampleRate;
+              this.phase += phaseIncrement;
+
+              // Wrap phase and update random value on wrap
+              if (this.phase >= 1.0) {
+                this.phase -= 1.0;
+                // Update random value only for random waveform
+                if (waveformIdx === 5) {
+                  this.randomValue = Math.random() * 2 - 1;
+                }
+              }
+            }
+
+            return true;
+          }
+        }
+
+        registerProcessor("lfo-processor", LFOProcessor);
+      }).toString(),
+      ")()",
+    ],
+    { type: "application/javascript" },
+  ),
+);

package/src/processors/scale-processor.ts

@@ -18,6 +18,10 @@ export const scaleProcessorURL = URL.createObjectURL(
                 name: "current",
                 defaultValue: 0.5,
               },
+              {
+                name: "mode",
+                defaultValue: 0, // 0 = exponential, 1 = linear
+              },
             ];
           }
 
@@ -33,7 +37,9 @@ export const scaleProcessorURL = URL.createObjectURL(
             const minValues = parameters.min;
             const maxValues = parameters.max;
             const currentValues = parameters.current;
-            if (!minValues || !maxValues || !currentValues) return true;
+            const modeValues = parameters.mode;
+            if (!minValues || !maxValues || !currentValues || !modeValues)
+              return true;
 
             const firstInput = input[0];
             if (!firstInput || firstInput.length === 0) {
@@ -70,18 +76,49 @@ export const scaleProcessorURL = URL.createObjectURL(
                   currentValues.length > 1
                     ? (currentValues[i] ?? currentValues[0])
                     : currentValues[0];
+                const mode =
+                  modeValues.length > 1
+                    ? (modeValues[i] ?? modeValues[0])
+                    : modeValues[0];
 
                 if (
                   min === undefined ||
                   max === undefined ||
-                  current === undefined
+                  current === undefined ||
+                  mode === undefined
                 )
                   continue;
 
-                if (x < 0) {
-                  outputChannel[i] = current * Math.pow(min / current, -x);
+                const isLinearMode = mode >= 0.5; // 0 = exponential, 1 = linear
+
+                if (isLinearMode) {
+                  // Linear interpolation
+                  if (x < 0) {
+                    outputChannel[i] = current + -x * (min - current);
+                  } else {
+                    outputChannel[i] = current + x * (max - current);
+                  }
                 } else {
-                  outputChannel[i] = current * Math.pow(max / current, x);
+                  // Exponential scaling
+                  // Handle edge cases where exponential would fail
+                  if (
+                    current === 0 ||
+                    (x < 0 && min === 0) ||
+                    (x > 0 && max === 0)
+                  ) {
+                    // Fallback to linear for invalid exponential cases
+                    if (x < 0) {
+                      outputChannel[i] = current + -x * (min - current);
+                    } else {
+                      outputChannel[i] = current + x * (max - current);
+                    }
+                  } else {
+                    if (x < 0) {
+                      outputChannel[i] = current * Math.pow(min / current, -x);
+                    } else {
+                      outputChannel[i] = current * Math.pow(max / current, x);
+                    }
+                  }
                 }
               }
             }