Play.hs

{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE Rank2Types #-}
module Synthesizer.Dimensional.ALSA.Play where

import qualified Synthesizer.Storable.ALSA.Play as Play

import qualified Synthesizer.Dimensional.Rate as Rate
import qualified Synthesizer.Dimensional.Amplitude as Amp

import qualified Synthesizer.Dimensional.Process as Proc
import qualified Synthesizer.Dimensional.Signal.Private as SigA

import qualified Synthesizer.Frame.Stereo as Stereo

import qualified Synthesizer.Storable.Signal as SigSt

import qualified Sound.Alsa as ALSA

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

-- import qualified Algebra.ToInteger      as ToInteger
import qualified Algebra.Module         as Module
import qualified Algebra.RealField      as RealField
-- import qualified Algebra.Field          as Field
-- import qualified Algebra.Ring           as Ring

import Foreign.Storable (Storable, )

-- import NumericPrelude
import PreludeBase


type RenderedStorableSignal u t v y yv =
   SigA.T (Rate.Dimensional u t) (Amp.Dimensional v y) (SigSt.T yv)

type StorableSignal s v y yv =
   SigA.T (Rate.Phantom s) (Amp.Dimensional v y) (SigSt.T yv)


{-# INLINE timeVoltageStorable #-}
timeVoltageStorable ::
   (Module.C y yv, ALSA.SampleFmt yv, RealField.C t) =>
   RenderedStorableSignal Dim.Time t Dim.Voltage y yv ->
   IO ()
timeVoltageStorable sig =
   let rate = DN.toNumberWithDimension Dim.frequency (SigA.actualSampleRate sig)
   in  Play.auto (RealField.round rate)
          (SigA.vectorSamples (DN.toNumberWithDimension Dim.voltage) sig)

{-# INLINE timeVoltageMonoStorableToInt16 #-}
timeVoltageMonoStorableToInt16 ::
   (Storable y, RealField.C y, RealField.C t) =>
   RenderedStorableSignal Dim.Time t Dim.Voltage y y ->
   IO ()
timeVoltageMonoStorableToInt16 sig =
   let rate = DN.toNumberWithDimension Dim.frequency (SigA.actualSampleRate sig)
   in  Play.monoToInt16 (RealField.round rate)
          (SigA.scalarSamples (DN.toNumberWithDimension Dim.voltage) sig)

{-# INLINE timeVoltageStereoStorableToInt16 #-}
timeVoltageStereoStorableToInt16 ::
   (Storable y, Module.C y y, RealField.C y, RealField.C t) =>
   RenderedStorableSignal Dim.Time t Dim.Voltage y (Stereo.T y) ->
   IO ()
timeVoltageStereoStorableToInt16 sig =
   let rate = DN.toNumberWithDimension Dim.frequency (SigA.actualSampleRate sig)
   in  Play.stereoToInt16 (RealField.round rate)
          (SigA.vectorSamples (DN.toNumberWithDimension Dim.voltage) sig)


{-# INLINE renderTimeVoltageStorable #-}
renderTimeVoltageStorable ::
   (Module.C y yv, ALSA.SampleFmt yv, RealField.C t) =>
   DN.T Dim.Frequency t ->
   (forall s. Proc.T s Dim.Time t
      (StorableSignal s Dim.Voltage y yv)) ->
   IO ()
renderTimeVoltageStorable rate sig =
   timeVoltageStorable (SigA.render rate sig)

{-# INLINE renderTimeVoltageMonoStorableToInt16 #-}
renderTimeVoltageMonoStorableToInt16 ::
   (Storable y, RealField.C y, RealField.C t) =>
   DN.T Dim.Frequency t ->
   (forall s. Proc.T s Dim.Time t
      (StorableSignal s Dim.Voltage y y)) ->
   IO ()
renderTimeVoltageMonoStorableToInt16 rate sig =
   timeVoltageMonoStorableToInt16 (SigA.render rate sig)

{-# INLINE renderTimeVoltageStereoStorableToInt16 #-}
renderTimeVoltageStereoStorableToInt16 ::
   (Storable y, Module.C y y, RealField.C y, RealField.C t) =>
   DN.T Dim.Frequency t ->
   (forall s. Proc.T s Dim.Time t
      (StorableSignal s Dim.Voltage y (Stereo.T y))) ->
   IO ()
renderTimeVoltageStereoStorableToInt16 rate sig =
   timeVoltageStereoStorableToInt16 (SigA.render rate sig)