module Synthesizer.Inference.Func.Cut (
takeUntilPause,
concat,
concatVolume,
append,
zip,
arrange,
arrangeVolume,
) where
import qualified Synthesizer.Physical.Signal as SigP
import qualified Synthesizer.Physical.Cut as CutP
import qualified Synthesizer.Inference.Func.Signal as SigF
import qualified Synthesizer.SampleRateContext.Signal as SigC
import qualified Synthesizer.SampleRateContext.Rate as Rate
import qualified Synthesizer.SampleRateContext.Cut as CutC
import qualified Data.EventList.Relative.TimeBody as EventList
import qualified Numeric.NonNegative.Class as NonNeg
import qualified Algebra.NormedSpace.Maximum as NormedMax
import qualified Algebra.OccasionallyScalar as OccScalar
import qualified Algebra.Module as Module
import qualified Algebra.RealField as RealField
import qualified Algebra.Field as Field
import qualified Algebra.Real as Real
import qualified Algebra.Ring as Ring
import PreludeBase hiding (zip, zip3, concat, )
import Prelude (RealFrac)
takeUntilPause :: (RealField.C t, Ring.C t', OccScalar.C t t',
Field.C y', NormedMax.C y yv, OccScalar.C y y') =>
y' -> t' -> SigF.T t t' y y' yv -> SigF.T t t' y y' yv
takeUntilPause y' t' x =
SigF.cons $ \infered@(isr,iamp) ->
let x' = SigF.eval x infered
xp = SigP.replaceParameters isr iamp x'
zp = CutP.takeUntilPause y' t' xp
in SigP.replaceParameters
(SigP.sampleRate x') (SigP.amplitude x') zp
concat ::
(Eq t', Real.C y', Field.C y', Module.C y yv, OccScalar.C y y') =>
[SigF.T t t' y y' yv]
-> SigF.T t t' y y' yv
concat xs =
SigF.cons $ \(isr,iamp) ->
let xs' = zipWith (\x amp -> SigF.eval x (isr, amp)) xs amps
amps = map SigF.guessAmplitude xs'
xps = zipWith SigF.contextFixAmplitude amps xs'
sampleRate = SigF.mergeSampleRates xs'
in SigF.fromContextCheckAmplitude sampleRate iamp
(CutC.concat (Rate.fromNumber isr) xps)
concatVolume ::
(Eq t', Real.C y', Field.C y', Module.C y yv, OccScalar.C y y') =>
[SigF.T t t' y y' yv]
-> SigF.T t t' y y' yv
concatVolume xs =
SigF.cons $ \(isr,iamp) ->
let xs' = zipWith (\x amp -> SigF.eval x (isr, amp)) xs amps
amps = map SigF.guessAmplitude xs'
xps = zipWith SigF.contextFixAmplitude amps xs'
sampleRate = SigF.mergeSampleRates xs'
in SigF.fromContextFreeAmplitude sampleRate
(CutC.concatVolume iamp (Rate.fromNumber isr) xps)
merge :: (Eq t', Real.C y', Field.C y', OccScalar.C y y',
Module.C y v0, Module.C y v1) =>
(Rate.T t t' -> SigC.T y y' v0 -> SigC.T y y' v1 -> SigC.T y y' v2)
-> SigF.T t t' y y' v0
-> SigF.T t t' y y' v1
-> SigF.T t t' y y' v2
merge f x y =
SigF.cons $ \(isr,iamp) ->
let x' = SigF.eval x (isr, ampX)
y' = SigF.eval y (isr, ampY)
ampX = SigF.guessAmplitude x'
ampY = SigF.guessAmplitude y'
xp = SigF.contextFixAmplitude ampX x'
yp = SigF.contextFixAmplitude ampY y'
sampleRate = SigF.mergeSampleRate x' y'
in SigF.fromContextCheckAmplitude sampleRate iamp
(f (Rate.fromNumber isr) xp yp)
append :: (Eq t', Real.C y', Field.C y', OccScalar.C y y',
Module.C y yv) =>
SigF.T t t' y y' yv
-> SigF.T t t' y y' yv
-> SigF.T t t' y y' yv
append = merge CutC.append
zip :: (Eq t', Real.C y', Field.C y', OccScalar.C y y',
Module.C y v0, Module.C y v1) =>
SigF.T t t' y y' v0
-> SigF.T t t' y y' v1
-> SigF.T t t' y y' (v0,v1)
zip = merge CutC.zip
scheduleToContext ::
t'
-> EventList.T time (SigF.T t t' y y' yv)
-> (SigF.Parameter t',
EventList.T time (SigC.T y y' yv))
scheduleToContext isr sched =
let xps =
EventList.mapBody
(\x ->
let y = SigF.eval x (isr, amp)
amp = SigF.guessAmplitude y
z = SigF.contextFixAmplitude amp y
in (y,z)) sched
schedp = EventList.mapBody snd xps
sampleRate = SigF.mergeSampleRates (map fst (EventList.getBodies xps))
in (sampleRate, schedp)
arrange ::
(RealFrac t, NonNeg.C t, Eq t', Ring.C t, Ring.C t', OccScalar.C t t',
Ord y', Field.C y', OccScalar.C y y',
Module.C y yv) =>
t'
-> EventList.T t (SigF.T t t' y y' yv)
-> SigF.T t t' y y' yv
arrange unit sched =
SigF.cons $ \(isr,iamp) ->
let (sampleRate, schedp) = scheduleToContext isr sched
in SigF.fromContextCheckAmplitude sampleRate iamp
(CutC.arrange unit (Rate.fromNumber isr) schedp)
arrangeVolume ::
(RealFrac t, NonNeg.C t, Eq t', Ring.C t, Ring.C t', OccScalar.C t t',
Field.C y', OccScalar.C y y',
Module.C y yv) =>
t'
-> EventList.T t (SigF.T t t' y y' yv)
-> SigF.T t t' y y' yv
arrangeVolume unit sched =
SigF.cons $ \(isr,iamp) ->
let (sampleRate, schedp) = scheduleToContext isr sched
in SigF.fromContextFreeAmplitude sampleRate
(CutC.arrangeVolume iamp unit (Rate.fromNumber isr) schedp)