{-# LINE 1 "src/Sound/ALSA/PCM/Core/SwParams.hsc" #-}
{-# LANGUAGE ForeignFunctionInterface #-}
module Sound.ALSA.PCM.Core.SwParams where

import Sound.ALSA.PCM.Core.Handle (Handle, Size, )
import qualified Sound.ALSA.PCM.Core.Handle as H -- expose Handle constructor to FFI
import qualified Sound.ALSA.PCM.Core.Convert as Conv

import Sound.ALSA.Exception (checkResult_, )

import Control.Applicative (Applicative(pure, (<*>)))

import Control.Exception (bracket, )

import qualified Foreign.Storable.Newtype as Store

import qualified Foreign.C.Types as C
import Foreign.Ptr (Ptr, )
import Foreign.Storable (Storable, sizeOf, alignment, peek, poke, )
import Foreign.Marshal.Alloc (alloca, )

import Data.Word (Word, )




newtype T i y a = Cons (H.Handle i y -> Ptr Params -> IO a)

data Params = Params


{-
T is a Reader monad.
-}
instance Functor (T i y) where
   fmap :: forall a b. (a -> b) -> T i y a -> T i y b
fmap a -> b
f (Cons Handle i y -> Ptr Params -> IO a
act) = (Handle i y -> Ptr Params -> IO b) -> T i y b
forall i y a. (Handle i y -> Ptr Params -> IO a) -> T i y a
Cons ((Handle i y -> Ptr Params -> IO b) -> T i y b)
-> (Handle i y -> Ptr Params -> IO b) -> T i y b
forall a b. (a -> b) -> a -> b
$ \Handle i y
h Ptr Params
p -> (a -> b) -> IO a -> IO b
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f (IO a -> IO b) -> IO a -> IO b
forall a b. (a -> b) -> a -> b
$ Handle i y -> Ptr Params -> IO a
act Handle i y
h Ptr Params
p

instance Applicative (T i y) where
   pure :: forall a. a -> T i y a
pure a
a = (Handle i y -> Ptr Params -> IO a) -> T i y a
forall i y a. (Handle i y -> Ptr Params -> IO a) -> T i y a
Cons ((Handle i y -> Ptr Params -> IO a) -> T i y a)
-> (Handle i y -> Ptr Params -> IO a) -> T i y a
forall a b. (a -> b) -> a -> b
$ \ Handle i y
_h Ptr Params
_p -> a -> IO a
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
a
   Cons Handle i y -> Ptr Params -> IO (a -> b)
f <*> :: forall a b. T i y (a -> b) -> T i y a -> T i y b
<*> Cons Handle i y -> Ptr Params -> IO a
x = (Handle i y -> Ptr Params -> IO b) -> T i y b
forall i y a. (Handle i y -> Ptr Params -> IO a) -> T i y a
Cons ((Handle i y -> Ptr Params -> IO b) -> T i y b)
-> (Handle i y -> Ptr Params -> IO b) -> T i y b
forall a b. (a -> b) -> a -> b
$ \Handle i y
h Ptr Params
p -> Handle i y -> Ptr Params -> IO (a -> b)
f Handle i y
h Ptr Params
p IO (a -> b) -> IO a -> IO b
forall a b. IO (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Handle i y -> Ptr Params -> IO a
x Handle i y
h Ptr Params
p

instance Monad (T i y) where
   return :: forall a. a -> T i y a
return = a -> T i y a
forall a. a -> T i y a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
   Cons Handle i y -> Ptr Params -> IO a
x >>= :: forall a b. T i y a -> (a -> T i y b) -> T i y b
>>= a -> T i y b
k =
      (Handle i y -> Ptr Params -> IO b) -> T i y b
forall i y a. (Handle i y -> Ptr Params -> IO a) -> T i y a
Cons ((Handle i y -> Ptr Params -> IO b) -> T i y b)
-> (Handle i y -> Ptr Params -> IO b) -> T i y b
forall a b. (a -> b) -> a -> b
$ \Handle i y
h Ptr Params
p -> Handle i y -> Ptr Params -> IO a
x Handle i y
h Ptr Params
p IO a -> (a -> IO b) -> IO b
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \a
a -> case a -> T i y b
k a
a of Cons Handle i y -> Ptr Params -> IO b
y -> Handle i y -> Ptr Params -> IO b
y Handle i y
h Ptr Params
p



withIO :: Handle i y -> (Ptr Params -> IO a) -> IO a
withIO :: forall i y a. Handle i y -> (Ptr Params -> IO a) -> IO a
withIO Handle i y
h Ptr Params -> IO a
f =
   IO (Ptr Params)
-> (Ptr Params -> IO ()) -> (Ptr Params -> IO a) -> IO a
forall a b c. IO a -> (a -> IO b) -> (a -> IO c) -> IO c
bracket IO (Ptr Params)
malloc Ptr Params -> IO ()
free ((Ptr Params -> IO a) -> IO a) -> (Ptr Params -> IO a) -> IO a
forall a b. (a -> b) -> a -> b
$ \Ptr Params
p -> do
      Handle i y -> Ptr Params -> IO ()
forall i y. Handle i y -> Ptr Params -> IO ()
current Handle i y
h Ptr Params
p
      a
x <- Ptr Params -> IO a
f Ptr Params
p
      Handle i y -> Ptr Params -> IO ()
forall i y. Handle i y -> Ptr Params -> IO ()
set Handle i y
h Ptr Params
p
      a -> IO a
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return a
x
--   bracket_ (current h p) (set h p) (f p)


foreign import ccall safe "alsa/pcm.h snd_pcm_sw_params_malloc"
   malloc_ :: Ptr (Ptr Params) -> IO C.CInt

foreign import ccall safe "alsa/pcm.h snd_pcm_sw_params_free"
   free :: Ptr Params -> IO ()

malloc :: IO (Ptr Params)
malloc :: IO (Ptr Params)
malloc =
   (Ptr (Ptr Params) -> IO (Ptr Params)) -> IO (Ptr Params)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr (Ptr Params) -> IO (Ptr Params)) -> IO (Ptr Params))
-> (Ptr (Ptr Params) -> IO (Ptr Params)) -> IO (Ptr Params)
forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr Params)
pp ->
   Ptr (Ptr Params) -> IO CInt
malloc_ Ptr (Ptr Params)
pp IO CInt -> (CInt -> IO ()) -> IO ()
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
   String -> CInt -> IO ()
forall a. Integral a => String -> a -> IO ()
checkResult_ String
"SwParams.malloc" IO () -> IO (Ptr Params) -> IO (Ptr Params)
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
   Ptr (Ptr Params) -> IO (Ptr Params)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Params)
pp



foreign import ccall safe "alsa/pcm.h snd_pcm_sw_params"
   set_ :: Handle i y -> Ptr Params -> IO C.CInt

foreign import ccall safe "alsa/pcm.h snd_pcm_sw_params_current"
   current_ :: Handle i y -> Ptr Params -> IO C.CInt

set :: Handle i y -> Ptr Params -> IO ()
set :: forall i y. Handle i y -> Ptr Params -> IO ()
set Handle i y
h Ptr Params
p =
   Handle i y -> Ptr Params -> IO CInt
forall i y. Handle i y -> Ptr Params -> IO CInt
set_ Handle i y
h Ptr Params
p IO CInt -> (CInt -> IO ()) -> IO ()
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> CInt -> IO ()
forall a. Integral a => String -> a -> IO ()
checkResult_ String
"SwParams.set"

current :: Handle i y -> Ptr Params -> IO ()
current :: forall i y. Handle i y -> Ptr Params -> IO ()
current Handle i y
h Ptr Params
p =
   Handle i y -> Ptr Params -> IO CInt
forall i y. Handle i y -> Ptr Params -> IO CInt
current_ Handle i y
h Ptr Params
p IO CInt -> (CInt -> IO ()) -> IO ()
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> CInt -> IO ()
forall a. Integral a => String -> a -> IO ()
checkResult_ String
"SwParams.current"



newtype TimestampMode = TimestampMode {TimestampMode -> CInt
fromTimestampMode :: C.CInt}
   deriving (TimestampMode -> TimestampMode -> Bool
(TimestampMode -> TimestampMode -> Bool)
-> (TimestampMode -> TimestampMode -> Bool) -> Eq TimestampMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TimestampMode -> TimestampMode -> Bool
== :: TimestampMode -> TimestampMode -> Bool
$c/= :: TimestampMode -> TimestampMode -> Bool
/= :: TimestampMode -> TimestampMode -> Bool
Eq, Eq TimestampMode
Eq TimestampMode
-> (TimestampMode -> TimestampMode -> Ordering)
-> (TimestampMode -> TimestampMode -> Bool)
-> (TimestampMode -> TimestampMode -> Bool)
-> (TimestampMode -> TimestampMode -> Bool)
-> (TimestampMode -> TimestampMode -> Bool)
-> (TimestampMode -> TimestampMode -> TimestampMode)
-> (TimestampMode -> TimestampMode -> TimestampMode)
-> Ord TimestampMode
TimestampMode -> TimestampMode -> Bool
TimestampMode -> TimestampMode -> Ordering
TimestampMode -> TimestampMode -> TimestampMode
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TimestampMode -> TimestampMode -> Ordering
compare :: TimestampMode -> TimestampMode -> Ordering
$c< :: TimestampMode -> TimestampMode -> Bool
< :: TimestampMode -> TimestampMode -> Bool
$c<= :: TimestampMode -> TimestampMode -> Bool
<= :: TimestampMode -> TimestampMode -> Bool
$c> :: TimestampMode -> TimestampMode -> Bool
> :: TimestampMode -> TimestampMode -> Bool
$c>= :: TimestampMode -> TimestampMode -> Bool
>= :: TimestampMode -> TimestampMode -> Bool
$cmax :: TimestampMode -> TimestampMode -> TimestampMode
max :: TimestampMode -> TimestampMode -> TimestampMode
$cmin :: TimestampMode -> TimestampMode -> TimestampMode
min :: TimestampMode -> TimestampMode -> TimestampMode
Ord)

instance Enum TimestampMode where
   toEnum :: Int -> TimestampMode
toEnum Int
n = CInt -> TimestampMode
TimestampMode (CInt -> TimestampMode) -> CInt -> TimestampMode
forall a b. (a -> b) -> a -> b
$ Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n
   fromEnum :: TimestampMode -> Int
fromEnum (TimestampMode CInt
n) = CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral CInt
n

instance Storable TimestampMode where
   sizeOf :: TimestampMode -> Int
sizeOf = (TimestampMode -> CInt) -> TimestampMode -> Int
forall core wrapper.
Storable core =>
(wrapper -> core) -> wrapper -> Int
Store.sizeOf TimestampMode -> CInt
fromTimestampMode
   alignment :: TimestampMode -> Int
alignment = (TimestampMode -> CInt) -> TimestampMode -> Int
forall core wrapper.
Storable core =>
(wrapper -> core) -> wrapper -> Int
Store.alignment TimestampMode -> CInt
fromTimestampMode
   peek :: Ptr TimestampMode -> IO TimestampMode
peek = (CInt -> TimestampMode) -> Ptr TimestampMode -> IO TimestampMode
forall core wrapper.
Storable core =>
(core -> wrapper) -> Ptr wrapper -> IO wrapper
Store.peek CInt -> TimestampMode
TimestampMode
   poke :: Ptr TimestampMode -> TimestampMode -> IO ()
poke = (TimestampMode -> CInt)
-> Ptr TimestampMode -> TimestampMode -> IO ()
forall core wrapper.
Storable core =>
(wrapper -> core) -> Ptr wrapper -> wrapper -> IO ()
Store.poke TimestampMode -> CInt
fromTimestampMode

timestampNone  :: TimestampMode
timestampNone :: TimestampMode
timestampNone  = CInt -> TimestampMode
TimestampMode CInt
0
timestampMmap  :: TimestampMode
timestampMmap :: TimestampMode
timestampMmap  = CInt -> TimestampMode
TimestampMode CInt
1

{-# LINE 105 "src/Sound/ALSA/PCM/Core/SwParams.hsc" #-}






foreign import ccall safe "alsa/pcm.h snd_pcm_sw_params_set_tstamp_mode"
   setTimestampMode_ :: Handle i y -> Ptr Params -> TimestampMode -> IO C.CInt

foreign import ccall safe "alsa/pcm.h snd_pcm_sw_params_get_tstamp_mode"
   getTimestampMode_ :: Ptr Params -> Ptr TimestampMode -> IO C.CInt

setTimestampMode :: TimestampMode -> T i y ()
setTimestampMode :: forall i y. TimestampMode -> T i y ()
setTimestampMode TimestampMode
x =
   (Handle i y -> Ptr Params -> IO ()) -> T i y ()
forall i y a. (Handle i y -> Ptr Params -> IO a) -> T i y a
Cons ((Handle i y -> Ptr Params -> IO ()) -> T i y ())
-> (Handle i y -> Ptr Params -> IO ()) -> T i y ()
forall a b. (a -> b) -> a -> b
$ \Handle i y
h Ptr Params
p ->
   Handle i y -> Ptr Params -> TimestampMode -> IO CInt
forall i y. Handle i y -> Ptr Params -> TimestampMode -> IO CInt
setTimestampMode_ Handle i y
h Ptr Params
p (T TimestampMode TimestampMode -> TimestampMode -> TimestampMode
forall h c. T h c -> h -> c
Conv.fromHaskell T TimestampMode TimestampMode
forall a. T a a
Conv.id TimestampMode
x) IO CInt -> (CInt -> IO ()) -> IO ()
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
   String -> CInt -> IO ()
forall a. Integral a => String -> a -> IO ()
checkResult_ String
"SwParams.setTimestampMode"

getTimestampMode :: T i y TimestampMode
getTimestampMode :: forall i y. T i y TimestampMode
getTimestampMode =
   (Handle i y -> Ptr Params -> IO TimestampMode)
-> T i y TimestampMode
forall i y a. (Handle i y -> Ptr Params -> IO a) -> T i y a
Cons ((Handle i y -> Ptr Params -> IO TimestampMode)
 -> T i y TimestampMode)
-> (Handle i y -> Ptr Params -> IO TimestampMode)
-> T i y TimestampMode
forall a b. (a -> b) -> a -> b
$ \Handle i y
_ Ptr Params
p ->
   (Ptr TimestampMode -> IO TimestampMode) -> IO TimestampMode
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr TimestampMode -> IO TimestampMode) -> IO TimestampMode)
-> (Ptr TimestampMode -> IO TimestampMode) -> IO TimestampMode
forall a b. (a -> b) -> a -> b
$ \Ptr TimestampMode
ptr ->
   Ptr Params -> Ptr TimestampMode -> IO CInt
getTimestampMode_ Ptr Params
p Ptr TimestampMode
ptr IO CInt -> (CInt -> IO ()) -> IO ()
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
   String -> CInt -> IO ()
forall a. Integral a => String -> a -> IO ()
checkResult_ String
"SwParams.getTimestampMode" IO () -> IO TimestampMode -> IO TimestampMode
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
   T TimestampMode TimestampMode
-> Ptr TimestampMode -> IO TimestampMode
forall a h. Storable a => T h a -> Ptr a -> IO h
Conv.peek T TimestampMode TimestampMode
forall a. T a a
Conv.id Ptr TimestampMode
ptr

{-# LINE 132 "src/Sound/ALSA/PCM/Core/SwParams.hsc" #-}
foreign import ccall safe "alsa/pcm.h snd_pcm_sw_params_set_sleep_min"
   setSleepMin_ :: Handle i y -> Ptr Params -> C.CUInt -> IO C.CInt

foreign import ccall safe "alsa/pcm.h snd_pcm_sw_params_get_sleep_min"
   getSleepMin_ :: Ptr Params -> Ptr C.CUInt -> IO C.CInt

setSleepMin :: Word -> T i y ()
setSleepMin x =
   Cons $ \h p ->
   setSleepMin_ h p (Conv.fromHaskell Conv.int x) >>=
   checkResult_ "SwParams.setSleepMin"

getSleepMin :: T i y Word
getSleepMin =
   Cons $ \_ p ->
   alloca $ \ptr ->
   getSleepMin_ p ptr >>=
   checkResult_ "SwParams.getSleepMin" >>
   Conv.peek Conv.int ptr

{-# LINE 133 "src/Sound/ALSA/PCM/Core/SwParams.hsc" #-}
foreign import ccall safe "alsa/pcm.h snd_pcm_sw_params_set_avail_min"
   setAvailMin_ :: Handle i y -> Ptr Params -> C.CULong -> IO C.CInt

foreign import ccall safe "alsa/pcm.h snd_pcm_sw_params_get_avail_min"
   getAvailMin_ :: Ptr Params -> Ptr C.CULong -> IO C.CInt

setAvailMin :: Size -> T i y ()
setAvailMin x =
   Cons $ \h p ->
   setAvailMin_ h p (Conv.fromHaskell Conv.int x) >>=
   checkResult_ "SwParams.setAvailMin"

getAvailMin :: T i y Size
getAvailMin =
   Cons $ \_ p ->
   alloca $ \ptr ->
   getAvailMin_ p ptr >>=
   checkResult_ "SwParams.getAvailMin" >>
   Conv.peek Conv.int ptr

{-# LINE 134 "src/Sound/ALSA/PCM/Core/SwParams.hsc" #-}
foreign import ccall safe "alsa/pcm.h snd_pcm_sw_params_set_xfer_align"
   setXferAlign_ :: Handle i y -> Ptr Params -> C.CULong -> IO C.CInt

foreign import ccall safe "alsa/pcm.h snd_pcm_sw_params_get_xfer_align"
   getXferAlign_ :: Ptr Params -> Ptr C.CULong -> IO C.CInt

setXferAlign :: Size -> T i y ()
setXferAlign x =
   Cons $ \h p ->
   setXferAlign_ h p (Conv.fromHaskell Conv.int x) >>=
   checkResult_ "SwParams.setXferAlign"

getXferAlign :: T i y Size
getXferAlign =
   Cons $ \_ p ->
   alloca $ \ptr ->
   getXferAlign_ p ptr >>=
   checkResult_ "SwParams.getXferAlign" >>
   Conv.peek Conv.int ptr

{-# LINE 135 "src/Sound/ALSA/PCM/Core/SwParams.hsc" #-}
foreign import ccall safe "alsa/pcm.h snd_pcm_sw_params_set_start_threshold"
   setStartThreshold_ :: Handle i y -> Ptr Params -> C.CULong -> IO C.CInt

foreign import ccall safe "alsa/pcm.h snd_pcm_sw_params_get_start_threshold"
   getStartThreshold_ :: Ptr Params -> Ptr C.CULong -> IO C.CInt

setStartThreshold :: Size -> T i y ()
setStartThreshold x =
   Cons $ \h p ->
   setStartThreshold_ h p (Conv.fromHaskell Conv.int x) >>=
   checkResult_ "SwParams.setStartThreshold"

getStartThreshold :: T i y Size
getStartThreshold =
   Cons $ \_ p ->
   alloca $ \ptr ->
   getStartThreshold_ p ptr >>=
   checkResult_ "SwParams.getStartThreshold" >>
   Conv.peek Conv.int ptr

{-# LINE 136 "src/Sound/ALSA/PCM/Core/SwParams.hsc" #-}
foreign import ccall safe "alsa/pcm.h snd_pcm_sw_params_set_stop_threshold"
   setStopThreshold_ :: Handle i y -> Ptr Params -> C.CULong -> IO C.CInt

foreign import ccall safe "alsa/pcm.h snd_pcm_sw_params_get_stop_threshold"
   getStopThreshold_ :: Ptr Params -> Ptr C.CULong -> IO C.CInt

setStopThreshold :: Size -> T i y ()
setStopThreshold x =
   Cons $ \h p ->
   setStopThreshold_ h p (Conv.fromHaskell Conv.int x) >>=
   checkResult_ "SwParams.setStopThreshold"

getStopThreshold :: T i y Size
getStopThreshold =
   Cons $ \_ p ->
   alloca $ \ptr ->
   getStopThreshold_ p ptr >>=
   checkResult_ "SwParams.getStopThreshold" >>
   Conv.peek Conv.int ptr

{-# LINE 137 "src/Sound/ALSA/PCM/Core/SwParams.hsc" #-}
foreign import ccall safe "alsa/pcm.h snd_pcm_sw_params_set_silence_threshold"
   setSilenceThreshold_ :: Handle i y -> Ptr Params -> C.CULong -> IO C.CInt

foreign import ccall safe "alsa/pcm.h snd_pcm_sw_params_get_silence_threshold"
   getSilenceThreshold_ :: Ptr Params -> Ptr C.CULong -> IO C.CInt

setSilenceThreshold :: Size -> T i y ()
setSilenceThreshold x =
   Cons $ \h p ->
   setSilenceThreshold_ h p (Conv.fromHaskell Conv.int x) >>=
   checkResult_ "SwParams.setSilenceThreshold"

getSilenceThreshold :: T i y Size
getSilenceThreshold =
   Cons $ \_ p ->
   alloca $ \ptr ->
   getSilenceThreshold_ p ptr >>=
   checkResult_ "SwParams.getSilenceThreshold" >>
   Conv.peek Conv.int ptr

{-# LINE 138 "src/Sound/ALSA/PCM/Core/SwParams.hsc" #-}
foreign import ccall safe "alsa/pcm.h snd_pcm_sw_params_set_silence_size"
   setSilenceSize_ :: Handle i y -> Ptr Params -> C.CULong -> IO C.CInt

foreign import ccall safe "alsa/pcm.h snd_pcm_sw_params_get_silence_size"
   getSilenceSize_ :: Ptr Params -> Ptr C.CULong -> IO C.CInt

setSilenceSize :: Size -> T i y ()
setSilenceSize x =
   Cons $ \h p ->
   setSilenceSize_ h p (Conv.fromHaskell Conv.int x) >>=
   checkResult_ "SwParams.setSilenceSize"

getSilenceSize :: T i y Size
getSilenceSize =
   Cons $ \_ p ->
   alloca $ \ptr ->
   getSilenceSize_ p ptr >>=
   checkResult_ "SwParams.getSilenceSize" >>
   Conv.peek Conv.int ptr

{-# LINE 139 "src/Sound/ALSA/PCM/Core/SwParams.hsc" #-}