module Sound.MED.Raw.MMD1NoteData where

import Sound.MED.Basic.Amiga

import Data.Bits ((.&.))

data MMD1NoteData = MMD1NoteData
  { MMD1NoteData -> UBYTE
note       :: UBYTE
  , MMD1NoteData -> UBYTE
instrument :: UBYTE
  , MMD1NoteData -> UBYTE
command    :: UBYTE
  , MMD1NoteData -> UBYTE
databyte   :: UBYTE
  }
  deriving (Int -> MMD1NoteData -> ShowS
[MMD1NoteData] -> ShowS
MMD1NoteData -> String
(Int -> MMD1NoteData -> ShowS)
-> (MMD1NoteData -> String)
-> ([MMD1NoteData] -> ShowS)
-> Show MMD1NoteData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MMD1NoteData] -> ShowS
$cshowList :: [MMD1NoteData] -> ShowS
show :: MMD1NoteData -> String
$cshow :: MMD1NoteData -> String
showsPrec :: Int -> MMD1NoteData -> ShowS
$cshowsPrec :: Int -> MMD1NoteData -> ShowS
Show)

{-# SPECIALISE peek :: PTR -> StorableReader MMD1NoteData #-}
{-# SPECIALISE peek :: PTR -> ByteStringReader MMD1NoteData #-}
peek :: (Reader m) => PTR -> m MMD1NoteData
peek :: PTR -> m MMD1NoteData
peek PTR
p = do
  UBYTE
byte1 <- Peek m UBYTE
forall (m :: * -> *). Reader m => Peek m UBYTE
peekUBYTE (PTR
p PTR -> PTR -> PTR
forall a. Num a => a -> a -> a
+ PTR
0)
  UBYTE
byte2 <- Peek m UBYTE
forall (m :: * -> *). Reader m => Peek m UBYTE
peekUBYTE (PTR
p PTR -> PTR -> PTR
forall a. Num a => a -> a -> a
+ PTR
1)
  UBYTE
byte3 <- Peek m UBYTE
forall (m :: * -> *). Reader m => Peek m UBYTE
peekUBYTE (PTR
p PTR -> PTR -> PTR
forall a. Num a => a -> a -> a
+ PTR
2)
  UBYTE
byte4 <- Peek m UBYTE
forall (m :: * -> *). Reader m => Peek m UBYTE
peekUBYTE (PTR
p PTR -> PTR -> PTR
forall a. Num a => a -> a -> a
+ PTR
3)
  let nnnnnnn :: UBYTE
nnnnnnn     = UBYTE
byte1 UBYTE -> UBYTE -> UBYTE
forall a. Bits a => a -> a -> a
.&. UBYTE
0x7F
  let iiiiii :: UBYTE
iiiiii      = UBYTE
byte2 UBYTE -> UBYTE -> UBYTE
forall a. Bits a => a -> a -> a
.&. UBYTE
0x3F
  let cccccccc :: UBYTE
cccccccc    = UBYTE
byte3 UBYTE -> UBYTE -> UBYTE
forall a. Bits a => a -> a -> a
.&. UBYTE
0xFF
  let dddddddd :: UBYTE
dddddddd    = UBYTE
byte4 UBYTE -> UBYTE -> UBYTE
forall a. Bits a => a -> a -> a
.&. UBYTE
0xFF
  let note' :: UBYTE
note'       = UBYTE
nnnnnnn
  let instrument' :: UBYTE
instrument' = UBYTE
iiiiii
  let command' :: UBYTE
command'    = UBYTE
cccccccc
  let databyte' :: UBYTE
databyte'   = UBYTE
dddddddd
  MMD1NoteData -> m MMD1NoteData
forall (m :: * -> *) a. Monad m => a -> m a
return (MMD1NoteData -> m MMD1NoteData) -> MMD1NoteData -> m MMD1NoteData
forall a b. (a -> b) -> a -> b
$ UBYTE -> UBYTE -> UBYTE -> UBYTE -> MMD1NoteData
MMD1NoteData
    UBYTE
note' UBYTE
instrument' UBYTE
command' UBYTE
databyte'