module Sound.MED.Raw.MMD0Block where

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

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

data MMD0Block = MMD0Block
  { MMD0Block -> UBYTE
numtracks :: UBYTE
  , MMD0Block -> UBYTE
lines     :: UBYTE -- NOTE: actual number of lines is one greater
  , MMD0Block -> [[MMD0NoteData]]
notedata  :: [ [ MMD0NoteData ] ]
  }
  deriving (Int -> MMD0Block -> ShowS
[MMD0Block] -> ShowS
MMD0Block -> String
(Int -> MMD0Block -> ShowS)
-> (MMD0Block -> String)
-> ([MMD0Block] -> ShowS)
-> Show MMD0Block
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MMD0Block] -> ShowS
$cshowList :: [MMD0Block] -> ShowS
show :: MMD0Block -> String
$cshow :: MMD0Block -> String
showsPrec :: Int -> MMD0Block -> ShowS
$cshowsPrec :: Int -> MMD0Block -> ShowS
Show)

{-# SPECIALISE peek :: PTR -> StorableReader MMD0Block #-}
{-# SPECIALISE peek :: PTR -> ByteStringReader MMD0Block #-}
peek :: (Reader m) => PTR -> m MMD0Block
peek :: PTR -> m MMD0Block
peek PTR
p = do
  UBYTE
numtracks'    <- 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
lines'        <- 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)
  [MMD0NoteData]
notedata''    <- (PTR -> m MMD0NoteData) -> [PTR] -> m [MMD0NoteData]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM PTR -> m MMD0NoteData
forall (m :: * -> *). Reader m => PTR -> m MMD0NoteData
MMD0NoteData.peek ([PTR] -> m [MMD0NoteData]) -> [PTR] -> m [MMD0NoteData]
forall a b. (a -> b) -> a -> b
$ PTR -> PTR -> UBYTE -> UBYTE -> [PTR]
forall i j.
(Integral i, Integral j) =>
PTR -> PTR -> i -> j -> [PTR]
pointerRangeGen2 (PTR
pPTR -> PTR -> PTR
forall a. Num a => a -> a -> a
+PTR
2) PTR
3 UBYTE
numtracks' (UBYTE
lines'UBYTE -> UBYTE -> UBYTE
forall a. Num a => a -> a -> a
+UBYTE
1)
  let notedata' :: [[MMD0NoteData]]
notedata' =  UBYTE -> [MMD0NoteData] -> [[MMD0NoteData]]
forall i a. Integral i => i -> [a] -> [[a]]
chunk UBYTE
numtracks' [MMD0NoteData]
notedata''
  MMD0Block -> m MMD0Block
forall (m :: * -> *) a. Monad m => a -> m a
return (MMD0Block -> m MMD0Block) -> MMD0Block -> m MMD0Block
forall a b. (a -> b) -> a -> b
$ UBYTE -> UBYTE -> [[MMD0NoteData]] -> MMD0Block
MMD0Block
    UBYTE
numtracks' UBYTE
lines' [[MMD0NoteData]]
notedata'