GenerateElmEuropeSnare.hs

{-# LANGUAGE OverloadedStrings, GeneralizedNewtypeDeriving #-}


module Main (main) where

import Prelude.Extra
import Flow

import qualified Audio
import Audio (Audio)
import qualified Control.Monad as CM
import qualified Mono
import Mono (Mono)
import qualified Mono.Fade
import qualified Timing
import qualified Data.Either.Extra as Either
import Data.Text.Lazy (Text)
import qualified Data.Text.Lazy as T
import Volume (Volume(Volume))
import qualified Volume


-- MAIN --


main :: IO ()
main =
    let
        readMono :: Text -> (Mono -> Mono) -> (Mono -> a) -> IO a
        readMono fileName mapper ctor =
            [ "./elm-europe-audio/"
            , fileName
            , ".wav"
            ]
                |> T.concat
                |> Mono.read
                |> mapIO (mapper .> ctor)

        topHeadTransformation :: Mono -> Mono
        topHeadTransformation =
            Mono.setVolume (Volume 4)
                .> Mono.splitAt 35
                .> snd
    in
    (toIO fromAudio)
        |> require (readMono "punch" id Punch)
        |> require (readMono "top-head-slow" topHeadTransformation TopHead)
        |> require (readMono "travel-1" id Travel)
        |> require (readMono "bottom-head" (Mono.splitAt 20 .> snd)  BottomHead)
        |> require (readMono "top-head-2" (Mono.setVolume (Volume 0.7)) LongBottomHead)
        |> require (readMono "snare" id Snare)
        |> andThen id


data TopHead
    = TopHead Mono


data LongBottomHead
    = LongBottomHead Mono


data BottomHead
    = BottomHead Mono


data Snare
    = Snare Mono


data Travel
    = Travel Mono


data Punch
    = Punch Mono


fromAudio :: Punch -> TopHead -> Travel -> BottomHead -> LongBottomHead -> Snare -> IO ()
fromAudio (Punch punch)  (TopHead topHead) (Travel travel) (BottomHead bottomHead) (LongBottomHead longBottomHead) (Snare snare) =
    let
        punchAndTopHead :: Mono
        punchAndTopHead =
            topHead
                |> Mono.deltaConvolve punch
                |> Mono.setVolume (Volume 2)

        travelAndBottomHead :: Mono
        travelAndBottomHead =
            punchAndTopHead
                |> Mono.setVolume (Volume 4)
                |> Mono.deltaConvolve travel
                |> Mono.deltaConvolve (Mono.setVolume (Volume 0.2) longBottomHead)

        output :: Mono
        output =
            [ punch
              , [ punchAndTopHead
                |> Mono.setVolume (Volume 3)
              , punchAndTopHead
                |> Mono.deltaConvolve snare
              , travelAndBottomHead
                |> Mono.deltaConvolve snare
                |> Mono.invertAbove 0.05
                |> Mono.setVolume (Volume 2)
              ]
                |> Mono.mixMany
            ]
                |> Mono.concat
                |> Mono.setVolume (Volume 0.8)
                |> Mono.Fade.out (Timing.Linear)
                |> Mono.Fade.out (Timing.Linear)

        outputFileName :: Text
        outputFileName =
            "elm-europe-snare.wav"
    in
    [ [ output
        |> Mono.compress 4
        |> Mono.setVolume (Volume 0.5)
      , output
        |> Mono.invertAbove 0.2
        |> Mono.invertBelow 0.3
        |> Mono.Fade.out (Timing.Linear)
        |> Mono.Fade.out (Timing.Linear)
      ]
        |> Mono.mixMany
        |> Mono.setVolume (Volume 0.5)
        |> Mono.declip
        |> Audio.fromMono
        |> Audio.write outputFileName
    , Audio.play outputFileName
    ]
        |> CM.sequence_