{-# LANGUAGE NoImplicitPrelude #-}
{- |
Functions for converting MIDI controller and key values
to something meaningful for signal processing.
-}
module Synthesizer.MIDI.Dimensional.Value (
   controllerLinear,
   controllerExponential,
   pitchBend,
   MV.frequencyFromPitch,
   ) where

import qualified Synthesizer.MIDI.Dimensional.ValuePlain as MV

import qualified Algebra.DimensionTerm as Dim
import qualified Number.DimensionTerm as DN

import qualified Algebra.Transcendental as Trans
import qualified Algebra.Field          as Field
-- import qualified Algebra.Additive       as Additive

import NumericPrelude.Numeric
-- import NumericPrelude.Base


{-# INLINE controllerLinear #-}
controllerLinear ::
   (Field.C y, Dim.C v) =>
   DN.T v y -> (DN.T v y, DN.T v y) -> Int -> y
controllerLinear :: forall y v. (C y, C v) => T v y -> (T v y, T v y) -> Int -> y
controllerLinear T v y
amp (T v y, T v y)
bnd Int
n =
   forall u a. (C u, C a) => T u a -> T u a -> a
DN.divToScalar (forall y v. (C y, C v) => (T v y, T v y) -> Int -> T v y
MV.controllerLinear (T v y, T v y)
bnd Int
n) T v y
amp

{-# INLINE controllerExponential #-}
controllerExponential ::
   (Trans.C y, Dim.C v) =>
   DN.T v y -> (DN.T v y, DN.T v y) -> Int -> y
controllerExponential :: forall y v. (C y, C v) => T v y -> (T v y, T v y) -> Int -> y
controllerExponential T v y
amp (T v y, T v y)
bnd Int
n =
   forall u a. (C u, C a) => T u a -> T u a -> a
DN.divToScalar (forall y v. (C y, C v) => (T v y, T v y) -> Int -> T v y
MV.controllerExponential (T v y, T v y)
bnd Int
n) T v y
amp

{-# INLINE pitchBend #-}
pitchBend ::
   (Trans.C y, Dim.C v) =>
   DN.T v y -> y -> DN.T v y -> Int -> y
pitchBend :: forall y v. (C y, C v) => T v y -> y -> T v y -> Int -> y
pitchBend T v y
amp y
range T v y
center Int
n =
   forall u a. (C u, C a) => T u a -> T u a -> a
DN.divToScalar (forall y v. (C y, C v) => y -> T v y -> Int -> T v y
MV.pitchBend y
range T v y
center Int
n) T v y
amp