{-# LINE 1 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
--------------------------------------------------------------------------------
-- |
-- Module    : Sound.ALSA.Sequencer.Marshal.Event
-- Copyright : (c) Henning Thielemann, 2011-2012
--             (c) Iavor S. Diatchki, 2007
-- License   : BSD3
--
-- Maintainer: Henning Thielemann
-- Stability : provisional
--
-- PRIVATE MODULE.
--
-- Here we have the various types used by the library,
-- and how they are imported\/exported to C.
--
-- We use Hsc for expanding C types to Haskell types like Word32.
-- However if a C type is translated to Word32
-- you should not assume that it is translated to Word32 on every platform.
-- On a 64bit machine it may well be Word64.
-- Thus you should use our wrapper types whereever possible.
--------------------------------------------------------------------------------

{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module Sound.ALSA.Sequencer.Marshal.Event where




import qualified Sound.ALSA.Sequencer.Marshal.Connect as Connect
import qualified Sound.ALSA.Sequencer.Marshal.Address as Addr
import qualified Sound.ALSA.Sequencer.Marshal.Queue as Queue
import qualified Sound.ALSA.Sequencer.Marshal.RealTime as RealTime
import qualified Sound.ALSA.Sequencer.Marshal.Time as Time

import qualified Data.ByteString.Unsafe as BU
import qualified Data.ByteString as B

import qualified Foreign.Marshal.Alloc as MA
import qualified Foreign.C.Types as C
import qualified Data.Int as Int
import qualified Data.Word as Word
import Foreign.Storable
          (Storable, sizeOf, alignment, peek, poke, pokeByteOff, peekByteOff, )
import Foreign.Ptr (Ptr, castPtr, nullPtr, plusPtr, )
import Control.Monad (liftM2, )
import Data.Monoid (mappend, )
import qualified Data.FlagSet as FlagSet
import Data.Array (Ix, Array, (!), accumArray, )
import Data.Tuple.HT (mapFst, )


data Flag
type Flags     = FlagSet.T Word.Word8 Flag
{-# LINE 54 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
type FlagValue = FlagSet.MaskedValue Word.Word8 Flag
{-# LINE 55 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

instance Time.Flag Flag where


eventLengthFixed, eventLengthVariable, eventLengthVarUser :: FlagValue
eventLengthFixed :: FlagValue
eventLengthFixed =
   forall w a. w -> w -> MaskedValue w a
FlagSet.MaskedValue
      Word8
12
{-# LINE 63 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
      0
{-# LINE 64 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
eventLengthVariable =
   FlagSet.MaskedValue
      12
{-# LINE 67 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
      4
{-# LINE 68 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
eventLengthVarUser =
   FlagSet.MaskedValue
      12
{-# LINE 71 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
      8
{-# LINE 72 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}


priorityHigh, priorityNormal :: FlagValue
priorityHigh :: FlagValue
priorityHigh =
   forall w a. w -> w -> MaskedValue w a
FlagSet.MaskedValue
      Word8
16
{-# LINE 78 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
      16
{-# LINE 79 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
priorityNormal =
   FlagSet.MaskedValue
      16
{-# LINE 82 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
      0
{-# LINE 83 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}



{- available in alsa-1.0.14, but gone in 1.0.22
#{newinttype "InstrCluster", snd_seq_instr_cluster_t}

#{newintfieldtype "StandardId", snd_seq_instr_t, std}
#{newintfieldtype "Bank",       snd_seq_instr_t, bank}
#{newintfieldtype "Program",    snd_seq_instr_t, prg}

data Instr = Instr
   { instrCluster :: !InstrCluster
    -- XXX: perhaps use Sample?
   , instrStd     :: !StandardId
   , instrBank    :: !Bank
   , instrPrg     :: !Program
   } deriving (Show)

instance Storable Instr where
  sizeOf _    = #{size snd_seq_instr_t}
  alignment _ = #{alignment snd_seq_instr_t}
  peek p      = do cl <- #{peek snd_seq_instr_t, cluster} p
                   st <- #{peek snd_seq_instr_t, std} p
                   ba <- #{peek snd_seq_instr_t, bank} p
                   pr <- #{peek snd_seq_instr_t, prg} p
                   return Instr { instrCluster = cl
                                , instrStd     = st
                                , instrBank    = ba
                                , instrPrg     = pr
                                }
  poke p v    = #{poke snd_seq_instr_t, cluster} p (instrCluster v)
             >> #{poke snd_seq_instr_t, std}     p (instrStd v)
             >> #{poke snd_seq_instr_t, bank}    p (instrBank v)
             >> #{poke snd_seq_instr_t, prg}     p (instrPrg v)
-}


newtype Channel = Channel { Channel -> Word8
unChannel :: Word.Word8 }
 deriving (Int -> Channel -> ShowS
[Channel] -> ShowS
Channel -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Channel] -> ShowS
$cshowList :: [Channel] -> ShowS
show :: Channel -> String
$cshow :: Channel -> String
showsPrec :: Int -> Channel -> ShowS
$cshowsPrec :: Int -> Channel -> ShowS
Show, Channel -> Channel -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Channel -> Channel -> Bool
$c/= :: Channel -> Channel -> Bool
== :: Channel -> Channel -> Bool
$c== :: Channel -> Channel -> Bool
Eq, Eq Channel
Channel -> Channel -> Bool
Channel -> Channel -> Ordering
Channel -> Channel -> Channel
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
min :: Channel -> Channel -> Channel
$cmin :: Channel -> Channel -> Channel
max :: Channel -> Channel -> Channel
$cmax :: Channel -> Channel -> Channel
>= :: Channel -> Channel -> Bool
$c>= :: Channel -> Channel -> Bool
> :: Channel -> Channel -> Bool
$c> :: Channel -> Channel -> Bool
<= :: Channel -> Channel -> Bool
$c<= :: Channel -> Channel -> Bool
< :: Channel -> Channel -> Bool
$c< :: Channel -> Channel -> Bool
compare :: Channel -> Channel -> Ordering
$ccompare :: Channel -> Channel -> Ordering
Ord, Ord Channel
(Channel, Channel) -> Int
(Channel, Channel) -> [Channel]
(Channel, Channel) -> Channel -> Bool
(Channel, Channel) -> Channel -> Int
forall a.
Ord a
-> ((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
unsafeRangeSize :: (Channel, Channel) -> Int
$cunsafeRangeSize :: (Channel, Channel) -> Int
rangeSize :: (Channel, Channel) -> Int
$crangeSize :: (Channel, Channel) -> Int
inRange :: (Channel, Channel) -> Channel -> Bool
$cinRange :: (Channel, Channel) -> Channel -> Bool
unsafeIndex :: (Channel, Channel) -> Channel -> Int
$cunsafeIndex :: (Channel, Channel) -> Channel -> Int
index :: (Channel, Channel) -> Channel -> Int
$cindex :: (Channel, Channel) -> Channel -> Int
range :: (Channel, Channel) -> [Channel]
$crange :: (Channel, Channel) -> [Channel]
Ix, Ptr Channel -> IO Channel
Ptr Channel -> Int -> IO Channel
Ptr Channel -> Int -> Channel -> IO ()
Ptr Channel -> Channel -> IO ()
Channel -> Int
forall b. Ptr b -> Int -> IO Channel
forall b. Ptr b -> Int -> Channel -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr Channel -> Channel -> IO ()
$cpoke :: Ptr Channel -> Channel -> IO ()
peek :: Ptr Channel -> IO Channel
$cpeek :: Ptr Channel -> IO Channel
pokeByteOff :: forall b. Ptr b -> Int -> Channel -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> Channel -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO Channel
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Channel
pokeElemOff :: Ptr Channel -> Int -> Channel -> IO ()
$cpokeElemOff :: Ptr Channel -> Int -> Channel -> IO ()
peekElemOff :: Ptr Channel -> Int -> IO Channel
$cpeekElemOff :: Ptr Channel -> Int -> IO Channel
alignment :: Channel -> Int
$calignment :: Channel -> Int
sizeOf :: Channel -> Int
$csizeOf :: Channel -> Int
Storable)

{-# LINE 121 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
newtype Pitch = Pitch { unPitch :: Word.Word8 }
 deriving (Show, Eq, Ord, Ix, Storable)

{-# LINE 122 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
newtype Velocity = Velocity { unVelocity :: Word.Word8 }
 deriving (Show, Eq, Ord, Ix, Storable)

{-# LINE 123 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
newtype Duration = Duration { unDuration :: Word.Word32 }
 deriving (Show, Eq, Ord, Ix, Storable)

{-# LINE 124 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

data Note = Note
   { noteChannel      :: !Channel
   , noteNote         :: !Pitch
   , noteVelocity     :: !Velocity
   , noteOffVelocity  :: !Velocity
   , noteDuration     :: !Duration
   } deriving (Show)


instance Storable Note where
  sizeOf :: Note -> Int
sizeOf Note
_    = (Int
8)
{-# LINE 136 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  alignment _ = 4
{-# LINE 137 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  peek p      = do c  <- (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 138 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
                   n  <- (\hsc_ptr -> peekByteOff hsc_ptr 1) p
{-# LINE 139 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
                   v  <- (\hsc_ptr -> peekByteOff hsc_ptr 2) p
{-# LINE 140 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
                   ov <- (\hsc_ptr -> peekByteOff hsc_ptr 3) p
{-# LINE 141 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
                   d  <- (\hsc_ptr -> peekByteOff hsc_ptr 4) p
{-# LINE 142 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
                   return Note { noteChannel = c
                               , noteNote = n
                               , noteVelocity = v
                               , noteOffVelocity = ov
                               , noteDuration = d
                               }
  poke :: Ptr Note -> Note -> IO ()
poke Ptr Note
p Note
v    = (\Ptr Note
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr Note
hsc_ptr Int
0)      Ptr Note
p (Note -> Channel
noteChannel Note
v)
{-# LINE 149 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
             forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (\Ptr Note
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr Note
hsc_ptr Int
1)         Ptr Note
p (Note -> Pitch
noteNote Note
v)
{-# LINE 150 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
             forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (\Ptr Note
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr Note
hsc_ptr Int
2)     Ptr Note
p (Note -> Velocity
noteVelocity Note
v)
{-# LINE 151 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
             forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (\Ptr Note
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr Note
hsc_ptr Int
3) Ptr Note
p (Note -> Velocity
noteOffVelocity Note
v)
{-# LINE 152 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
             forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (\Ptr Note
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr Note
hsc_ptr Int
4)     Ptr Note
p (Note -> Duration
noteDuration Note
v)
{-# LINE 153 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}


newtype Parameter = Parameter { Parameter -> Word32
unParameter :: Word.Word32 }
 deriving (Int -> Parameter -> ShowS
[Parameter] -> ShowS
Parameter -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Parameter] -> ShowS
$cshowList :: [Parameter] -> ShowS
show :: Parameter -> String
$cshow :: Parameter -> String
showsPrec :: Int -> Parameter -> ShowS
$cshowsPrec :: Int -> Parameter -> ShowS
Show, Parameter -> Parameter -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Parameter -> Parameter -> Bool
$c/= :: Parameter -> Parameter -> Bool
== :: Parameter -> Parameter -> Bool
$c== :: Parameter -> Parameter -> Bool
Eq, Eq Parameter
Parameter -> Parameter -> Bool
Parameter -> Parameter -> Ordering
Parameter -> Parameter -> Parameter
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
min :: Parameter -> Parameter -> Parameter
$cmin :: Parameter -> Parameter -> Parameter
max :: Parameter -> Parameter -> Parameter
$cmax :: Parameter -> Parameter -> Parameter
>= :: Parameter -> Parameter -> Bool
$c>= :: Parameter -> Parameter -> Bool
> :: Parameter -> Parameter -> Bool
$c> :: Parameter -> Parameter -> Bool
<= :: Parameter -> Parameter -> Bool
$c<= :: Parameter -> Parameter -> Bool
< :: Parameter -> Parameter -> Bool
$c< :: Parameter -> Parameter -> Bool
compare :: Parameter -> Parameter -> Ordering
$ccompare :: Parameter -> Parameter -> Ordering
Ord, Ord Parameter
(Parameter, Parameter) -> Int
(Parameter, Parameter) -> [Parameter]
(Parameter, Parameter) -> Parameter -> Bool
(Parameter, Parameter) -> Parameter -> Int
forall a.
Ord a
-> ((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
unsafeRangeSize :: (Parameter, Parameter) -> Int
$cunsafeRangeSize :: (Parameter, Parameter) -> Int
rangeSize :: (Parameter, Parameter) -> Int
$crangeSize :: (Parameter, Parameter) -> Int
inRange :: (Parameter, Parameter) -> Parameter -> Bool
$cinRange :: (Parameter, Parameter) -> Parameter -> Bool
unsafeIndex :: (Parameter, Parameter) -> Parameter -> Int
$cunsafeIndex :: (Parameter, Parameter) -> Parameter -> Int
index :: (Parameter, Parameter) -> Parameter -> Int
$cindex :: (Parameter, Parameter) -> Parameter -> Int
range :: (Parameter, Parameter) -> [Parameter]
$crange :: (Parameter, Parameter) -> [Parameter]
Ix, Ptr Parameter -> IO Parameter
Ptr Parameter -> Int -> IO Parameter
Ptr Parameter -> Int -> Parameter -> IO ()
Ptr Parameter -> Parameter -> IO ()
Parameter -> Int
forall b. Ptr b -> Int -> IO Parameter
forall b. Ptr b -> Int -> Parameter -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr Parameter -> Parameter -> IO ()
$cpoke :: Ptr Parameter -> Parameter -> IO ()
peek :: Ptr Parameter -> IO Parameter
$cpeek :: Ptr Parameter -> IO Parameter
pokeByteOff :: forall b. Ptr b -> Int -> Parameter -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> Parameter -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO Parameter
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Parameter
pokeElemOff :: Ptr Parameter -> Int -> Parameter -> IO ()
$cpokeElemOff :: Ptr Parameter -> Int -> Parameter -> IO ()
peekElemOff :: Ptr Parameter -> Int -> IO Parameter
$cpeekElemOff :: Ptr Parameter -> Int -> IO Parameter
alignment :: Parameter -> Int
$calignment :: Parameter -> Int
sizeOf :: Parameter -> Int
$csizeOf :: Parameter -> Int
Storable)

{-# LINE 156 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
newtype Value = Value { unValue :: Int.Int32 }
 deriving (Show, Eq, Ord, Ix, Storable)

{-# LINE 157 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

data Ctrl = Ctrl
   { ctrlChannel  :: !Channel
   , ctrlParam    :: !Parameter
   , ctrlValue    :: !Value
   } deriving (Show)

instance Storable Ctrl where
  sizeOf :: Ctrl -> Int
sizeOf Ctrl
_    = (Int
12)
{-# LINE 166 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  alignment _ = 4
{-# LINE 167 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  peek p      = do ct <- (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 168 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
                   pa <- (\hsc_ptr -> peekByteOff hsc_ptr 4) p
{-# LINE 169 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
                   va <- (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 170 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
                   return Ctrl { ctrlChannel = ct
                               , ctrlParam   = pa
                               , ctrlValue   = va
                               }
  poke :: Ptr Ctrl -> Ctrl -> IO ()
poke Ptr Ctrl
p Ctrl
v    = (\Ptr Ctrl
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr Ctrl
hsc_ptr Int
0) Ptr Ctrl
p (Ctrl -> Channel
ctrlChannel Ctrl
v)
{-# LINE 175 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
             forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (\Ptr Ctrl
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr Ctrl
hsc_ptr Int
4)   Ptr Ctrl
p (Ctrl -> Parameter
ctrlParam Ctrl
v)
{-# LINE 176 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
             forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (\Ptr Ctrl
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr Ctrl
hsc_ptr Int
8)   Ptr Ctrl
p (Ctrl -> Value
ctrlValue Ctrl
v)
{-# LINE 177 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}


pokeQueue ::
  Ptr Data -> QueueEv -> Queue.T -> IO EType
pokeQueue :: Ptr Data -> QueueEv -> T -> IO EType
pokeQueue Ptr Data
p QueueEv
e T
q = do
  forall a. Storable a => Ptr a -> a -> IO ()
poke (forall a b. Ptr a -> Ptr b
castPtr Ptr Data
p) T
q
  case QueueEv
e of
    QueueSetPosTick Word32
t -> (\Ptr Data
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr Data
hsc_ptr Int
4) Ptr Data
p Word32
t
{-# LINE 185 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
    QueueSetPosTime t -> (\hsc_ptr -> pokeByteOff hsc_ptr 4) p t
{-# LINE 186 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
    QueueTempo      t -> (\hsc_ptr -> pokeByteOff hsc_ptr 4) p t
{-# LINE 187 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
    QueueSkew       s -> (\hsc_ptr -> pokeByteOff hsc_ptr 4) p s
{-# LINE 188 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
    QueueSyncPos    s -> (\hsc_ptr -> pokeByteOff hsc_ptr 4) p s
{-# LINE 189 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
    _ -> return ()
  forall (m :: * -> *) a. Monad m => a -> m a
return (forall e. Type e => e -> EType
expEv QueueEv
e)


{- available in alsa-1.0.14, but gone in 1.0.22
data Sample = Sample
   { sampleStd  :: !StandardId
   , sampleBank :: !Bank
   , samplePrg  :: !Program
   } deriving (Show)

instance Storable Sample where
  sizeOf _    = #{size snd_seq_ev_sample_t}
  alignment _ = #{alignment snd_seq_ev_sample_t}
  peek p      = do st <- #{peek snd_seq_ev_sample_t, std} p
                   ba <- #{peek snd_seq_ev_sample_t, bank} p
                   pr <- #{peek snd_seq_ev_sample_t, prg} p
                   return Sample { sampleStd     = st
                                 , sampleBank    = ba
                                 , samplePrg     = pr
                                 }
  poke p v    = #{poke snd_seq_ev_sample_t, std}     p (sampleStd v)
             >> #{poke snd_seq_ev_sample_t, bank}    p (sampleBank v)
             >> #{poke snd_seq_ev_sample_t, prg}     p (samplePrg v)


newtype Cluster = Cluster
   { clusterCluster :: InstrCluster
   } deriving (Show, Eq, Storable)


#{newintfieldtype "Volume",  snd_seq_ev_volume_t, volume}
#{newintfieldtype "Balance", snd_seq_ev_volume_t, lr}

-- | These are all 14 bit values.
data VolumeControl = VolumeControl
   { volumeVolume  :: !Volume
   , volumeLR      :: !Balance
   , volumeFR      :: !Balance
   , volumeDU      :: !Balance
   } deriving (Show)

instance Storable VolumeControl where
  sizeOf _    = #{size snd_seq_ev_volume_t}
  alignment _ = #{alignment snd_seq_ev_volume_t}
  peek p      = do v <- #{peek snd_seq_ev_volume_t, volume} p
                   l <- #{peek snd_seq_ev_volume_t, lr} p
                   f <- #{peek snd_seq_ev_volume_t, fr} p
                   d <- #{peek snd_seq_ev_volume_t, du} p
                   return VolumeControl
                                 { volumeVolume  = v
                                 , volumeLR      = l
                                 , volumeFR      = f
                                 , volumeDU      = d
                                 }
  poke p v    = #{poke snd_seq_ev_volume_t, volume} p (volumeVolume v)
             >> #{poke snd_seq_ev_volume_t, lr}     p (volumeLR v)
             >> #{poke snd_seq_ev_volume_t, fr}     p (volumeFR v)
             >> #{poke snd_seq_ev_volume_t, du}     p (volumeDU v)
-}


data Custom =
  Custom {
    Custom -> Word32
custom0, Custom -> Word32
custom1, Custom -> Word32
custom2 :: !(Word.Word32)
{-# LINE 254 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  } deriving (Show)

instance Storable Custom where
  sizeOf :: Custom -> Int
sizeOf Custom
_    = (Int
12)
{-# LINE 258 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  alignment _ = 4
{-# LINE 259 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  peek p      = do d0 <- (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 260 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
                   d1 <- (\hsc_ptr -> peekByteOff hsc_ptr 4) p
{-# LINE 261 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
                   d2 <- (\hsc_ptr -> peekByteOff hsc_ptr 8) p
{-# LINE 262 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
                   return Custom { custom0 = d0
                                 , custom1 = d1
                                 , custom2 = d2
                                 }
  poke :: Ptr Custom -> Custom -> IO ()
poke Ptr Custom
p Custom
v    = (\Ptr Custom
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr Custom
hsc_ptr Int
0) Ptr Custom
p (Custom -> Word32
custom0 Custom
v)
{-# LINE 267 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
             forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (\Ptr Custom
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr Custom
hsc_ptr Int
4) Ptr Custom
p (Custom -> Word32
custom1 Custom
v)
{-# LINE 268 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
             forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (\Ptr Custom
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr Custom
hsc_ptr Int
8) Ptr Custom
p (Custom -> Word32
custom2 Custom
v)
{-# LINE 269 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}


newtype Tag = Tag { Tag -> Word8
unTag :: Word.Word8 }
 deriving (Int -> Tag -> ShowS
[Tag] -> ShowS
Tag -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Tag] -> ShowS
$cshowList :: [Tag] -> ShowS
show :: Tag -> String
$cshow :: Tag -> String
showsPrec :: Int -> Tag -> ShowS
$cshowsPrec :: Int -> Tag -> ShowS
Show, Tag -> Tag -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Tag -> Tag -> Bool
$c/= :: Tag -> Tag -> Bool
== :: Tag -> Tag -> Bool
$c== :: Tag -> Tag -> Bool
Eq, Eq Tag
Tag -> Tag -> Bool
Tag -> Tag -> Ordering
Tag -> Tag -> Tag
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
min :: Tag -> Tag -> Tag
$cmin :: Tag -> Tag -> Tag
max :: Tag -> Tag -> Tag
$cmax :: Tag -> Tag -> Tag
>= :: Tag -> Tag -> Bool
$c>= :: Tag -> Tag -> Bool
> :: Tag -> Tag -> Bool
$c> :: Tag -> Tag -> Bool
<= :: Tag -> Tag -> Bool
$c<= :: Tag -> Tag -> Bool
< :: Tag -> Tag -> Bool
$c< :: Tag -> Tag -> Bool
compare :: Tag -> Tag -> Ordering
$ccompare :: Tag -> Tag -> Ordering
Ord, Ord Tag
(Tag, Tag) -> Int
(Tag, Tag) -> [Tag]
(Tag, Tag) -> Tag -> Bool
(Tag, Tag) -> Tag -> Int
forall a.
Ord a
-> ((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
unsafeRangeSize :: (Tag, Tag) -> Int
$cunsafeRangeSize :: (Tag, Tag) -> Int
rangeSize :: (Tag, Tag) -> Int
$crangeSize :: (Tag, Tag) -> Int
inRange :: (Tag, Tag) -> Tag -> Bool
$cinRange :: (Tag, Tag) -> Tag -> Bool
unsafeIndex :: (Tag, Tag) -> Tag -> Int
$cunsafeIndex :: (Tag, Tag) -> Tag -> Int
index :: (Tag, Tag) -> Tag -> Int
$cindex :: (Tag, Tag) -> Tag -> Int
range :: (Tag, Tag) -> [Tag]
$crange :: (Tag, Tag) -> [Tag]
Ix, Ptr Tag -> IO Tag
Ptr Tag -> Int -> IO Tag
Ptr Tag -> Int -> Tag -> IO ()
Ptr Tag -> Tag -> IO ()
Tag -> Int
forall b. Ptr b -> Int -> IO Tag
forall b. Ptr b -> Int -> Tag -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr Tag -> Tag -> IO ()
$cpoke :: Ptr Tag -> Tag -> IO ()
peek :: Ptr Tag -> IO Tag
$cpeek :: Ptr Tag -> IO Tag
pokeByteOff :: forall b. Ptr b -> Int -> Tag -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> Tag -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO Tag
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Tag
pokeElemOff :: Ptr Tag -> Int -> Tag -> IO ()
$cpokeElemOff :: Ptr Tag -> Int -> Tag -> IO ()
peekElemOff :: Ptr Tag -> Int -> IO Tag
$cpeekElemOff :: Ptr Tag -> Int -> IO Tag
alignment :: Tag -> Int
$calignment :: Tag -> Int
sizeOf :: Tag -> Int
$csizeOf :: Tag -> Int
Storable)

{-# LINE 272 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

data T = Cons
   { highPriority   :: !Bool
   , tag            :: !Tag
   , queue          :: !Queue.T
   , time           :: !Time.T
   , source         :: !Addr.T
   , dest           :: !Addr.T
   , body           :: !Data
   } deriving Show

instance Storable T where
  sizeOf :: T -> Int
sizeOf T
_    = (Int
28)
{-# LINE 285 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  alignment _ = 4
{-# LINE 286 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  peek p =
    do ty    <- (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 288 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
       flags <- (\hsc_ptr -> peekByteOff hsc_ptr 1) p
{-# LINE 289 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
       tg    <- (\hsc_ptr -> peekByteOff hsc_ptr 2) p
{-# LINE 290 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
       q     <- (\hsc_ptr -> peekByteOff hsc_ptr 3) p
{-# LINE 291 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
       t     <- Time.peek flags ((\hsc_ptr -> hsc_ptr `plusPtr` 4) p)
{-# LINE 292 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
       src   <- (\hsc_ptr -> peekByteOff hsc_ptr 12) p
{-# LINE 293 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
       dst   <- (\hsc_ptr -> peekByteOff hsc_ptr 14) p
{-# LINE 294 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
       d     <- (peekData ! ty) ((\hsc_ptr -> hsc_ptr `plusPtr` 16) p)
{-# LINE 295 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
       return Cons
         { highPriority = not $ FlagSet.match flags priorityNormal
         , tag = tg
         , queue = q
         , time = t
         , source = src
         , dest = dst
         , body = d
         }
  poke :: Ptr T -> T -> IO ()
poke Ptr T
p T
e =
    Ptr T -> T -> FlagValue -> EType -> IO ()
pokeHeader Ptr T
p T
e FlagValue
eventLengthFixed
      forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr Data -> Data -> IO EType
pokeData ((\Ptr T
hsc_ptr -> Ptr T
hsc_ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) Ptr T
p) (T -> Data
body T
e)
{-# LINE 307 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

withMaybe :: Maybe T -> (Ptr T -> IO a) -> IO a
withMaybe :: forall a. Maybe T -> (Ptr T -> IO a) -> IO a
withMaybe Maybe T
me Ptr T -> IO a
f =
  forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Ptr T -> IO a
f forall a. Ptr a
nullPtr) (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a. T -> (Ptr T -> IO a) -> IO a
with Ptr T -> IO a
f) Maybe T
me

with :: T -> (Ptr T -> IO a) -> IO a
with :: forall a. T -> (Ptr T -> IO a) -> IO a
with T
ev Ptr T -> IO a
f =
  forall a b. Storable a => (Ptr a -> IO b) -> IO b
MA.alloca forall a b. (a -> b) -> a -> b
$ \Ptr T
p ->
    case T -> Data
body T
ev of
      ExtEv ExtEv
e ByteString
d -> do
        let lengthFlag :: FlagValue
lengthFlag =
              case ExtEv
e of
                ExtEv
SysEx -> FlagValue
eventLengthVariable
                ExtEv
Bounce -> FlagValue
eventLengthVariable
                ExtEv
_ -> FlagValue
eventLengthVarUser
        Ptr T -> T -> FlagValue -> EType -> IO ()
pokeHeader Ptr T
p T
ev FlagValue
lengthFlag (forall e. Type e => e -> EType
expEv ExtEv
e)
        forall a. ByteString -> (Ptr CChar -> IO a) -> IO a
BU.unsafeUseAsCString ByteString
d forall a b. (a -> b) -> a -> b
$ \Ptr CChar
ptr -> do
          (\Ptr T
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr T
hsc_ptr Int
16) Ptr T
p (ByteString -> Int
B.length ByteString
d)
{-# LINE 325 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
          (\Ptr T
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr T
hsc_ptr Int
20) Ptr T
p Ptr CChar
ptr
{-# LINE 326 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
          Ptr T -> IO a
f Ptr T
p
      Data
b -> do
        Ptr T -> T -> FlagValue -> EType -> IO ()
pokeHeader Ptr T
p T
ev FlagValue
eventLengthFixed
          forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Ptr Data -> Data -> IO EType
pokeData ((\Ptr T
hsc_ptr -> Ptr T
hsc_ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) Ptr T
p) Data
b
{-# LINE 330 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
        Ptr T -> IO a
f Ptr T
p


pokeBody ::
  (Storable d, Type e) =>
  Ptr Data -> e -> d -> IO EType
pokeBody :: forall d e. (Storable d, Type e) => Ptr Data -> e -> d -> IO EType
pokeBody Ptr Data
p e
e d
d =
  forall a. Storable a => Ptr a -> a -> IO ()
poke (forall a b. Ptr a -> Ptr b
castPtr Ptr Data
p) d
d forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return (forall e. Type e => e -> EType
expEv e
e)

pokeData :: Ptr Data -> Data -> IO EType
pokeData :: Ptr Data -> Data -> IO EType
pokeData Ptr Data
p Data
dt = case Data
dt of
  NoteEv   NoteEv
e Note
d -> forall d e. (Storable d, Type e) => Ptr Data -> e -> d -> IO EType
pokeBody Ptr Data
p NoteEv
e Note
d
  CtrlEv   CtrlEv
e Ctrl
d -> forall d e. (Storable d, Type e) => Ptr Data -> e -> d -> IO EType
pokeBody Ptr Data
p CtrlEv
e Ctrl
d
  QueueEv  QueueEv
e T
d -> Ptr Data -> QueueEv -> T -> IO EType
pokeQueue Ptr Data
p QueueEv
e T
d
  AddrEv   AddrEv
e T
d -> forall d e. (Storable d, Type e) => Ptr Data -> e -> d -> IO EType
pokeBody Ptr Data
p AddrEv
e T
d
  ConnEv   ConnEv
e T
d -> forall d e. (Storable d, Type e) => Ptr Data -> e -> d -> IO EType
pokeBody Ptr Data
p ConnEv
e T
d
  CustomEv CustomEv
e Custom
d -> forall d e. (Storable d, Type e) => Ptr Data -> e -> d -> IO EType
pokeBody Ptr Data
p CustomEv
e Custom
d
  ExtEv    ExtEv
_ ByteString
_ -> forall a. HasCallStack => String -> a
error String
"cannot simply poke ExtEv, because it needs allocation - use Event.with instead"
  EmptyEv  EmptyEv
e   -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall e. Type e => e -> EType
expEv EmptyEv
e)

pokeHeader :: Ptr T -> T -> FlagValue -> EType -> IO ()
pokeHeader :: Ptr T -> T -> FlagValue -> EType -> IO ()
pokeHeader Ptr T
p T
e FlagValue
lengthFlag EType
ty = do
  (\Ptr T
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr T
hsc_ptr Int
0) Ptr T
p EType
ty
{-# LINE 353 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  (\hsc_ptr -> pokeByteOff hsc_ptr 2) p (tag e)
{-# LINE 354 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  (\hsc_ptr -> pokeByteOff hsc_ptr 3) p (queue e)
{-# LINE 355 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  real <- Time.poke ((\hsc_ptr -> hsc_ptr `plusPtr` 4) p) (time e)
{-# LINE 356 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  (\hsc_ptr -> pokeByteOff hsc_ptr 12) p (source e)
{-# LINE 357 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  (\hsc_ptr -> pokeByteOff hsc_ptr 14) p (dest e)
{-# LINE 358 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  let flags =
         (if highPriority e
            then priorityHigh
            else priorityNormal)
         `mappend` real
         `mappend` lengthFlag
  (\Ptr T
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr T
hsc_ptr Int
1) Ptr T
p (forall w a. MaskedValue w a -> T w a
FlagSet.fromMaskedValue FlagValue
flags)
{-# LINE 365 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}


peekData :: Array EType (Ptr Data -> IO Data)
peekData :: Array EType (Ptr Data -> IO Data)
peekData =
  forall i e a.
Ix i =>
(e -> a -> e) -> e -> (i, i) -> [(i, a)] -> Array i e
accumArray (forall a b. a -> b -> a
const forall a. a -> a
id) Ptr Data -> IO Data
unknown (Word8 -> EType
EType Word8
0, Word8 -> EType
EType Word8
255) forall a b. (a -> b) -> a -> b
$
  forall a b. (a -> b) -> [a] -> [b]
map (forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst Word8 -> EType
EType) forall a b. (a -> b) -> a -> b
$
  [ -- result events (2)
    (Word8
0, Ptr Data -> IO Data
unknown)
{-# LINE 373 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (1, unknown)
{-# LINE 374 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

    -- note events (4)
  , (Word8
5,     NoteEv -> Ptr Data -> IO Data
peekNoteEv NoteEv
ANote)
{-# LINE 377 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (6,   peekNoteEv NoteOn)
{-# LINE 378 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (7,  peekNoteEv NoteOff)
{-# LINE 379 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (8, peekNoteEv KeyPress)
{-# LINE 380 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

    -- control events (12)
  , (Word8
10,  CtrlEv -> Ptr Data -> IO Data
peekCtrlEv CtrlEv
Controller)
{-# LINE 383 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (11,   peekCtrlEv PgmChange)
{-# LINE 384 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (12,   peekCtrlEv ChanPress)
{-# LINE 385 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (13,   peekCtrlEv PitchBend)
{-# LINE 386 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (14,   peekCtrlEv Control14)
{-# LINE 387 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (15, peekCtrlEv NonRegParam)
{-# LINE 388 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (16,    peekCtrlEv RegParam)
{-# LINE 389 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (20,     peekCtrlEv SongPos)
{-# LINE 390 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (21,     peekCtrlEv SongSel)
{-# LINE 391 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (22,      peekCtrlEv QFrame)
{-# LINE 392 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (23,    peekCtrlEv TimeSign)
{-# LINE 393 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (24,     peekCtrlEv KeySign)
{-# LINE 394 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

  -- queue control (10)
  , (Word8
30,       QueueEv -> Ptr Data -> IO Data
peekQueueEv  QueueEv
QueueStart)
{-# LINE 397 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (31,    peekQueueEv  QueueContinue)
{-# LINE 398 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (32,        peekQueueEv  QueueStop)
{-# LINE 399 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (33, peekQueueExt QueueSetPosTick (\hsc_ptr -> peekByteOff hsc_ptr 4 :: IO Word.Word32))
{-# LINE 400 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (34, peekQueueExt QueueSetPosTime (\hsc_ptr -> peekByteOff hsc_ptr 4))
{-# LINE 401 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (35,       peekQueueExt QueueTempo      (\hsc_ptr -> peekByteOff hsc_ptr 4))
{-# LINE 402 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (36,       peekQueueEv  QueueClock)
{-# LINE 403 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (37,        peekQueueEv  QueueTick)
{-# LINE 404 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (38,  peekQueueExt QueueSkew       (\hsc_ptr -> peekByteOff hsc_ptr 4))
{-# LINE 405 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (39,    peekQueueExt QueueSyncPos    (\hsc_ptr -> peekByteOff hsc_ptr 4))
{-# LINE 406 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

  -- misc (3)
  , (Word8
40, EmptyEv -> Ptr Data -> IO Data
peekEmptyEv EmptyEv
TuneRequest)
{-# LINE 409 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (41,        peekEmptyEv Reset)
{-# LINE 410 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (42,      peekEmptyEv Sensing)
{-# LINE 411 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

  , (Word8
50, CustomEv -> Ptr Data -> IO Data
peekCustomEv CustomEv
Echo)
{-# LINE 413 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (51,  peekCustomEv OSS)
{-# LINE 414 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

  -- networking (8)
  , (Word8
60,  AddrEv -> Ptr Data -> IO Data
peekAddrEv AddrEv
ClientStart)
{-# LINE 417 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (61,   peekAddrEv ClientExit)
{-# LINE 418 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (62, peekAddrEv ClientChange)
{-# LINE 419 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (63,    peekAddrEv PortStart)
{-# LINE 420 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (64,     peekAddrEv PortExit)
{-# LINE 421 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (65,   peekAddrEv PortChange)
{-# LINE 422 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (66,   peekConnEv PortSubscribed)
{-# LINE 423 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (67, peekConnEv PortUnsubscribed)
{-# LINE 424 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

{- available in alsa-1.0.14, but gone in 1.0.22
  , (#{const SND_SEQ_EVENT_SAMPLE}, unknown)
  , (#{const SND_SEQ_EVENT_SAMPLE_CLUSTER}, unknown)
  , (#{const SND_SEQ_EVENT_SAMPLE_START}, unknown)
  , (#{const SND_SEQ_EVENT_SAMPLE_STOP}, unknown)
  , (#{const SND_SEQ_EVENT_SAMPLE_FREQ}, unknown)
  , (#{const SND_SEQ_EVENT_SAMPLE_VOLUME}, unknown)
  , (#{const SND_SEQ_EVENT_SAMPLE_LOOP}, unknown)
  , (#{const SND_SEQ_EVENT_SAMPLE_POSITION}, unknown)
  , (#{const SND_SEQ_EVENT_SAMPLE_PRIVATE1}, unknown)
-}
  , (Word8
90, CustomEv -> Ptr Data -> IO Data
peekCustomEv CustomEv
User0)
{-# LINE 437 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (91, peekCustomEv User1)
{-# LINE 438 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (92, peekCustomEv User2)
{-# LINE 439 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (93, peekCustomEv User3)
{-# LINE 440 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (94, peekCustomEv User4)
{-# LINE 441 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (95, peekCustomEv User5)
{-# LINE 442 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (96, peekCustomEv User6)
{-# LINE 443 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (97, peekCustomEv User7)
{-# LINE 444 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (98, peekCustomEv User8)
{-# LINE 445 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (99, peekCustomEv User9)
{-# LINE 446 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

{- available in alsa-1.0.14, but gone in 1.0.22
  , (#{const SND_SEQ_EVENT_INSTR_BEGIN}, unknown)
  , (#{const SND_SEQ_EVENT_INSTR_END}, unknown)
  , (#{const SND_SEQ_EVENT_INSTR_INFO}, unknown)
  , (#{const SND_SEQ_EVENT_INSTR_INFO_RESULT}, unknown)
  , (#{const SND_SEQ_EVENT_INSTR_FINFO}, unknown)
  , (#{const SND_SEQ_EVENT_INSTR_FINFO_RESULT}, unknown)
  , (#{const SND_SEQ_EVENT_INSTR_RESET}, unknown)
  , (#{const SND_SEQ_EVENT_INSTR_STATUS}, unknown)
  , (#{const SND_SEQ_EVENT_INSTR_STATUS_RESULT}, unknown)
  , (#{const SND_SEQ_EVENT_INSTR_PUT}, unknown)
  , (#{const SND_SEQ_EVENT_INSTR_GET}, unknown)
  , (#{const SND_SEQ_EVENT_INSTR_GET_RESULT}, unknown)
  , (#{const SND_SEQ_EVENT_INSTR_FREE}, unknown)
  , (#{const SND_SEQ_EVENT_INSTR_LIST}, unknown)
  , (#{const SND_SEQ_EVENT_INSTR_LIST_RESULT}, unknown)
  , (#{const SND_SEQ_EVENT_INSTR_CLUSTER}, unknown)
  , (#{const SND_SEQ_EVENT_INSTR_CLUSTER_GET}, unknown)
  , (#{const SND_SEQ_EVENT_INSTR_CLUSTER_RESULT}, unknown)
  , (#{const SND_SEQ_EVENT_INSTR_CHANGE}, unknown)
-}

  , (Word8
130,    ExtEv -> Ptr Data -> IO Data
peekExtEv ExtEv
SysEx   )
{-# LINE 470 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (131,   peekExtEv Bounce  )
{-# LINE 471 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (135, peekExtEv UserVar0)
{-# LINE 472 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (136, peekExtEv UserVar1)
{-# LINE 473 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (137, peekExtEv UserVar2)
{-# LINE 474 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (138, peekExtEv UserVar3)
{-# LINE 475 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  , (138, peekExtEv UserVar4)
{-# LINE 476 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

  , (Word8
255, EmptyEv -> Ptr Data -> IO Data
peekEmptyEv EmptyEv
None)
{-# LINE 478 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  ]

  where unknown :: Ptr Data -> IO Data
unknown = EmptyEv -> Ptr Data -> IO Data
peekEmptyEv EmptyEv
Unknown


-- maybe rename to NoteType for consistency with Type class
data NoteEv   = ANote | NoteOn | NoteOff | KeyPress
                deriving (Int -> NoteEv -> ShowS
[NoteEv] -> ShowS
NoteEv -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NoteEv] -> ShowS
$cshowList :: [NoteEv] -> ShowS
show :: NoteEv -> String
$cshow :: NoteEv -> String
showsPrec :: Int -> NoteEv -> ShowS
$cshowsPrec :: Int -> NoteEv -> ShowS
Show, NoteEv -> NoteEv -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NoteEv -> NoteEv -> Bool
$c/= :: NoteEv -> NoteEv -> Bool
== :: NoteEv -> NoteEv -> Bool
$c== :: NoteEv -> NoteEv -> Bool
Eq, Eq NoteEv
NoteEv -> NoteEv -> Bool
NoteEv -> NoteEv -> Ordering
NoteEv -> NoteEv -> NoteEv
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
min :: NoteEv -> NoteEv -> NoteEv
$cmin :: NoteEv -> NoteEv -> NoteEv
max :: NoteEv -> NoteEv -> NoteEv
$cmax :: NoteEv -> NoteEv -> NoteEv
>= :: NoteEv -> NoteEv -> Bool
$c>= :: NoteEv -> NoteEv -> Bool
> :: NoteEv -> NoteEv -> Bool
$c> :: NoteEv -> NoteEv -> Bool
<= :: NoteEv -> NoteEv -> Bool
$c<= :: NoteEv -> NoteEv -> Bool
< :: NoteEv -> NoteEv -> Bool
$c< :: NoteEv -> NoteEv -> Bool
compare :: NoteEv -> NoteEv -> Ordering
$ccompare :: NoteEv -> NoteEv -> Ordering
Ord, Int -> NoteEv
NoteEv -> Int
NoteEv -> [NoteEv]
NoteEv -> NoteEv
NoteEv -> NoteEv -> [NoteEv]
NoteEv -> NoteEv -> NoteEv -> [NoteEv]
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 :: NoteEv -> NoteEv -> NoteEv -> [NoteEv]
$cenumFromThenTo :: NoteEv -> NoteEv -> NoteEv -> [NoteEv]
enumFromTo :: NoteEv -> NoteEv -> [NoteEv]
$cenumFromTo :: NoteEv -> NoteEv -> [NoteEv]
enumFromThen :: NoteEv -> NoteEv -> [NoteEv]
$cenumFromThen :: NoteEv -> NoteEv -> [NoteEv]
enumFrom :: NoteEv -> [NoteEv]
$cenumFrom :: NoteEv -> [NoteEv]
fromEnum :: NoteEv -> Int
$cfromEnum :: NoteEv -> Int
toEnum :: Int -> NoteEv
$ctoEnum :: Int -> NoteEv
pred :: NoteEv -> NoteEv
$cpred :: NoteEv -> NoteEv
succ :: NoteEv -> NoteEv
$csucc :: NoteEv -> NoteEv
Enum, NoteEv
forall a. a -> a -> Bounded a
maxBound :: NoteEv
$cmaxBound :: NoteEv
minBound :: NoteEv
$cminBound :: NoteEv
Bounded)

data CtrlEv   = Controller | PgmChange | ChanPress
              | PitchBend | Control14
              | NonRegParam | RegParam
              | SongPos | SongSel
              | QFrame
              | TimeSign | KeySign
                deriving (Int -> CtrlEv -> ShowS
[CtrlEv] -> ShowS
CtrlEv -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CtrlEv] -> ShowS
$cshowList :: [CtrlEv] -> ShowS
show :: CtrlEv -> String
$cshow :: CtrlEv -> String
showsPrec :: Int -> CtrlEv -> ShowS
$cshowsPrec :: Int -> CtrlEv -> ShowS
Show, CtrlEv -> CtrlEv -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CtrlEv -> CtrlEv -> Bool
$c/= :: CtrlEv -> CtrlEv -> Bool
== :: CtrlEv -> CtrlEv -> Bool
$c== :: CtrlEv -> CtrlEv -> Bool
Eq, Eq CtrlEv
CtrlEv -> CtrlEv -> Bool
CtrlEv -> CtrlEv -> Ordering
CtrlEv -> CtrlEv -> CtrlEv
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
min :: CtrlEv -> CtrlEv -> CtrlEv
$cmin :: CtrlEv -> CtrlEv -> CtrlEv
max :: CtrlEv -> CtrlEv -> CtrlEv
$cmax :: CtrlEv -> CtrlEv -> CtrlEv
>= :: CtrlEv -> CtrlEv -> Bool
$c>= :: CtrlEv -> CtrlEv -> Bool
> :: CtrlEv -> CtrlEv -> Bool
$c> :: CtrlEv -> CtrlEv -> Bool
<= :: CtrlEv -> CtrlEv -> Bool
$c<= :: CtrlEv -> CtrlEv -> Bool
< :: CtrlEv -> CtrlEv -> Bool
$c< :: CtrlEv -> CtrlEv -> Bool
compare :: CtrlEv -> CtrlEv -> Ordering
$ccompare :: CtrlEv -> CtrlEv -> Ordering
Ord, Int -> CtrlEv
CtrlEv -> Int
CtrlEv -> [CtrlEv]
CtrlEv -> CtrlEv
CtrlEv -> CtrlEv -> [CtrlEv]
CtrlEv -> CtrlEv -> CtrlEv -> [CtrlEv]
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 :: CtrlEv -> CtrlEv -> CtrlEv -> [CtrlEv]
$cenumFromThenTo :: CtrlEv -> CtrlEv -> CtrlEv -> [CtrlEv]
enumFromTo :: CtrlEv -> CtrlEv -> [CtrlEv]
$cenumFromTo :: CtrlEv -> CtrlEv -> [CtrlEv]
enumFromThen :: CtrlEv -> CtrlEv -> [CtrlEv]
$cenumFromThen :: CtrlEv -> CtrlEv -> [CtrlEv]
enumFrom :: CtrlEv -> [CtrlEv]
$cenumFrom :: CtrlEv -> [CtrlEv]
fromEnum :: CtrlEv -> Int
$cfromEnum :: CtrlEv -> Int
toEnum :: Int -> CtrlEv
$ctoEnum :: Int -> CtrlEv
pred :: CtrlEv -> CtrlEv
$cpred :: CtrlEv -> CtrlEv
succ :: CtrlEv -> CtrlEv
$csucc :: CtrlEv -> CtrlEv
Enum, CtrlEv
forall a. a -> a -> Bounded a
maxBound :: CtrlEv
$cmaxBound :: CtrlEv
minBound :: CtrlEv
$cminBound :: CtrlEv
Bounded)

newtype Tempo = Tempo { Tempo -> Int32
unTempo :: Int.Int32 }
 deriving (Int -> Tempo -> ShowS
[Tempo] -> ShowS
Tempo -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Tempo] -> ShowS
$cshowList :: [Tempo] -> ShowS
show :: Tempo -> String
$cshow :: Tempo -> String
showsPrec :: Int -> Tempo -> ShowS
$cshowsPrec :: Int -> Tempo -> ShowS
Show, Tempo -> Tempo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Tempo -> Tempo -> Bool
$c/= :: Tempo -> Tempo -> Bool
== :: Tempo -> Tempo -> Bool
$c== :: Tempo -> Tempo -> Bool
Eq, Eq Tempo
Tempo -> Tempo -> Bool
Tempo -> Tempo -> Ordering
Tempo -> Tempo -> Tempo
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
min :: Tempo -> Tempo -> Tempo
$cmin :: Tempo -> Tempo -> Tempo
max :: Tempo -> Tempo -> Tempo
$cmax :: Tempo -> Tempo -> Tempo
>= :: Tempo -> Tempo -> Bool
$c>= :: Tempo -> Tempo -> Bool
> :: Tempo -> Tempo -> Bool
$c> :: Tempo -> Tempo -> Bool
<= :: Tempo -> Tempo -> Bool
$c<= :: Tempo -> Tempo -> Bool
< :: Tempo -> Tempo -> Bool
$c< :: Tempo -> Tempo -> Bool
compare :: Tempo -> Tempo -> Ordering
$ccompare :: Tempo -> Tempo -> Ordering
Ord, Ord Tempo
(Tempo, Tempo) -> Int
(Tempo, Tempo) -> [Tempo]
(Tempo, Tempo) -> Tempo -> Bool
(Tempo, Tempo) -> Tempo -> Int
forall a.
Ord a
-> ((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
unsafeRangeSize :: (Tempo, Tempo) -> Int
$cunsafeRangeSize :: (Tempo, Tempo) -> Int
rangeSize :: (Tempo, Tempo) -> Int
$crangeSize :: (Tempo, Tempo) -> Int
inRange :: (Tempo, Tempo) -> Tempo -> Bool
$cinRange :: (Tempo, Tempo) -> Tempo -> Bool
unsafeIndex :: (Tempo, Tempo) -> Tempo -> Int
$cunsafeIndex :: (Tempo, Tempo) -> Tempo -> Int
index :: (Tempo, Tempo) -> Tempo -> Int
$cindex :: (Tempo, Tempo) -> Tempo -> Int
range :: (Tempo, Tempo) -> [Tempo]
$crange :: (Tempo, Tempo) -> [Tempo]
Ix, Ptr Tempo -> IO Tempo
Ptr Tempo -> Int -> IO Tempo
Ptr Tempo -> Int -> Tempo -> IO ()
Ptr Tempo -> Tempo -> IO ()
Tempo -> Int
forall b. Ptr b -> Int -> IO Tempo
forall b. Ptr b -> Int -> Tempo -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr Tempo -> Tempo -> IO ()
$cpoke :: Ptr Tempo -> Tempo -> IO ()
peek :: Ptr Tempo -> IO Tempo
$cpeek :: Ptr Tempo -> IO Tempo
pokeByteOff :: forall b. Ptr b -> Int -> Tempo -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> Tempo -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO Tempo
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Tempo
pokeElemOff :: Ptr Tempo -> Int -> Tempo -> IO ()
$cpokeElemOff :: Ptr Tempo -> Int -> Tempo -> IO ()
peekElemOff :: Ptr Tempo -> Int -> IO Tempo
$cpeekElemOff :: Ptr Tempo -> Int -> IO Tempo
alignment :: Tempo -> Int
$calignment :: Tempo -> Int
sizeOf :: Tempo -> Int
$csizeOf :: Tempo -> Int
Storable)

{-# LINE 496 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

data QueueEv  = QueueStart
              | QueueContinue
              | QueueStop
              | QueueSetPosTick !Time.Tick
              | QueueSetPosTime !RealTime.T
              | QueueTempo      !Tempo
              | QueueClock
              | QueueTick
              | QueueSkew       !Queue.Skew
              | QueueSyncPos    !Queue.Position
                deriving (Show, Eq)

data EmptyEv  = TuneRequest | Reset | Sensing | None | Unknown
                deriving (Int -> EmptyEv -> ShowS
[EmptyEv] -> ShowS
EmptyEv -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EmptyEv] -> ShowS
$cshowList :: [EmptyEv] -> ShowS
show :: EmptyEv -> String
$cshow :: EmptyEv -> String
showsPrec :: Int -> EmptyEv -> ShowS
$cshowsPrec :: Int -> EmptyEv -> ShowS
Show, EmptyEv -> EmptyEv -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EmptyEv -> EmptyEv -> Bool
$c/= :: EmptyEv -> EmptyEv -> Bool
== :: EmptyEv -> EmptyEv -> Bool
$c== :: EmptyEv -> EmptyEv -> Bool
Eq, Eq EmptyEv
EmptyEv -> EmptyEv -> Bool
EmptyEv -> EmptyEv -> Ordering
EmptyEv -> EmptyEv -> EmptyEv
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
min :: EmptyEv -> EmptyEv -> EmptyEv
$cmin :: EmptyEv -> EmptyEv -> EmptyEv
max :: EmptyEv -> EmptyEv -> EmptyEv
$cmax :: EmptyEv -> EmptyEv -> EmptyEv
>= :: EmptyEv -> EmptyEv -> Bool
$c>= :: EmptyEv -> EmptyEv -> Bool
> :: EmptyEv -> EmptyEv -> Bool
$c> :: EmptyEv -> EmptyEv -> Bool
<= :: EmptyEv -> EmptyEv -> Bool
$c<= :: EmptyEv -> EmptyEv -> Bool
< :: EmptyEv -> EmptyEv -> Bool
$c< :: EmptyEv -> EmptyEv -> Bool
compare :: EmptyEv -> EmptyEv -> Ordering
$ccompare :: EmptyEv -> EmptyEv -> Ordering
Ord, Int -> EmptyEv
EmptyEv -> Int
EmptyEv -> [EmptyEv]
EmptyEv -> EmptyEv
EmptyEv -> EmptyEv -> [EmptyEv]
EmptyEv -> EmptyEv -> EmptyEv -> [EmptyEv]
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 :: EmptyEv -> EmptyEv -> EmptyEv -> [EmptyEv]
$cenumFromThenTo :: EmptyEv -> EmptyEv -> EmptyEv -> [EmptyEv]
enumFromTo :: EmptyEv -> EmptyEv -> [EmptyEv]
$cenumFromTo :: EmptyEv -> EmptyEv -> [EmptyEv]
enumFromThen :: EmptyEv -> EmptyEv -> [EmptyEv]
$cenumFromThen :: EmptyEv -> EmptyEv -> [EmptyEv]
enumFrom :: EmptyEv -> [EmptyEv]
$cenumFrom :: EmptyEv -> [EmptyEv]
fromEnum :: EmptyEv -> Int
$cfromEnum :: EmptyEv -> Int
toEnum :: Int -> EmptyEv
$ctoEnum :: Int -> EmptyEv
pred :: EmptyEv -> EmptyEv
$cpred :: EmptyEv -> EmptyEv
succ :: EmptyEv -> EmptyEv
$csucc :: EmptyEv -> EmptyEv
Enum, EmptyEv
forall a. a -> a -> Bounded a
maxBound :: EmptyEv
$cmaxBound :: EmptyEv
minBound :: EmptyEv
$cminBound :: EmptyEv
Bounded)

data CustomEv = Echo | OSS
              | User0 | User1 | User2 | User3 | User4
              | User5 | User6 | User7 | User8 | User9
                deriving (Int -> CustomEv -> ShowS
[CustomEv] -> ShowS
CustomEv -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CustomEv] -> ShowS
$cshowList :: [CustomEv] -> ShowS
show :: CustomEv -> String
$cshow :: CustomEv -> String
showsPrec :: Int -> CustomEv -> ShowS
$cshowsPrec :: Int -> CustomEv -> ShowS
Show, CustomEv -> CustomEv -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CustomEv -> CustomEv -> Bool
$c/= :: CustomEv -> CustomEv -> Bool
== :: CustomEv -> CustomEv -> Bool
$c== :: CustomEv -> CustomEv -> Bool
Eq, Eq CustomEv
CustomEv -> CustomEv -> Bool
CustomEv -> CustomEv -> Ordering
CustomEv -> CustomEv -> CustomEv
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
min :: CustomEv -> CustomEv -> CustomEv
$cmin :: CustomEv -> CustomEv -> CustomEv
max :: CustomEv -> CustomEv -> CustomEv
$cmax :: CustomEv -> CustomEv -> CustomEv
>= :: CustomEv -> CustomEv -> Bool
$c>= :: CustomEv -> CustomEv -> Bool
> :: CustomEv -> CustomEv -> Bool
$c> :: CustomEv -> CustomEv -> Bool
<= :: CustomEv -> CustomEv -> Bool
$c<= :: CustomEv -> CustomEv -> Bool
< :: CustomEv -> CustomEv -> Bool
$c< :: CustomEv -> CustomEv -> Bool
compare :: CustomEv -> CustomEv -> Ordering
$ccompare :: CustomEv -> CustomEv -> Ordering
Ord, Int -> CustomEv
CustomEv -> Int
CustomEv -> [CustomEv]
CustomEv -> CustomEv
CustomEv -> CustomEv -> [CustomEv]
CustomEv -> CustomEv -> CustomEv -> [CustomEv]
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 :: CustomEv -> CustomEv -> CustomEv -> [CustomEv]
$cenumFromThenTo :: CustomEv -> CustomEv -> CustomEv -> [CustomEv]
enumFromTo :: CustomEv -> CustomEv -> [CustomEv]
$cenumFromTo :: CustomEv -> CustomEv -> [CustomEv]
enumFromThen :: CustomEv -> CustomEv -> [CustomEv]
$cenumFromThen :: CustomEv -> CustomEv -> [CustomEv]
enumFrom :: CustomEv -> [CustomEv]
$cenumFrom :: CustomEv -> [CustomEv]
fromEnum :: CustomEv -> Int
$cfromEnum :: CustomEv -> Int
toEnum :: Int -> CustomEv
$ctoEnum :: Int -> CustomEv
pred :: CustomEv -> CustomEv
$cpred :: CustomEv -> CustomEv
succ :: CustomEv -> CustomEv
$csucc :: CustomEv -> CustomEv
Enum, CustomEv
forall a. a -> a -> Bounded a
maxBound :: CustomEv
$cmaxBound :: CustomEv
minBound :: CustomEv
$cminBound :: CustomEv
Bounded)

data ExtEv    = SysEx | Bounce
              | UserVar0 | UserVar1 | UserVar2 | UserVar3 | UserVar4
                deriving (Int -> ExtEv -> ShowS
[ExtEv] -> ShowS
ExtEv -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExtEv] -> ShowS
$cshowList :: [ExtEv] -> ShowS
show :: ExtEv -> String
$cshow :: ExtEv -> String
showsPrec :: Int -> ExtEv -> ShowS
$cshowsPrec :: Int -> ExtEv -> ShowS
Show, ExtEv -> ExtEv -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExtEv -> ExtEv -> Bool
$c/= :: ExtEv -> ExtEv -> Bool
== :: ExtEv -> ExtEv -> Bool
$c== :: ExtEv -> ExtEv -> Bool
Eq, Eq ExtEv
ExtEv -> ExtEv -> Bool
ExtEv -> ExtEv -> Ordering
ExtEv -> ExtEv -> ExtEv
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
min :: ExtEv -> ExtEv -> ExtEv
$cmin :: ExtEv -> ExtEv -> ExtEv
max :: ExtEv -> ExtEv -> ExtEv
$cmax :: ExtEv -> ExtEv -> ExtEv
>= :: ExtEv -> ExtEv -> Bool
$c>= :: ExtEv -> ExtEv -> Bool
> :: ExtEv -> ExtEv -> Bool
$c> :: ExtEv -> ExtEv -> Bool
<= :: ExtEv -> ExtEv -> Bool
$c<= :: ExtEv -> ExtEv -> Bool
< :: ExtEv -> ExtEv -> Bool
$c< :: ExtEv -> ExtEv -> Bool
compare :: ExtEv -> ExtEv -> Ordering
$ccompare :: ExtEv -> ExtEv -> Ordering
Ord, Int -> ExtEv
ExtEv -> Int
ExtEv -> [ExtEv]
ExtEv -> ExtEv
ExtEv -> ExtEv -> [ExtEv]
ExtEv -> ExtEv -> ExtEv -> [ExtEv]
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 :: ExtEv -> ExtEv -> ExtEv -> [ExtEv]
$cenumFromThenTo :: ExtEv -> ExtEv -> ExtEv -> [ExtEv]
enumFromTo :: ExtEv -> ExtEv -> [ExtEv]
$cenumFromTo :: ExtEv -> ExtEv -> [ExtEv]
enumFromThen :: ExtEv -> ExtEv -> [ExtEv]
$cenumFromThen :: ExtEv -> ExtEv -> [ExtEv]
enumFrom :: ExtEv -> [ExtEv]
$cenumFrom :: ExtEv -> [ExtEv]
fromEnum :: ExtEv -> Int
$cfromEnum :: ExtEv -> Int
toEnum :: Int -> ExtEv
$ctoEnum :: Int -> ExtEv
pred :: ExtEv -> ExtEv
$cpred :: ExtEv -> ExtEv
succ :: ExtEv -> ExtEv
$csucc :: ExtEv -> ExtEv
Enum, ExtEv
forall a. a -> a -> Bounded a
maxBound :: ExtEv
$cmaxBound :: ExtEv
minBound :: ExtEv
$cminBound :: ExtEv
Bounded)

data AddrEv   = ClientStart | ClientExit | ClientChange
              | PortStart | PortExit | PortChange
                deriving (Int -> AddrEv -> ShowS
[AddrEv] -> ShowS
AddrEv -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AddrEv] -> ShowS
$cshowList :: [AddrEv] -> ShowS
show :: AddrEv -> String
$cshow :: AddrEv -> String
showsPrec :: Int -> AddrEv -> ShowS
$cshowsPrec :: Int -> AddrEv -> ShowS
Show, AddrEv -> AddrEv -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AddrEv -> AddrEv -> Bool
$c/= :: AddrEv -> AddrEv -> Bool
== :: AddrEv -> AddrEv -> Bool
$c== :: AddrEv -> AddrEv -> Bool
Eq, Eq AddrEv
AddrEv -> AddrEv -> Bool
AddrEv -> AddrEv -> Ordering
AddrEv -> AddrEv -> AddrEv
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
min :: AddrEv -> AddrEv -> AddrEv
$cmin :: AddrEv -> AddrEv -> AddrEv
max :: AddrEv -> AddrEv -> AddrEv
$cmax :: AddrEv -> AddrEv -> AddrEv
>= :: AddrEv -> AddrEv -> Bool
$c>= :: AddrEv -> AddrEv -> Bool
> :: AddrEv -> AddrEv -> Bool
$c> :: AddrEv -> AddrEv -> Bool
<= :: AddrEv -> AddrEv -> Bool
$c<= :: AddrEv -> AddrEv -> Bool
< :: AddrEv -> AddrEv -> Bool
$c< :: AddrEv -> AddrEv -> Bool
compare :: AddrEv -> AddrEv -> Ordering
$ccompare :: AddrEv -> AddrEv -> Ordering
Ord, Int -> AddrEv
AddrEv -> Int
AddrEv -> [AddrEv]
AddrEv -> AddrEv
AddrEv -> AddrEv -> [AddrEv]
AddrEv -> AddrEv -> AddrEv -> [AddrEv]
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 :: AddrEv -> AddrEv -> AddrEv -> [AddrEv]
$cenumFromThenTo :: AddrEv -> AddrEv -> AddrEv -> [AddrEv]
enumFromTo :: AddrEv -> AddrEv -> [AddrEv]
$cenumFromTo :: AddrEv -> AddrEv -> [AddrEv]
enumFromThen :: AddrEv -> AddrEv -> [AddrEv]
$cenumFromThen :: AddrEv -> AddrEv -> [AddrEv]
enumFrom :: AddrEv -> [AddrEv]
$cenumFrom :: AddrEv -> [AddrEv]
fromEnum :: AddrEv -> Int
$cfromEnum :: AddrEv -> Int
toEnum :: Int -> AddrEv
$ctoEnum :: Int -> AddrEv
pred :: AddrEv -> AddrEv
$cpred :: AddrEv -> AddrEv
succ :: AddrEv -> AddrEv
$csucc :: AddrEv -> AddrEv
Enum, AddrEv
forall a. a -> a -> Bounded a
maxBound :: AddrEv
$cmaxBound :: AddrEv
minBound :: AddrEv
$cminBound :: AddrEv
Bounded)

data ConnEv   = PortSubscribed | PortUnsubscribed
                deriving (Int -> ConnEv -> ShowS
[ConnEv] -> ShowS
ConnEv -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConnEv] -> ShowS
$cshowList :: [ConnEv] -> ShowS
show :: ConnEv -> String
$cshow :: ConnEv -> String
showsPrec :: Int -> ConnEv -> ShowS
$cshowsPrec :: Int -> ConnEv -> ShowS
Show, ConnEv -> ConnEv -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConnEv -> ConnEv -> Bool
$c/= :: ConnEv -> ConnEv -> Bool
== :: ConnEv -> ConnEv -> Bool
$c== :: ConnEv -> ConnEv -> Bool
Eq, Eq ConnEv
ConnEv -> ConnEv -> Bool
ConnEv -> ConnEv -> Ordering
ConnEv -> ConnEv -> ConnEv
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
min :: ConnEv -> ConnEv -> ConnEv
$cmin :: ConnEv -> ConnEv -> ConnEv
max :: ConnEv -> ConnEv -> ConnEv
$cmax :: ConnEv -> ConnEv -> ConnEv
>= :: ConnEv -> ConnEv -> Bool
$c>= :: ConnEv -> ConnEv -> Bool
> :: ConnEv -> ConnEv -> Bool
$c> :: ConnEv -> ConnEv -> Bool
<= :: ConnEv -> ConnEv -> Bool
$c<= :: ConnEv -> ConnEv -> Bool
< :: ConnEv -> ConnEv -> Bool
$c< :: ConnEv -> ConnEv -> Bool
compare :: ConnEv -> ConnEv -> Ordering
$ccompare :: ConnEv -> ConnEv -> Ordering
Ord, Int -> ConnEv
ConnEv -> Int
ConnEv -> [ConnEv]
ConnEv -> ConnEv
ConnEv -> ConnEv -> [ConnEv]
ConnEv -> ConnEv -> ConnEv -> [ConnEv]
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 :: ConnEv -> ConnEv -> ConnEv -> [ConnEv]
$cenumFromThenTo :: ConnEv -> ConnEv -> ConnEv -> [ConnEv]
enumFromTo :: ConnEv -> ConnEv -> [ConnEv]
$cenumFromTo :: ConnEv -> ConnEv -> [ConnEv]
enumFromThen :: ConnEv -> ConnEv -> [ConnEv]
$cenumFromThen :: ConnEv -> ConnEv -> [ConnEv]
enumFrom :: ConnEv -> [ConnEv]
$cenumFrom :: ConnEv -> [ConnEv]
fromEnum :: ConnEv -> Int
$cfromEnum :: ConnEv -> Int
toEnum :: Int -> ConnEv
$ctoEnum :: Int -> ConnEv
pred :: ConnEv -> ConnEv
$cpred :: ConnEv -> ConnEv
succ :: ConnEv -> ConnEv
$csucc :: ConnEv -> ConnEv
Enum, ConnEv
forall a. a -> a -> Bounded a
maxBound :: ConnEv
$cmaxBound :: ConnEv
minBound :: ConnEv
$cminBound :: ConnEv
Bounded)


newtype EType = EType { EType -> Word8
unEType :: Word.Word8 }
 deriving (Int -> EType -> ShowS
[EType] -> ShowS
EType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EType] -> ShowS
$cshowList :: [EType] -> ShowS
show :: EType -> String
$cshow :: EType -> String
showsPrec :: Int -> EType -> ShowS
$cshowsPrec :: Int -> EType -> ShowS
Show, EType -> EType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EType -> EType -> Bool
$c/= :: EType -> EType -> Bool
== :: EType -> EType -> Bool
$c== :: EType -> EType -> Bool
Eq, Eq EType
EType -> EType -> Bool
EType -> EType -> Ordering
EType -> EType -> EType
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
min :: EType -> EType -> EType
$cmin :: EType -> EType -> EType
max :: EType -> EType -> EType
$cmax :: EType -> EType -> EType
>= :: EType -> EType -> Bool
$c>= :: EType -> EType -> Bool
> :: EType -> EType -> Bool
$c> :: EType -> EType -> Bool
<= :: EType -> EType -> Bool
$c<= :: EType -> EType -> Bool
< :: EType -> EType -> Bool
$c< :: EType -> EType -> Bool
compare :: EType -> EType -> Ordering
$ccompare :: EType -> EType -> Ordering
Ord, Ord EType
(EType, EType) -> Int
(EType, EType) -> [EType]
(EType, EType) -> EType -> Bool
(EType, EType) -> EType -> Int
forall a.
Ord a
-> ((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
unsafeRangeSize :: (EType, EType) -> Int
$cunsafeRangeSize :: (EType, EType) -> Int
rangeSize :: (EType, EType) -> Int
$crangeSize :: (EType, EType) -> Int
inRange :: (EType, EType) -> EType -> Bool
$cinRange :: (EType, EType) -> EType -> Bool
unsafeIndex :: (EType, EType) -> EType -> Int
$cunsafeIndex :: (EType, EType) -> EType -> Int
index :: (EType, EType) -> EType -> Int
$cindex :: (EType, EType) -> EType -> Int
range :: (EType, EType) -> [EType]
$crange :: (EType, EType) -> [EType]
Ix, Ptr EType -> IO EType
Ptr EType -> Int -> IO EType
Ptr EType -> Int -> EType -> IO ()
Ptr EType -> EType -> IO ()
EType -> Int
forall b. Ptr b -> Int -> IO EType
forall b. Ptr b -> Int -> EType -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr EType -> EType -> IO ()
$cpoke :: Ptr EType -> EType -> IO ()
peek :: Ptr EType -> IO EType
$cpeek :: Ptr EType -> IO EType
pokeByteOff :: forall b. Ptr b -> Int -> EType -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> EType -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO EType
$cpeekByteOff :: forall b. Ptr b -> Int -> IO EType
pokeElemOff :: Ptr EType -> Int -> EType -> IO ()
$cpokeElemOff :: Ptr EType -> Int -> EType -> IO ()
peekElemOff :: Ptr EType -> Int -> IO EType
$cpeekElemOff :: Ptr EType -> Int -> IO EType
alignment :: EType -> Int
$calignment :: EType -> Int
sizeOf :: EType -> Int
$csizeOf :: EType -> Int
Storable)

{-# LINE 530 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

-- type EType = #{inttype snd_seq_event_type_t}


class Type e where
  expEv :: e -> EType

instance Type NoteEv where
 expEv :: NoteEv -> EType
expEv NoteEv
e = Word8 -> EType
EType forall a b. (a -> b) -> a -> b
$ case NoteEv
e of
  NoteEv
ANote    -> Word8
5
{-# LINE 540 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  NoteOn   -> 6
{-# LINE 541 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  NoteOff  -> 7
{-# LINE 542 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  KeyPress -> 8
{-# LINE 543 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

instance Type CtrlEv where
 expEv :: CtrlEv -> EType
expEv CtrlEv
e = Word8 -> EType
EType forall a b. (a -> b) -> a -> b
$ case CtrlEv
e of
  CtrlEv
Controller  -> Word8
10
{-# LINE 547 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  PgmChange   -> 11
{-# LINE 548 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  ChanPress   -> 12
{-# LINE 549 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  PitchBend   -> 13
{-# LINE 550 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  Control14   -> 14
{-# LINE 551 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  NonRegParam -> 15
{-# LINE 552 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  RegParam    -> 16
{-# LINE 553 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  SongPos     -> 20
{-# LINE 554 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  SongSel     -> 21
{-# LINE 555 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  QFrame      -> 22
{-# LINE 556 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  TimeSign    -> 23
{-# LINE 557 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  KeySign     -> 24
{-# LINE 558 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

instance Type QueueEv where
  expEv :: QueueEv -> EType
expEv = forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. QueueEv -> (EType, CInt)
expQueueEv

-- setPosTick should be an error
expQueueEv :: QueueEv -> (EType, C.CInt)
expQueueEv :: QueueEv -> (EType, CInt)
expQueueEv QueueEv
e = forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst Word8 -> EType
EType forall a b. (a -> b) -> a -> b
$ case QueueEv
e of
  QueueEv
QueueStart        -> (Word8
30       , CInt
0)
{-# LINE 566 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  QueueContinue     -> (31    , 0)
{-# LINE 567 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  QueueStop         -> (32        , 0)
{-# LINE 568 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  QueueSetPosTick _ -> (33 , error "expQueueEv.QueueSetPosTick: cannot represent position as int")
{-# LINE 569 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  QueueSetPosTime _ -> (34 , error "expQueueEv.QueueSetPosTime: cannot represent position as int")
{-# LINE 570 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  QueueTempo      x -> (35       , fromIntegral $ unTempo x)
{-# LINE 571 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  QueueClock        -> (36       , 0)
{-# LINE 572 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  QueueTick         -> (37        , 0)
{-# LINE 573 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  QueueSkew       _ -> (38  , error "expQueueEv.QueueSkew: cannot represent skew record as int")
{-# LINE 574 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  QueueSyncPos    x -> (39    , fromIntegral $ Queue.unPosition x)
{-# LINE 575 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}


instance Type EmptyEv where
 expEv :: EmptyEv -> EType
expEv EmptyEv
e = Word8 -> EType
EType forall a b. (a -> b) -> a -> b
$ case EmptyEv
e of
  EmptyEv
TuneRequest -> Word8
40
{-# LINE 580 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  Reset       -> 41
{-# LINE 581 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  Sensing     -> 42
{-# LINE 582 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  None        -> 255
{-# LINE 583 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  Unknown     -> 255
{-# LINE 584 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

instance Type CustomEv where
 expEv :: CustomEv -> EType
expEv CustomEv
e = Word8 -> EType
EType forall a b. (a -> b) -> a -> b
$ case CustomEv
e of
  CustomEv
Echo  -> Word8
50
{-# LINE 588 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  OSS   -> 51
{-# LINE 589 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  User0 -> 90
{-# LINE 590 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  User1 -> 91
{-# LINE 591 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  User2 -> 92
{-# LINE 592 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  User3 -> 93
{-# LINE 593 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  User4 -> 94
{-# LINE 594 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  User5 -> 95
{-# LINE 595 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  User6 -> 96
{-# LINE 596 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  User7 -> 97
{-# LINE 597 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  User8 -> 98
{-# LINE 598 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  User9 -> 99
{-# LINE 599 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

instance Type ExtEv where
 expEv :: ExtEv -> EType
expEv ExtEv
e = Word8 -> EType
EType forall a b. (a -> b) -> a -> b
$ case ExtEv
e of
  ExtEv
SysEx    -> Word8
130
{-# LINE 603 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  Bounce   -> 131
{-# LINE 604 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  UserVar0 -> 135
{-# LINE 605 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  UserVar1 -> 136
{-# LINE 606 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  UserVar2 -> 137
{-# LINE 607 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  UserVar3 -> 138
{-# LINE 608 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  UserVar4 -> 139
{-# LINE 609 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

instance Type AddrEv where
  expEv :: AddrEv -> EType
expEv AddrEv
e = Word8 -> EType
EType forall a b. (a -> b) -> a -> b
$ case AddrEv
e of
    AddrEv
ClientStart -> Word8
60
{-# LINE 613 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
    ClientExit -> 61
{-# LINE 614 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
    ClientChange -> 62
{-# LINE 615 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
    PortStart -> 63
{-# LINE 616 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
    PortExit -> 64
{-# LINE 617 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
    PortChange -> 65
{-# LINE 618 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}

instance Type ConnEv where
 expEv :: ConnEv -> EType
expEv ConnEv
e = Word8 -> EType
EType forall a b. (a -> b) -> a -> b
$ case ConnEv
e of
  ConnEv
PortSubscribed   -> Word8
66
{-# LINE 622 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  PortUnsubscribed -> 67
{-# LINE 623 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}


maxEventType :: EmptyEv
maxEventType :: EmptyEv
maxEventType = forall a. Bounded a => a
maxBound


peekBody ::
  (Storable d) =>
  (d -> Data) -> Ptr Data -> IO Data
peekBody :: forall d. Storable d => (d -> Data) -> Ptr Data -> IO Data
peekBody d -> Data
makeBody Ptr Data
p =
  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap d -> Data
makeBody (forall a. Storable a => Ptr a -> IO a
peek (forall a b. Ptr a -> Ptr b
castPtr Ptr Data
p))

peekNoteEv :: NoteEv -> Ptr Data -> IO Data
peekNoteEv :: NoteEv -> Ptr Data -> IO Data
peekNoteEv NoteEv
e = forall d. Storable d => (d -> Data) -> Ptr Data -> IO Data
peekBody (NoteEv -> Note -> Data
NoteEv NoteEv
e)

peekCtrlEv :: CtrlEv -> Ptr Data -> IO Data
peekCtrlEv :: CtrlEv -> Ptr Data -> IO Data
peekCtrlEv CtrlEv
e = forall d. Storable d => (d -> Data) -> Ptr Data -> IO Data
peekBody (CtrlEv -> Ctrl -> Data
CtrlEv CtrlEv
e)

peekQueueEv :: QueueEv -> Ptr Data -> IO Data
peekQueueEv :: QueueEv -> Ptr Data -> IO Data
peekQueueEv QueueEv
e = forall d. Storable d => (d -> Data) -> Ptr Data -> IO Data
peekBody (QueueEv -> T -> Data
QueueEv QueueEv
e)

peekQueueExt :: (a -> QueueEv) -> (Ptr Data -> IO a) -> Ptr Data -> IO Data
peekQueueExt :: forall a.
(a -> QueueEv) -> (Ptr Data -> IO a) -> Ptr Data -> IO Data
peekQueueExt a -> QueueEv
makeQ Ptr Data -> IO a
peekParam Ptr Data
p =
  forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (QueueEv -> T -> Data
QueueEv forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> QueueEv
makeQ) (Ptr Data -> IO a
peekParam Ptr Data
p) (forall a. Storable a => Ptr a -> IO a
peek (forall a b. Ptr a -> Ptr b
castPtr Ptr Data
p))

peekAddrEv :: AddrEv -> Ptr Data -> IO Data
peekAddrEv :: AddrEv -> Ptr Data -> IO Data
peekAddrEv AddrEv
e = forall d. Storable d => (d -> Data) -> Ptr Data -> IO Data
peekBody (AddrEv -> T -> Data
AddrEv AddrEv
e)

peekConnEv :: ConnEv -> Ptr Data -> IO Data
peekConnEv :: ConnEv -> Ptr Data -> IO Data
peekConnEv ConnEv
e = forall d. Storable d => (d -> Data) -> Ptr Data -> IO Data
peekBody (ConnEv -> T -> Data
ConnEv ConnEv
e)

peekEmptyEv :: EmptyEv -> Ptr Data -> IO Data
peekEmptyEv :: EmptyEv -> Ptr Data -> IO Data
peekEmptyEv EmptyEv
e Ptr Data
_ = forall (m :: * -> *) a. Monad m => a -> m a
return (EmptyEv -> Data
EmptyEv EmptyEv
e)

peekCustomEv :: CustomEv -> Ptr Data -> IO Data
peekCustomEv :: CustomEv -> Ptr Data -> IO Data
peekCustomEv CustomEv
e = forall d. Storable d => (d -> Data) -> Ptr Data -> IO Data
peekBody (CustomEv -> Custom -> Data
CustomEv CustomEv
e)

peekExtEv :: ExtEv -> Ptr Data -> IO Data
peekExtEv :: ExtEv -> Ptr Data -> IO Data
peekExtEv ExtEv
e Ptr Data
p = do
  Word32
len <- (\Ptr Data
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff Ptr Data
hsc_ptr Int
0 :: IO Word.Word32) Ptr Data
p
{-# LINE 663 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  ptr <- (\hsc_ptr -> peekByteOff hsc_ptr 4) p
{-# LINE 664 "src/Sound/ALSA/Sequencer/Marshal/Event.hsc" #-}
  fmap (ExtEv e) $ B.packCStringLen (ptr, fromIntegral len)


data Data
  = NoteEv NoteEv Note
  | CtrlEv CtrlEv Ctrl
  | QueueEv QueueEv Queue.T
  | AddrEv AddrEv Addr.T
  | ConnEv ConnEv Connect.T
  | EmptyEv EmptyEv
  | CustomEv CustomEv Custom
  | ExtEv ExtEv B.ByteString
    deriving Int -> Data -> ShowS
[Data] -> ShowS
Data -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Data] -> ShowS
$cshowList :: [Data] -> ShowS
show :: Data -> String
$cshow :: Data -> String
showsPrec :: Int -> Data -> ShowS
$cshowsPrec :: Int -> Data -> ShowS
Show