module Sound.MED.Raw.SynthInstr where

import qualified Sound.MED.Raw.SynthWF as SynthWF
import Sound.MED.Raw.SynthWF(SynthWF)

import Sound.MED.Basic.Amiga
import Sound.MED.Basic.Utility

data SynthInstr = SynthInstr
  { SynthInstr -> UBYTE
defaultdecay :: UBYTE
  , SynthInstr -> [UBYTE]
reserved     :: [ UBYTE ]
  , SynthInstr -> UWORD
rep          :: UWORD
  , SynthInstr -> UWORD
replen       :: UWORD
  , SynthInstr -> UWORD
voltbllen    :: UWORD
  , SynthInstr -> UWORD
wftbllen     :: UWORD
  , SynthInstr -> UBYTE
volspeed     :: UBYTE
  , SynthInstr -> UBYTE
wfspeed      :: UBYTE
  , SynthInstr -> UWORD
wforms       :: UWORD
  , SynthInstr -> [UBYTE]
voltbl       :: [ UBYTE ]
  , SynthInstr -> [UBYTE]
wftbl        :: [ UBYTE ]
  , SynthInstr -> [Maybe SynthWF]
wf           :: [ Maybe SynthWF ]
  }
  deriving (Int -> SynthInstr -> ShowS
[SynthInstr] -> ShowS
SynthInstr -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SynthInstr] -> ShowS
$cshowList :: [SynthInstr] -> ShowS
show :: SynthInstr -> String
$cshow :: SynthInstr -> String
showsPrec :: Int -> SynthInstr -> ShowS
$cshowsPrec :: Int -> SynthInstr -> ShowS
Show)

{-# SPECIALISE peek :: PTR -> StorableReader SynthInstr #-}
{-# SPECIALISE peek :: PTR -> ByteStringReader SynthInstr #-}
peek :: (Reader m) => PTR -> m SynthInstr
peek :: forall (m :: * -> *). Reader m => PTR -> m SynthInstr
peek PTR
p = do
  UBYTE
defaultdecay' <- forall (m :: * -> *). Reader m => Peek m UBYTE
peekUBYTE (PTR
pforall a. Num a => a -> a -> a
+PTR
6)
  [UBYTE]
reserved'     <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall (m :: * -> *). Reader m => Peek m UBYTE
peekUBYTE forall a b. (a -> b) -> a -> b
$ PTR -> PTR -> Int -> [PTR]
pointerRange (PTR
pforall a. Num a => a -> a -> a
+PTR
7) PTR
1 Int
3
  UWORD
rep'          <- forall (m :: * -> *). Reader m => Peek m UWORD
peekUWORD (PTR
pforall a. Num a => a -> a -> a
+PTR
10)
  UWORD
replen'       <- forall (m :: * -> *). Reader m => Peek m UWORD
peekUWORD (PTR
pforall a. Num a => a -> a -> a
+PTR
12)
  UWORD
voltbllen'    <- forall (m :: * -> *). Reader m => Peek m UWORD
peekUWORD (PTR
pforall a. Num a => a -> a -> a
+PTR
14)
  UWORD
wftbllen'     <- forall (m :: * -> *). Reader m => Peek m UWORD
peekUWORD (PTR
pforall a. Num a => a -> a -> a
+PTR
16)
  UBYTE
volspeed'     <- forall (m :: * -> *). Reader m => Peek m UBYTE
peekUBYTE (PTR
pforall a. Num a => a -> a -> a
+PTR
18)
  UBYTE
wfspeed'      <- forall (m :: * -> *). Reader m => Peek m UBYTE
peekUBYTE (PTR
pforall a. Num a => a -> a -> a
+PTR
19)
  UWORD
wforms'       <- forall (m :: * -> *). Reader m => Peek m UWORD
peekUWORD (PTR
pforall a. Num a => a -> a -> a
+PTR
20)
  [UBYTE]
voltbl'       <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall (m :: * -> *). Reader m => Peek m UBYTE
peekUBYTE forall a b. (a -> b) -> a -> b
$ PTR -> PTR -> Int -> [PTR]
pointerRange (PTR
pforall a. Num a => a -> a -> a
+PTR
22) PTR
1 Int
128
  [UBYTE]
wftbl'        <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall (m :: * -> *). Reader m => Peek m UBYTE
peekUBYTE forall a b. (a -> b) -> a -> b
$ PTR -> PTR -> Int -> [PTR]
pointerRange (PTR
pforall a. Num a => a -> a -> a
+PTR
150) PTR
150 Int
128
  [PTR]
wf''          <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall (m :: * -> *). Reader m => Peek m PTR
peekPTR   forall a b. (a -> b) -> a -> b
$ PTR -> PTR -> Int -> [PTR]
pointerRange (PTR
pforall a. Num a => a -> a -> a
+PTR
278) PTR
4 Int
64
  [Maybe SynthWF]
wf'           <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall (m :: * -> *). Reader m => PTR -> m SynthWF
SynthWF.peek forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PTR
pforall a. Num a => a -> a -> a
+) forall (m :: * -> *) a.
Monad m =>
(PTR -> m a) -> PTR -> m (Maybe a)
$?) [PTR]
wf''
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ UBYTE
-> [UBYTE]
-> UWORD
-> UWORD
-> UWORD
-> UWORD
-> UBYTE
-> UBYTE
-> UWORD
-> [UBYTE]
-> [UBYTE]
-> [Maybe SynthWF]
-> SynthInstr
SynthInstr
    UBYTE
defaultdecay' [UBYTE]
reserved' UWORD
rep' UWORD
replen' UWORD
voltbllen' UWORD
wftbllen'
    UBYTE
volspeed' UBYTE
wfspeed' UWORD
wforms' [UBYTE]
voltbl' [UBYTE]
wftbl' [Maybe SynthWF]
wf'

{-
showVOL :: [UBYTE] -> String
showVOL vs = "[ " ++ (unwords . map showVOL') vs ++ " ]"
showVOL' :: UBYTE -> String
showVOL' 0xF0 = "SPD"
showVOL' 0xF1 = "WAI"
showVOL' 0xF2 = "CHD"
showVOL' 0xF3 = "CDU"
showVOL' 0xF4 = "EN1"
showVOL' 0xF5 = "EN2"
showVOL' 0xF6 = "EST"
showVOL' 0xFA = "JWS"
showVOL' 0xFB = "HLT"
showVOL' 0xFE = "JMP"
showVOL' 0xFF = "END"
showVOL' v    = show v

showWF :: [UBYTE] -> String
showWF vs = "[ " ++ (unwords . map showWF') vs ++ " ]"
showWF' :: UBYTE -> String
showWF' 0xF0 = "SPD"
showWF' 0xF1 = "WAI"
showWF' 0xF2 = "CHD"
showWF' 0xF3 = "CDU"
showWF' 0xF4 = "VBD"
showWF' 0xF5 = "VBS"
showWF' 0xF6 = "RES"
showWF' 0xF7 = "VWF"
showWF' 0xFA = "JVS"
showWF' 0xFB = "HLT"
showWF' 0xFC = "ARP"
showWF' 0xFD = "ARE"
showWF' 0xFE = "JMP"
showWF' 0xFF = "END"
showWF' v    = show v
-}