module Synthesizer.Plain.Effect where

import qualified Synthesizer.Plain.Noise as Noise
import qualified Synthesizer.Plain.Filter.Recursive as Filter
import qualified Synthesizer.Plain.Filter.Recursive.FirstOrder  as Filt1
import qualified Synthesizer.Plain.Filter.Recursive.Moog        as Moog
import qualified Synthesizer.Plain.Filter.Recursive.Comb        as Comb
import qualified Synthesizer.Plain.Filter.Recursive.Butterworth as Butter
import qualified Synthesizer.Plain.Filter.Recursive.Chebyshev   as Cheby
import Synthesizer.Plain.Control(exponential2)
import Synthesizer.Plain.Instrument
import Synthesizer.Plain.Effect.Glass(glass)

import qualified Synthesizer.Plain.File as File
import qualified Control.Monad.Exception.Synchronous as Exc
import System.Process (rawSystem, )
import System.Exit (ExitCode, )


main :: IO ExitCode
main :: IO ExitCode
main =
   let rate :: Double
rate = Double
44100
   in  forall (m :: * -> *).
Functor m =>
ExceptionalT Int m () -> m ExitCode
Exc.toExitCodeT forall a b. (a -> b) -> a -> b
$
       do {- File.writeMono "test" rate
                (take (round (3*rate)) (soundD rate)) -}
          forall (m :: * -> *).
Functor m =>
m ExitCode -> ExceptionalT Int m ()
Exc.fromExitCodeT forall a b. (a -> b) -> a -> b
$ forall a. C a => FilePath -> a -> (a -> [a]) -> IO ExitCode
File.renderMonoToInt16 FilePath
"test.aiff" Double
rate Double -> [Double]
soundE
          forall (m :: * -> *).
Functor m =>
m ExitCode -> ExceptionalT Int m ()
Exc.fromExitCodeT forall a b. (a -> b) -> a -> b
$ FilePath -> [FilePath] -> IO ExitCode
rawSystem FilePath
"play" [FilePath
"test.aiff"]


soundE, soundB, soundA,
   sound9, sound8, sound7,
   sound6, sound5, sound4,
   sound3, sound2, sound1,
   sound0, soundm0 :: Double -> [Double]

soundE :: Double -> [Double]
soundE = Double -> [Double]
glass

{- moved to synthesizer-filter
soundD = flangedSaw
soundC _ = guitarRaw
-}

cFreq :: Double
cFreq :: Double
cFreq = Double
521.3417849066773

soundB :: Double -> [Double]
soundB Double
sampleRate =
   let baseFreq :: Double
baseFreq = Double
cFreqforall a. Fractional a => a -> a -> a
/Double
2
       chord :: [Double]
chord = forall a b c d. (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
zipWith3 (\Double
x Double
y Double
z -> (Double
xforall a. Num a => a -> a -> a
+Double
yforall a. Num a => a -> a -> a
+Double
z)forall a. Fractional a => a -> a -> a
/Double
5)
                        (forall a. (Random a, C a, C a) => a -> a -> [a]
choir Double
sampleRate (Double
baseFreqforall a. Num a => a -> a -> a
*Double
1forall a. Fractional a => a -> a -> a
/Double
1))
                        (forall a. (Random a, C a, C a) => a -> a -> [a]
choir Double
sampleRate (Double
baseFreqforall a. Num a => a -> a -> a
*Double
5forall a. Fractional a => a -> a -> a
/Double
4))
                        (forall a. (Random a, C a, C a) => a -> a -> [a]
choir Double
sampleRate (Double
baseFreqforall a. Num a => a -> a -> a
*Double
3forall a. Fractional a => a -> a -> a
/Double
2))
       filterFreqs :: [Double]
filterFreqs = forall a b. (a -> b) -> [a] -> [b]
map (Double
3000forall a. Fractional a => a -> a -> a
/Double
sampleRateforall a. Num a => a -> a -> a
*)
                         (forall a b. (a -> b) -> [a] -> [b]
map forall a. Floating a => a -> a
sin (forall a. (a -> a) -> a -> [a]
iterate (forall a. Floating a => a
piforall a. Fractional a => a -> a -> a
/(Double
6forall a. Num a => a -> a -> a
*Double
sampleRate)forall a. Num a => a -> a -> a
+) Double
0))
   in  forall a v. (C a, C a v) => Int -> T a -> T a -> T v -> T v
Butter.lowpassPole Int
8 (forall a. a -> [a]
repeat (Double
0.3::Double)) [Double]
filterFreqs ([Double]
chord::[Double])

soundA :: Double -> [Double]
soundA Double
sampleRate =
   forall a. (Random a, C a, C a) => a -> a -> [a]
choir Double
sampleRate Double
cFreq

sound9 :: Double -> [Double]
sound9 Double
sampleRate =
   forall a b. (a -> b) -> [a] -> [b]
map (forall a. Num a => a -> a -> a
*Double
0.1) (forall a. (Random a, C a, C a) => a -> a -> [[a]]
accumulatedSaws Double
sampleRate Double
cFreq forall a. [a] -> Int -> a
!! Int
20)

sound8 :: Double -> [Double]
sound8 Double
sampleRate =
   let filterFreqs :: [Double]
filterFreqs = forall y. C y => y -> y -> T y
exponential2 (-Double
0.5forall a. Num a => a -> a -> a
*Double
sampleRate) (Double
100forall a. Fractional a => a -> a -> a
/Double
sampleRate)
   --  Cheby.lowpassBPole
   --  Cheby.highpassBPole
   --  Cheby.lowpassAPole
   --  Cheby.highpassAPole
   in  forall a v. (C a, C a v) => Int -> T a -> T a -> T v -> T v
Cheby.lowpassBPole Int
8 (forall a. a -> [a]
repeat (Double
0.3::Double)) [Double]
filterFreqs (forall y. (C y, Random y) => T y
Noise.white::[Double])

sound7 :: Double -> [Double]
sound7 Double
sampleRate =
   let filterFreqs :: [Double]
filterFreqs = forall y. C y => y -> y -> T y
exponential2 (-Double
0.5forall a. Num a => a -> a -> a
*Double
sampleRate) (Double
100forall a. Fractional a => a -> a -> a
/Double
sampleRate)
   --  butterworthHighpass
   in  forall a v. (C a, C a v) => Int -> T a -> T a -> T v -> T v
Butter.lowpassPole Int
8 (forall a. a -> [a]
repeat (Double
0.3::Double)) [Double]
filterFreqs (forall y. (C y, Random y) => T y
Noise.white::[Double])

-- a moog filter which randomly changes the resonance frequency
sound6 :: Double -> [Double]
sound6 Double
sampleRate =
   let order :: Int
order = Int
10
       {- unused
       switchRates = repeat (8/sampleRate)
       filterFreqs = map (\exp -> 100*2**exp/sampleRate)
                         ((randomRs (0,6) (mkStdGen 142857))::[Double])
       filterReso  = 10
        -}

       control0 {-, control1, control2-} :: [Moog.Parameter Double]
       -- constant control
       control0 :: [Parameter Double]
control0 = forall a. a -> [a]
repeat (forall a. C a => Int -> Pole a -> Parameter a
Moog.parameter Int
order (forall a. a -> a -> Pole a
Filter.Pole Double
10 (Double
400forall a. Fractional a => a -> a -> a
/Double
sampleRate)))
       -- apply moogFilterParam first then resample, fast
       {- Need Additive and VectorSpace instances for MoogFilterParam
       control1 = interpolateConstant 0 switchRates
                     (map (moogFilterParam order)
                          (map (Pole filterReso) filterFreqs))
       -- first resample then apply moogFilterParam, slow
       control2 = map (moogFilterParam order)
                      (map (Pole filterReso)
                           (interpolateConstant 0 switchRates filterFreqs))
       -}
   in  forall a v. (C a, C a v) => Int -> T (Parameter a) -> T v -> T v
Moog.lowpass Int
order [Parameter Double]
control0
          (forall a b. (a -> b) -> [a] -> [b]
map (Double
0.5forall a. Num a => a -> a -> a
*) (forall a. (C a, C a, C a a) => a -> a -> [a]
fatSawChord Double
sampleRate Double
220))

sound5 :: Double -> [Double]
sound5 Double
sampleRate =
   forall a v. (C a, C a v) => [Int] -> a -> T v -> T v
Comb.runMulti
      (forall a b. (a -> b) -> [a] -> [b]
map (\Double
t -> forall a b. (RealFrac a, Integral b) => a -> b
round (Double
tforall a. Num a => a -> a -> a
*Double
sampleRate)) [Double
0.08,Double
0.13,Double
0.21])
      (Double
0.3::Double) (forall a. (C a, C a) => a -> a -> [a]
bell Double
sampleRate Double
441)
sound4 :: Double -> [Double]
sound4 Double
sampleRate =
   forall v. C v => Int -> (T v -> T v) -> T v -> T v
Comb.runProc
      (forall a b. (RealFrac a, Integral b) => a -> b
round (Double
0.3forall a. Num a => a -> a -> a
*Double
sampleRate))
      (forall a v. (C a, C a v) => T (Parameter a) -> T v -> T v
Filt1.lowpass
          (forall a. a -> [a]
repeat (forall a. C a => a -> Parameter a
Filt1.parameter (Double
441forall a. Fractional a => a -> a -> a
/Double
sampleRate::Double))))
      (forall a. (C a, C a) => a -> a -> [a]
bell Double
sampleRate Double
441)

sound3 :: Double -> [Double]
sound3 Double
sampleRate = forall a. (C a, C a, C a a) => a -> a -> a -> a -> [a]
allpassPlain Double
sampleRate Double
0.3 Double
1 Double
441
sound2 :: Double -> [Double]
sound2 Double
sampleRate = forall a. (C a, C a, C a a) => a -> Int -> a -> a -> a -> [a]
allpassDown  Double
sampleRate Int
10 Double
0.5 Double
1000 Double
441

sound1 :: Double -> [Double]
sound1 Double
sampleRate = forall a b. (a -> b) -> [a] -> [b]
map (Double
0.1forall a. Num a => a -> a -> a
*) (forall a. (C a, C a, C a a) => a -> Int -> a -> a -> a -> [a]
moogDown Double
sampleRate Int
6 Double
0.4 Double
5000 Double
441)
sound0 :: Double -> [Double]
sound0 Double
sampleRate = forall a b. (a -> b) -> [a] -> [b]
map (Double
0.3forall a. Num a => a -> a -> a
*) (forall a. (C a, C a, C a a) => a -> Int -> a -> a -> a -> [a]
moogReso Double
sampleRate Int
6 Double
0.1 Double
2000 Double
441)

soundm0 :: Double -> [Double]
soundm0 Double
sampleRate = forall a. (C a, C a, C a a) => a -> a -> [a]
fatSawChordFilter Double
sampleRate Double
110