{-# LINE 1 "src/Sound/ALSA/Sequencer/Marshal/Time.hsc" #-}
module Sound.ALSA.Sequencer.Marshal.Time where




import qualified Sound.ALSA.Sequencer.Marshal.RealTime as RealTime

import qualified Sound.ALSA.Sequencer.Utility as U
import qualified Foreign.Storable as St
-- import qualified Foreign.C.Types as C
import Foreign.Ptr (Ptr, castPtr, )
import qualified Data.FlagSet as FlagSet
import qualified Data.Word as Word
import Data.Monoid (mappend, )

import qualified Data.Accessor.Basic as Acc


data T = Cons {T -> Mode
mode :: Mode, T -> Stamp
stamp :: Stamp}

instance Show T where
   showsPrec :: Int -> T -> ShowS
showsPrec Int
prec (Cons Mode
m Stamp
st) =
      Int -> String -> [ShowS] -> ShowS
U.showsRecord Int
prec String
"Time"
         [forall a. Show a => a -> ShowS
U.showsField Mode
m, forall a. Show a => a -> ShowS
U.showsField Stamp
st]


consAbs :: Stamp -> T
consAbs :: Stamp -> T
consAbs = Mode -> Stamp -> T
Cons Mode
Absolute

consRel :: Stamp -> T
consRel :: Stamp -> T
consRel = Mode -> Stamp -> T
Cons Mode
Relative


modeAcc :: Acc.T T Mode
modeAcc :: T T Mode
modeAcc =
   forall a r. (a -> r -> r) -> (r -> a) -> T r a
Acc.fromSetGet (\Mode
x T
ev -> T
ev{mode :: Mode
mode = Mode
x}) T -> Mode
mode

stampAcc :: Acc.T T Stamp
stampAcc :: T T Stamp
stampAcc =
   forall a r. (a -> r -> r) -> (r -> a) -> T r a
Acc.fromSetGet (\Stamp
x T
ev -> T
ev{stamp :: Stamp
stamp = Stamp
x}) T -> Stamp
stamp


type Tick = Word.Word32
{-# LINE 44 "src/Sound/ALSA/Sequencer/Marshal/Time.hsc" #-}

data Mode = Absolute | Relative
   deriving (Mode -> Mode -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Mode -> Mode -> Bool
$c/= :: Mode -> Mode -> Bool
== :: Mode -> Mode -> Bool
$c== :: Mode -> Mode -> Bool
Eq, Int -> Mode -> ShowS
[Mode] -> ShowS
Mode -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Mode] -> ShowS
$cshowList :: [Mode] -> ShowS
show :: Mode -> String
$cshow :: Mode -> String
showsPrec :: Int -> Mode -> ShowS
$cshowsPrec :: Int -> Mode -> ShowS
Show, Int -> Mode
Mode -> Int
Mode -> [Mode]
Mode -> Mode
Mode -> Mode -> [Mode]
Mode -> Mode -> Mode -> [Mode]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Mode -> Mode -> Mode -> [Mode]
$cenumFromThenTo :: Mode -> Mode -> Mode -> [Mode]
enumFromTo :: Mode -> Mode -> [Mode]
$cenumFromTo :: Mode -> Mode -> [Mode]
enumFromThen :: Mode -> Mode -> [Mode]
$cenumFromThen :: Mode -> Mode -> [Mode]
enumFrom :: Mode -> [Mode]
$cenumFrom :: Mode -> [Mode]
fromEnum :: Mode -> Int
$cfromEnum :: Mode -> Int
toEnum :: Int -> Mode
$ctoEnum :: Int -> Mode
pred :: Mode -> Mode
$cpred :: Mode -> Mode
succ :: Mode -> Mode
$csucc :: Mode -> Mode
Enum)

data Stamp =
     Tick !Tick
   | Real !RealTime.T
     deriving Int -> Stamp -> ShowS
[Stamp] -> ShowS
Stamp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Stamp] -> ShowS
$cshowList :: [Stamp] -> ShowS
show :: Stamp -> String
$cshow :: Stamp -> String
showsPrec :: Int -> Stamp -> ShowS
$cshowsPrec :: Int -> Stamp -> ShowS
Show


class Flag flag where

type FlagContainer = Word.Word8
{-# LINE 57 "src/Sound/ALSA/Sequencer/Marshal/Time.hsc" #-}

stampTick, stampReal :: Flag flag => FlagSet.MaskedValue FlagContainer flag
stampTick :: forall flag. Flag flag => MaskedValue FlagContainer flag
stampTick =
   forall w a. w -> w -> MaskedValue w a
FlagSet.MaskedValue
      FlagContainer
1
{-# LINE 62 "src/Sound/ALSA/Sequencer/Marshal/Time.hsc" #-}
      0
{-# LINE 63 "src/Sound/ALSA/Sequencer/Marshal/Time.hsc" #-}
stampReal =
   FlagSet.MaskedValue
      1
{-# LINE 66 "src/Sound/ALSA/Sequencer/Marshal/Time.hsc" #-}
      1
{-# LINE 67 "src/Sound/ALSA/Sequencer/Marshal/Time.hsc" #-}


modeAbs, modeRel :: Flag flag => FlagSet.MaskedValue FlagContainer flag
modeAbs :: forall flag. Flag flag => MaskedValue FlagContainer flag
modeAbs =
   forall w a. w -> w -> MaskedValue w a
FlagSet.MaskedValue
      FlagContainer
2
{-# LINE 73 "src/Sound/ALSA/Sequencer/Marshal/Time.hsc" #-}
      0
{-# LINE 74 "src/Sound/ALSA/Sequencer/Marshal/Time.hsc" #-}
modeRel =
   FlagSet.MaskedValue
      2
{-# LINE 77 "src/Sound/ALSA/Sequencer/Marshal/Time.hsc" #-}
      2
{-# LINE 78 "src/Sound/ALSA/Sequencer/Marshal/Time.hsc" #-}


peek :: Flag flag => FlagSet.T FlagContainer flag -> Ptr T -> IO T
peek :: forall flag. Flag flag => T FlagContainer flag -> Ptr T -> IO T
peek T FlagContainer flag
flags Ptr T
p =
   forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
      (Mode -> Stamp -> T
Cons
         (if forall w a. Bits w => T w a -> MaskedValue w a -> Bool
FlagSet.match T FlagContainer flag
flags forall flag. Flag flag => MaskedValue FlagContainer flag
modeAbs
            then Mode
Absolute
            else Mode
Relative)) forall a b. (a -> b) -> a -> b
$
   forall flag.
Flag flag =>
T FlagContainer flag -> Ptr Stamp -> IO Stamp
peekStamp T FlagContainer flag
flags forall a b. (a -> b) -> a -> b
$ forall a b. Ptr a -> Ptr b
castPtr Ptr T
p

poke :: Flag flag => Ptr T -> T -> IO (FlagSet.MaskedValue FlagContainer flag)
poke :: forall flag.
Flag flag =>
Ptr T -> T -> IO (MaskedValue FlagContainer flag)
poke Ptr T
p (Cons Mode
m Stamp
st) =
   forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. Monoid a => a -> a -> a
mappend
      (case Mode
m of
         Mode
Absolute -> forall flag. Flag flag => MaskedValue FlagContainer flag
modeAbs
         Mode
Relative -> forall flag. Flag flag => MaskedValue FlagContainer flag
modeRel)) forall a b. (a -> b) -> a -> b
$
   forall flag.
Flag flag =>
Ptr Stamp -> Stamp -> IO (MaskedValue FlagContainer flag)
pokeStamp (forall a b. Ptr a -> Ptr b
castPtr Ptr T
p) Stamp
st


peekStamp :: Flag flag => FlagSet.T FlagContainer flag -> Ptr Stamp -> IO Stamp
peekStamp :: forall flag.
Flag flag =>
T FlagContainer flag -> Ptr Stamp -> IO Stamp
peekStamp T FlagContainer flag
flags Ptr Stamp
p =
   if forall w a. Bits w => T w a -> MaskedValue w a -> Bool
FlagSet.match T FlagContainer flag
flags forall flag. Flag flag => MaskedValue FlagContainer flag
stampTick
     then forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Tick -> Stamp
Tick forall a b. (a -> b) -> a -> b
$ forall a. Storable a => Ptr a -> IO a
St.peek forall a b. (a -> b) -> a -> b
$ forall a b. Ptr a -> Ptr b
castPtr Ptr Stamp
p
     else forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap T -> Stamp
Real forall a b. (a -> b) -> a -> b
$ forall a. Storable a => Ptr a -> IO a
St.peek forall a b. (a -> b) -> a -> b
$ forall a b. Ptr a -> Ptr b
castPtr Ptr Stamp
p

pokeStamp :: Flag flag => Ptr Stamp -> Stamp -> IO (FlagSet.MaskedValue FlagContainer flag)
pokeStamp :: forall flag.
Flag flag =>
Ptr Stamp -> Stamp -> IO (MaskedValue FlagContainer flag)
pokeStamp Ptr Stamp
p Stamp
ts = case Stamp
ts of
   Tick Tick
t -> forall a. Storable a => Ptr a -> a -> IO ()
St.poke (forall a b. Ptr a -> Ptr b
castPtr Ptr Stamp
p) Tick
t forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return forall flag. Flag flag => MaskedValue FlagContainer flag
stampTick
   Real T
t -> forall a. Storable a => Ptr a -> a -> IO ()
St.poke (forall a b. Ptr a -> Ptr b
castPtr Ptr Stamp
p) T
t forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return forall flag. Flag flag => MaskedValue FlagContainer flag
stampReal