module Synthesizer.LLVM.Frame where
import qualified Synthesizer.LLVM.Frame.Stereo as Stereo
import qualified LLVM.Extra.Vector as Vector
import qualified LLVM.Extra.Arithmetic as A
import qualified LLVM.Core as LLVM
import LLVM.Core
(CodeGenFunction, Value, Vector,
IsPrimitive, IsArithmetic)
import qualified Type.Data.Num.Decimal as TypeNum
import Type.Data.Num.Decimal (D2, D4)
import qualified Data.Traversable as Trav
import qualified Data.Foldable as Fold
import NumericPrelude.Numeric hiding (zero, one, div, signum)
import NumericPrelude.Base
stereoFromMono ::
a -> CodeGenFunction r (Stereo.T a)
stereoFromMono x =
return $ Stereo.cons x x
mixMonoFromStereo ::
(A.Additive a) =>
Stereo.T a -> CodeGenFunction r a
mixMonoFromStereo s =
mix (Stereo.left s) (Stereo.right s)
stereoFromVector ::
(IsPrimitive a) =>
Value (Vector D2 a) ->
CodeGenFunction r (Stereo.T (Value a))
stereoFromVector x =
Trav.mapM (LLVM.extractelement x . LLVM.valueOf) $ Stereo.cons 0 1
vectorFromStereo ::
(IsPrimitive a) =>
Stereo.T (Value a) ->
CodeGenFunction r (Value (Vector D2 a))
vectorFromStereo =
Vector.assemble . Fold.toList
quadroFromVector ::
(IsPrimitive a) =>
Value (Vector D4 a) ->
CodeGenFunction r (Stereo.T (Stereo.T (Value a)))
quadroFromVector x =
Trav.mapM (Trav.mapM (LLVM.extractelement x . LLVM.valueOf)) $
Stereo.cons (Stereo.cons 0 1) (Stereo.cons 2 3)
vectorFromQuadro ::
(IsPrimitive a) =>
Stereo.T (Stereo.T (Value a)) ->
CodeGenFunction r (Value (Vector D4 a))
vectorFromQuadro =
Vector.assemble .
concatMap Fold.toList . Fold.toList
mix ::
(A.Additive a) =>
a -> a -> CodeGenFunction r a
mix = A.add
mixStereoV ::
(IsArithmetic a, IsPrimitive a) =>
Stereo.T (Value a) -> Stereo.T (Value a) ->
CodeGenFunction r (Stereo.T (Value a))
mixStereoV x y =
do xv <- vectorFromStereo x
yv <- vectorFromStereo y
stereoFromVector =<< A.add xv yv
mixVector ::
(Vector.Arithmetic a, TypeNum.Positive n) =>
Value (Vector n a) ->
CodeGenFunction r (Value a)
mixVector = Vector.sum
mixVectorToStereo ::
(Vector.Arithmetic a, TypeNum.Positive n) =>
Value (Vector n a) ->
CodeGenFunction r (Stereo.T (Value a))
mixVectorToStereo =
fmap (uncurry Stereo.cons) .
Vector.sumInterleavedToPair
mixInterleavedVectorToStereo ::
(Vector.Arithmetic a, TypeNum.Positive n) =>
Value (Vector n a) ->
CodeGenFunction r (Stereo.T (Value a))
mixInterleavedVectorToStereo =
fmap (uncurry Stereo.cons) .
Vector.sumInterleavedToPair
amplifyMono ::
(A.PseudoRing a) =>
a -> a -> CodeGenFunction r a
amplifyMono = A.mul
amplifyStereo ::
(A.PseudoRing a) =>
a -> Stereo.T a -> CodeGenFunction r (Stereo.T a)
amplifyStereo x =
Trav.mapM (A.mul x)