{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE Rank2Types #-}
module Synthesizer.MIDI.Dimensional.Example.Instrument where

import qualified Synthesizer.MIDI.Dimensional as MIDI
import qualified Synthesizer.MIDI.PiecewiseConstant as PC

import qualified Synthesizer.Dimensional.Causal.Process    as Causal
import qualified Synthesizer.Dimensional.Causal.Filter     as Filt

import qualified Synthesizer.Dimensional.Rate as Rate
import qualified Synthesizer.Dimensional.Rate.Cut as CutR
import qualified Synthesizer.Dimensional.Rate.Control as CtrlR
import qualified Synthesizer.Dimensional.Rate.Oscillator as OsciR
import qualified Synthesizer.Dimensional.Rate.Filter as FiltR
import qualified Synthesizer.Dimensional.Amplitude as Amp
import qualified Synthesizer.Dimensional.Amplitude.Cut as CutA
import qualified Synthesizer.Dimensional.Amplitude.Displacement as DispA
import qualified Synthesizer.Dimensional.Amplitude.Flat as Flat
import qualified Synthesizer.Dimensional.Amplitude.Analysis as AnaA
import qualified Synthesizer.Dimensional.Amplitude.Filter as FiltA
import qualified Synthesizer.Dimensional.RateAmplitude.Control as CtrlD
import qualified Synthesizer.Dimensional.ChunkySize.Signal as SigC
import qualified Synthesizer.Dimensional.Signal.Private as SigA
import qualified Synthesizer.Dimensional.Process as Proc

import Synthesizer.Dimensional.Causal.Process ((<<<), )
import Synthesizer.Dimensional.Wave ((&*~), )
import Synthesizer.Dimensional.Process (($:), )
import Synthesizer.Dimensional.Signal ((&*^), )
import Control.Applicative (liftA3, )

import qualified Synthesizer.Basic.Wave          as Wave
import qualified Synthesizer.Frame.Stereo        as Stereo

import qualified Synthesizer.Storable.Signal      as SigSt

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

import NumericPrelude.Numeric
import NumericPrelude.Base hiding (break, )


type Real = Double


{-# INLINE ping #-}
ping :: MIDI.Instrument s Dim.Time Dim.Voltage Real (SigSt.T Real)
ping :: forall s. Instrument s Time Voltage Real (T Real)
ping Real
vel T (Recip Time) Real
freq =
   forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall (sig :: * -> *) yv s amp.
Write sig yv =>
Size s -> Signal s amp (T yv) -> Signal s amp (sig yv)
SigC.store)
      (forall y0 flat u s t amp.
(C y0 flat, C y0, C u) =>
T s u t (Signal s flat y0 -> Signal s amp y0 -> Signal s amp y0)
FiltR.envelope
         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 (forall a. a -> Time a
DN.time Real
0.2)
         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
OsciR.static (forall a. a -> Voltage a
DN.voltage (Real
4forall a. C a => a -> a -> a
**Real
vel) forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.saw) forall a. C a => a
zero T (Recip Time) Real
freq)


{-
Generating the envelope requires great care:
 - you must avoid an append function that determines the common volume automatically,
   because the volume of the second part is only known after the first part is complete
 - you must terminate the release phase,
   otherwise you get an infinite signal for every played note
-}
{-# INLINE pingReleaseEnvelope #-}
pingReleaseEnvelope ::
   Real ->
   Proc.T s Dim.Time Real
      (MIDI.LazyTime s ->
       SigA.T (Rate.Phantom s) (Amp.Dimensional Dim.Scalar Real) (SigSt.T Real))
pingReleaseEnvelope :: forall s.
Real
-> T s
     Time
     Real
     (LazyTime s -> T (Phantom s) (Dimensional Scalar Real) (T Real))
pingReleaseEnvelope Real
vel =
   forall a s u t b. (a -> T s u t b) -> T s u t (a -> b)
Proc.withParam forall a b. (a -> b) -> a -> b
$ \LazyTime s
dur ->
   do Signal s (Flat Real) (T Real)
decay <-
         forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (sig :: * -> *) yv s amp.
Write sig yv =>
Size s -> Signal s amp (T yv) -> Signal s amp (sig yv)
SigC.store LazyTime s
dur) forall a b. (a -> b) -> a -> b
$
         forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 (forall a. a -> Time a
DN.time Real
0.4)
      Real
end <- forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall amp (sig :: * -> *) y rate.
(Primitive amp, Transform sig y) =>
y -> T rate amp (sig y) -> y
AnaA.endPrimitive forall a. C a => a
zero) forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a b. (a -> b) -> a -> b
$ Signal s (Flat Real) (T Real)
decay) forall u s t amp sig.
C u =>
T s u t (T (Phantom s) amp sig -> T (Dimensional u t) amp sig)
SigA.embedSampleRate
      Signal s (Flat Real) (T Real)
release <-
         forall t u yv s amp.
(C t, C u, Storable yv) =>
T u t
-> T s u t (T (Phantom s) amp (T yv) -> T (Phantom s) amp (T yv))
SigA.store (forall a. a -> Time a
DN.time Real
0.01) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$:
         (forall sig t u s amp.
(Transform sig, C t, C u) =>
T u t -> T s u t (Signal s amp sig -> Signal s amp sig)
CutR.take (forall a. a -> Time a
DN.time Real
0.3) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$:
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall y flat (sig :: * -> *) rate.
(C y flat, Transform sig y) =>
T rate flat (sig y) -> T rate (Flat y) (sig y)
Flat.canonicalize
            (forall a. a -> Scalar a
DN.scalar Real
end forall y flat (sig :: * -> *) amp s u t rate.
(C y flat, Transform sig y) =>
amp
-> T s u t (T rate flat (sig y))
-> T s u t (T rate (Numeric amp) (sig y))
&*^ forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 (forall a. a -> Time a
DN.time Real
0.1)))
      Signal s (Flat Real) (T Real)
-> Signal s (Flat Real) (T Real) -> Signal s (Flat Real) (T Real)
append <- forall amp sig u s t.
(Primitive amp, Monoid sig, C u) =>
T s u t (Signal s amp sig -> Signal s amp sig -> Signal s amp sig)
CutR.append
      forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall amp rate y sig.
amp -> T rate (Flat y) sig -> T rate (Numeric amp) sig
DispA.inflate (forall a. a -> Scalar a
DN.fromNumber forall a b. (a -> b) -> a -> b
$ Real
4forall a. C a => a -> a -> a
**Real
vel) (Signal s (Flat Real) (T Real)
-> Signal s (Flat Real) (T Real) -> Signal s (Flat Real) (T Real)
append Signal s (Flat Real) (T Real)
decay Signal s (Flat Real) (T Real)
release)
--      return $ DispA.inflate (DN.fromNumber $ 4**vel) decay

{-
   Proc.withParam $ \dur ->
   liftA2
      (\embed env ->
          let x = SigC.store dur env
              y = AnaA.end $ embed x
          in  )
      SigA.embedSampleRate
      (FiltR.envelope
         $: CtrlR.exponential2 (DN.time 0.2)
         $: OsciR.static (DN.voltage (4**vel) &*~ Wave.saw) zero freq)
-}

{-# INLINE pingRelease #-}
pingRelease :: MIDI.Instrument s Dim.Time Dim.Voltage Real (SigSt.T Real)
pingRelease :: forall s. Instrument s Time Voltage Real (T Real)
pingRelease Real
vel T (Recip Time) Real
freq =
   forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3
      (\T (Core s)
  (T (Dimensional Scalar Real) Real, Numeric (T Voltage Real) Real)
  (Numeric (T Voltage Real) Real)
env LazyTime s -> T (Phantom s) (Dimensional Scalar Real) (T Real)
ctrl T (Phantom s) (Dimensional Voltage Real) (T Real)
osci LazyTime s
dur ->
          forall (sig :: * -> *) yv0 yv1 s amp0 amp1.
(Transform sig yv0, Transform sig yv1) =>
Single s amp0 amp1 yv0 yv1
-> T (Phantom s) amp0 (sig yv0) -> T (Phantom s) amp1 (sig yv1)
Causal.apply
             (T (Core s)
  (T (Dimensional Scalar Real) Real, Numeric (T Voltage Real) Real)
  (Numeric (T Voltage Real) Real)
env forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<< forall (sig :: * -> *) yv s amp restSample.
Read sig yv =>
T (Phantom s) amp (sig yv) -> T s restSample (restSample, T amp yv)
Causal.feedSnd T (Phantom s) (Dimensional Voltage Real) (T Real)
osci)
             (LazyTime s -> T (Phantom s) (Dimensional Scalar Real) (T Real)
ctrl LazyTime s
dur))
      forall y u v s t.
(C y, C u, C v) =>
T s
  u
  t
  (T s
     (Dimensional Scalar y y, Dimensional v y y)
     (Dimensional v y y))
Filt.envelopeScalarDimension
      (forall s.
Real
-> T s
     Time
     Real
     (LazyTime s -> T (Phantom s) (Dimensional Scalar Real) (T Real))
pingReleaseEnvelope Real
vel)
      (forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
OsciR.static (forall a. a -> Voltage a
DN.voltage Real
1 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.saw) forall a. C a => a
zero T (Recip Time) Real
freq)


{-# INLINE pingReleaseFM #-}
pingReleaseFM ::
   MIDI.ModulatedInstrument s Dim.Time Real
      (MIDI.Signal s Dim.Scalar Real (SigSt.T Real) ->
       MIDI.Signal s Dim.Voltage Real (SigSt.T Real))
pingReleaseFM :: forall s.
ModulatedInstrument
  s
  Time
  Real
  (Signal s Scalar Real (T Real) -> Signal s Voltage Real (T Real))
pingReleaseFM Real
vel T (Recip Time) Real
freq =
   forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3
      (\T (Core s)
  (T (Dimensional Scalar Real) Real, Numeric (T Voltage Real) Real)
  (Numeric (T Voltage Real) Real)
env LazyTime s -> T (Phantom s) (Dimensional Scalar Real) (T Real)
ctrl T (Phantom s) (Dimensional (Recip Time) Real) (T Real)
-> T (Phantom s) (Dimensional Voltage Real) (T Real)
osci LazyTime s
dur T (Phantom s) (Dimensional Scalar Real) (T Real)
fm ->
          forall (sig :: * -> *) yv0 yv1 s amp0 amp1.
(Transform sig yv0, Transform sig yv1) =>
Single s amp0 amp1 yv0 yv1
-> T (Phantom s) amp0 (sig yv0) -> T (Phantom s) amp1 (sig yv1)
Causal.apply
             (T (Core s)
  (T (Dimensional Scalar Real) Real, Numeric (T Voltage Real) Real)
  (Numeric (T Voltage Real) Real)
env forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<<
              forall (sig :: * -> *) yv s amp restSample.
Read sig yv =>
T (Phantom s) amp (sig yv) -> T s restSample (restSample, T amp yv)
Causal.feedSnd (T (Phantom s) (Dimensional (Recip Time) Real) (T Real)
-> T (Phantom s) (Dimensional Voltage Real) (T Real)
osci (forall y v rate body.
(C y, C v) =>
T v y
-> T rate (Dimensional Scalar y) body
-> T rate (Dimensional v y) body
FiltA.amplifyScalarDimension T (Recip Time) Real
freq forall a b. (a -> b) -> a -> b
$ forall (sig :: * -> *) yv rate amp.
Read sig yv =>
T rate amp (sig yv) -> T rate amp (T yv)
SigA.restore T (Phantom s) (Dimensional Scalar Real) (T Real)
fm)))
             (LazyTime s -> T (Phantom s) (Dimensional Scalar Real) (T Real)
ctrl LazyTime s
dur))
      forall y u v s t.
(C y, C u, C v) =>
T s
  u
  t
  (T s
     (Dimensional Scalar y y, Dimensional v y y)
     (Dimensional v y y))
Filt.envelopeScalarDimension
      (forall s.
Real
-> T s
     Time
     Real
     (LazyTime s -> T (Phantom s) (Dimensional Scalar Real) (T Real))
pingReleaseEnvelope Real
vel)
      (forall t u amp y s.
(C t, C u) =>
T t (T amp y)
-> T t -> T s u t (R s (Recip u) t t -> Signal s amp y)
OsciR.freqMod (forall a. a -> Voltage a
DN.voltage Real
1 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.saw) forall a. C a => a
zero)


{-# INLINE pingStereoDetuneFM #-}
pingStereoDetuneFM ::
   MIDI.ModulatedInstrument s Dim.Time Real
      (MIDI.Signal s Dim.Scalar Real (PC.T Real) ->
       MIDI.Signal s Dim.Scalar Real (SigSt.T Real) ->
       MIDI.Signal s Dim.Voltage Real (SigSt.T (Stereo.T Real)))
pingStereoDetuneFM :: forall s.
ModulatedInstrument
  s
  Time
  Real
  (Signal s Scalar Real (T Real)
   -> Signal s Scalar Real (T Real)
   -> Signal s Voltage Real (T (T Real)))
pingStereoDetuneFM Real
vel T (Recip Time) Real
freq =
   forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3
      (\T (Core s)
  (T (Dimensional Scalar Real) Real,
   T (Dimensional Voltage Real) (T Real))
  (T (Dimensional (Mul Scalar Voltage) Real) (T Real))
env LazyTime s -> T (Phantom s) (Dimensional Scalar Real) (T Real)
ctrl T (Phantom s) (Dimensional (Recip Time) Real) (T Real)
-> Signal s Voltage Real T Real
osci LazyTime s
dur Signal s Scalar Real (T Real)
detuneSt T (Phantom s) (Dimensional Scalar Real) (T Real)
fmSt ->
          let fm :: T (Phantom s) (Dimensional Scalar Real) (T Real)
fm     = forall (sig :: * -> *) yv rate amp.
Read sig yv =>
T rate amp (sig yv) -> T rate amp (T yv)
SigA.restore T (Phantom s) (Dimensional Scalar Real) (T Real)
fmSt
              detune :: T (Phantom s) (Dimensional Scalar Real) (T Real)
detune = forall (sig :: * -> *) yv rate amp.
Read sig yv =>
T rate amp (sig yv) -> T rate amp (T yv)
SigA.restore Signal s Scalar Real (T Real)
detuneSt
              osciChan :: T (Phantom s) (Dimensional u Real) (T Real)
-> Signal s Voltage Real T Real
osciChan T (Phantom s) (Dimensional u Real) (T Real)
d =
                 T (Phantom s) (Dimensional (Recip Time) Real) (T Real)
-> Signal s Voltage Real T Real
osci (forall y v rate body.
(C y, C v) =>
T v y
-> T rate (Dimensional Scalar y) body
-> T rate (Dimensional v y) body
FiltA.amplifyScalarDimension T (Recip Time) Real
freq
                    (forall y flat s amp.
(C y flat, C y) =>
T (Phantom s) flat (T y)
-> T (Phantom s) amp (T y) -> T (Phantom s) amp (T y)
FiltA.envelope (forall y u rate.
(C y, C u) =>
T u y
-> T rate (Dimensional u y) (T y) -> T rate (Dimensional u y) (T y)
DispA.raise T u Real
1 T (Phantom s) (Dimensional u Real) (T Real)
d) T (Phantom s) (Dimensional Scalar Real) (T Real)
fm))
          in  forall v0 v1 rate y sig.
(C v0, C v1) =>
(v0 -> v1)
-> T rate (Dimensional v0 y) sig -> T rate (Dimensional v1 y) sig
SigA.rewriteAmplitudeDimension forall u. C u => Mul Scalar u -> u
Dim.identityLeft forall a b. (a -> b) -> a -> b
$
              forall (sig :: * -> *) yv0 yv1 s amp0 amp1.
(Transform sig yv0, Transform sig yv1) =>
Single s amp0 amp1 yv0 yv1
-> T (Phantom s) amp0 (sig yv0) -> T (Phantom s) amp1 (sig yv1)
Causal.apply
                 (T (Core s)
  (T (Dimensional Scalar Real) Real,
   T (Dimensional Voltage Real) (T Real))
  (T (Dimensional (Mul Scalar Voltage) Real) (T Real))
env forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<<
                  forall (sig :: * -> *) yv s amp restSample.
Read sig yv =>
T (Phantom s) amp (sig yv) -> T s restSample (restSample, T amp yv)
Causal.feedSnd (forall y u yv (sig :: * -> *) s.
(Ord y, C y, C u, C y yv, Transform sig yv,
 Transform sig (T yv)) =>
Signal s u y sig yv
-> Signal s u y sig yv -> Signal s u y sig (T yv)
CutA.mergeStereo
                     (forall {u}.
IsScalar u =>
T (Phantom s) (Dimensional u Real) (T Real)
-> Signal s Voltage Real T Real
osciChan T (Phantom s) (Dimensional Scalar Real) (T Real)
detune)
                     (forall {u}.
IsScalar u =>
T (Phantom s) (Dimensional u Real) (T Real)
-> Signal s Voltage Real T Real
osciChan forall a b. (a -> b) -> a -> b
$ forall (sig :: * -> *) yv rate amp.
(Transform sig yv, C yv) =>
T rate amp (sig yv) -> T rate amp (sig yv)
FiltA.negate T (Phantom s) (Dimensional Scalar Real) (T Real)
detune)))
                 (LazyTime s -> T (Phantom s) (Dimensional Scalar Real) (T Real)
ctrl LazyTime s
dur))
      forall y0 yv y u v0 v1 s t.
(C y0 yv, C y, C u, C v0, C v1) =>
T s
  u
  t
  (T s
     (Dimensional v0 y y0, Dimensional v1 y yv)
     (Dimensional (Mul v0 v1) y yv))
Filt.envelopeVectorDimension
      (forall s.
Real
-> T s
     Time
     Real
     (LazyTime s -> T (Phantom s) (Dimensional Scalar Real) (T Real))
pingReleaseEnvelope Real
vel)
      (forall t u amp y s.
(C t, C u) =>
T t (T amp y)
-> T t -> T s u t (R s (Recip u) t t -> Signal s amp y)
OsciR.freqMod (forall a. a -> Voltage a
DN.voltage Real
1 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.saw) forall a. C a => a
zero)


{- INLINE stringReleaseEnvelope -}
stringReleaseEnvelope ::
   Real ->
   Proc.T s Dim.Time Real
      (MIDI.LazyTime s ->
       SigA.T (Rate.Phantom s) (Amp.Dimensional Dim.Scalar Real) (SigSt.T Real))
stringReleaseEnvelope :: forall s.
Real
-> T s
     Time
     Real
     (LazyTime s -> T (Phantom s) (Dimensional Scalar Real) (T Real))
stringReleaseEnvelope Real
vel =
   forall a s u t b. (a -> T s u t b) -> T s u t (a -> b)
Proc.withParam forall a b. (a -> b) -> a -> b
$ \LazyTime s
dur ->
   do let attackTime :: Time Real
attackTime = forall a. a -> Time a
DN.time Real
1
      Signal s Real
cnst <- forall y u s t. (C y, C u) => T s u t (Signal s y)
CtrlR.constant
      {-
      release <- take attackTime beginning
      would yield a space leak, thus we first split 'beginning'
      and then concatenate it again
      -}
      {-
      We can not easily generate attack and sustain separately,
      because we want to use the chunk structure implied by 'dur'.
      -}
      (Signal s (Flat Real) (T Real)
attack, Signal s (Flat Real) (T Real)
sustain) <-
         forall sig t u s amp.
(Transform sig, C t, C u) =>
T u t
-> T s
     u
     t
     (Signal s amp sig -> (Signal s amp sig, Signal s amp sig))
CutR.splitAt Time Real
attackTime forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$:
         (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (sig :: * -> *) yv s amp.
Write sig yv =>
Size s -> Signal s amp (T yv) -> Signal s amp (sig yv)
SigC.store LazyTime s
dur forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                forall a b c. (a -> b -> c) -> b -> a -> c
flip forall sig amp s.
(Transform sig, Primitive amp) =>
T (Phantom s) amp sig
-> T (Phantom s) amp sig -> T (Phantom s) amp sig
CutA.appendPrimitive Signal s Real
cnst forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                forall amp y0 y1 rate.
Primitive amp =>
(y0 -> y1) -> T rate amp (T y0) -> T rate amp (T y1)
DispA.map forall a. C a => a -> a
sin forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall y flat (sig :: * -> *) rate.
(C y flat, Transform sig y) =>
T rate flat (sig y) -> T rate (Flat y) (sig y)
Flat.canonicalize)
            (forall q u v s.
(C q, C u, C v) =>
T u q -> (T v q, T v q) -> T s u q (R s v q q)
CtrlD.line Time Real
attackTime (Scalar Real
0, forall a. a -> Scalar a
DN.scalar (forall a. C a => a
piforall a. C a => a -> a -> a
/Real
2))))
      let release :: Signal s (Flat Real) (T Real)
release = forall (sig :: * -> *) yv rate amp.
Transform sig yv =>
T rate amp (sig yv) -> T rate amp (sig yv)
CutA.reverse Signal s (Flat Real) (T Real)
attack
--          infixr 5 append
      Signal s (Flat Real) (T Real)
-> Signal s (Flat Real) (T Real) -> Signal s (Flat Real) (T Real)
append <- forall amp sig u s t.
(Primitive amp, Monoid sig, C u) =>
T s u t (Signal s amp sig -> Signal s amp sig -> Signal s amp sig)
CutR.append
      forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$
         forall amp rate y sig.
amp -> T rate (Flat y) sig -> T rate (Numeric amp) sig
DispA.inflate (forall a. a -> Scalar a
DN.fromNumber forall a b. (a -> b) -> a -> b
$ Real
4forall a. C a => a -> a -> a
**Real
vel) forall a b. (a -> b) -> a -> b
$
         Signal s (Flat Real) (T Real)
attack Signal s (Flat Real) (T Real)
-> Signal s (Flat Real) (T Real) -> Signal s (Flat Real) (T Real)
`append` Signal s (Flat Real) (T Real)
sustain Signal s (Flat Real) (T Real)
-> Signal s (Flat Real) (T Real) -> Signal s (Flat Real) (T Real)
`append` Signal s (Flat Real) (T Real)
release

{- INLINE string -}
string ::
   MIDI.ModulatedInstrument s Dim.Time Real
      (MIDI.Signal s Dim.Voltage Real (SigSt.T (Stereo.T Real)))
string :: forall s.
ModulatedInstrument
  s Time Real (Signal s Voltage Real (T (T Real)))
string Real
vel T (Recip Time) Real
freq =
   forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3
      (\T (Core s)
  (T (Dimensional Scalar Real) Real,
   T (Dimensional Voltage Real) (T Real))
  (T (Dimensional (Mul Scalar Voltage) Real) (T Real))
env LazyTime s -> T (Phantom s) (Dimensional Scalar Real) (T Real)
ctrl T (Phantom s) (Dimensional Voltage Real) (T (T Real))
osci LazyTime s
dur ->
          forall v0 v1 rate y sig.
(C v0, C v1) =>
(v0 -> v1)
-> T rate (Dimensional v0 y) sig -> T rate (Dimensional v1 y) sig
SigA.rewriteAmplitudeDimension forall u. C u => Mul Scalar u -> u
Dim.identityLeft forall a b. (a -> b) -> a -> b
$
          forall (sig :: * -> *) yv0 yv1 s amp0 amp1.
(Transform sig yv0, Transform sig yv1) =>
Single s amp0 amp1 yv0 yv1
-> T (Phantom s) amp0 (sig yv0) -> T (Phantom s) amp1 (sig yv1)
Causal.apply
             (T (Core s)
  (T (Dimensional Scalar Real) Real,
   T (Dimensional Voltage Real) (T Real))
  (T (Dimensional (Mul Scalar Voltage) Real) (T Real))
env forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<< forall (sig :: * -> *) yv s amp restSample.
Read sig yv =>
T (Phantom s) amp (sig yv) -> T s restSample (restSample, T amp yv)
Causal.feedSnd T (Phantom s) (Dimensional Voltage Real) (T (T Real))
osci)
             (LazyTime s -> T (Phantom s) (Dimensional Scalar Real) (T Real)
ctrl LazyTime s
dur))
      forall y0 yv y u v0 v1 s t.
(C y0 yv, C y, C u, C v0, C v1) =>
T s
  u
  t
  (T s
     (Dimensional v0 y y0, Dimensional v1 y yv)
     (Dimensional (Mul v0 v1) y yv))
Filt.envelopeVectorDimension
      (forall s.
Real
-> T s
     Time
     Real
     (LazyTime s -> T (Phantom s) (Dimensional Scalar Real) (T Real))
stringReleaseEnvelope Real
vel)
      (forall a s u t. a -> T s u t a
Proc.pure forall y u yv (sig :: * -> *) s.
(Ord y, C y, C u, C y yv, Transform sig yv,
 Transform sig (T yv)) =>
Signal s u y sig yv
-> Signal s u y sig yv -> Signal s u y sig (T yv)
CutA.mergeStereo
         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall a s u t. a -> T s u t a
Proc.pure forall y yv u s.
(C y, C y, C y yv, C u) =>
R s u y yv -> R s u y yv -> R s u y yv
DispA.mix
              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
OsciR.static (forall a. a -> Voltage a
DN.voltage Real
0.5 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.saw) forall a. C a => a
zero (forall u a. (C u, C a) => a -> T u a -> T u a
DN.scale Real
1.005 T (Recip Time) Real
freq)
              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
OsciR.static (forall a. a -> Voltage a
DN.voltage Real
0.5 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.saw) forall a. C a => a
zero (forall u a. (C u, C a) => a -> T u a -> T u a
DN.scale Real
0.998 T (Recip Time) Real
freq))
         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall a s u t. a -> T s u t a
Proc.pure forall y yv u s.
(C y, C y, C y yv, C u) =>
R s u y yv -> R s u y yv -> R s u y yv
DispA.mix
              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
OsciR.static (forall a. a -> Voltage a
DN.voltage Real
0.5 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.saw) forall a. C a => a
zero (forall u a. (C u, C a) => a -> T u a -> T u a
DN.scale Real
1.002 T (Recip Time) Real
freq)
              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
OsciR.static (forall a. a -> Voltage a
DN.voltage Real
0.5 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.saw) forall a. C a => a
zero (forall u a. (C u, C a) => a -> T u a -> T u a
DN.scale Real
0.995 T (Recip Time) Real
freq)))