-----------------------------------------------------------------------------

-- |

-- Module      : Codec.SoundFont

-- Copyright   : George Giorgidze

-- License     : BSD3

-- 

-- Maintainer  : George Giorgidze <http://cs.nott.ac.uk/~ggg/>

-- Stability   : Experimental

-- Portability : Portable

--

-- Module for reading and writting of SoundFont instrument description files.

--

-----------------------------------------------------------------------------


module Codec.SoundFont (
    SoundFont (..)
  , Info (..)
  , Sdta (..)
  , Pdta (..)
  , Phdr (..)
  , Bag (..)
  , Mod (..)
  , Generator (..)
  , isSampleIndex
  , isInstIndex
  , Inst (..)
  , Shdr (..)
  , importFile
  , exportFile
  , parseSoundFont
  , buildSoundFont
  , parseInfos
  , buildInfos
  , parseSdta
  , buildSdta
  , parsePdta
  , buildPdta
  )  where

import Codec.ByteString.Parser
import Codec.ByteString.Builder
import Codec.Internal.Arbitrary
import qualified Data.Audio as Audio

import Data.Word
import Data.Int
import qualified Data.ByteString.Lazy as L
import Data.ByteString.Internal (w2c)
import Data.Array.IArray
import Data.List

import Test.QuickCheck
import Data.Monoid (mconcat)
import Control.Applicative
import Control.Monad

data SoundFont = SoundFont {
    SoundFont -> Array Word Info
infos :: Array Word Info -- Suplemental information

  , SoundFont -> Sdta
sdta  :: Sdta -- The Sample Binary Data

  , SoundFont -> Pdta
pdta :: Pdta 
  -- articulation :: Articulation -- The Preset, Instrument, and Sample Header data

  } deriving (SoundFont -> SoundFont -> Bool
(SoundFont -> SoundFont -> Bool)
-> (SoundFont -> SoundFont -> Bool) -> Eq SoundFont
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SoundFont -> SoundFont -> Bool
$c/= :: SoundFont -> SoundFont -> Bool
== :: SoundFont -> SoundFont -> Bool
$c== :: SoundFont -> SoundFont -> Bool
Eq, Int -> SoundFont -> ShowS
[SoundFont] -> ShowS
SoundFont -> String
(Int -> SoundFont -> ShowS)
-> (SoundFont -> String)
-> ([SoundFont] -> ShowS)
-> Show SoundFont
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SoundFont] -> ShowS
$cshowList :: [SoundFont] -> ShowS
show :: SoundFont -> String
$cshow :: SoundFont -> String
showsPrec :: Int -> SoundFont -> ShowS
$cshowsPrec :: Int -> SoundFont -> ShowS
Show)

instance Arbitrary SoundFont where
  arbitrary :: Gen SoundFont
arbitrary = do
    Array Word Info
f1 <- Gen (Array Word Info)
forall a. Arbitrary a => Gen a
arbitrary; Sdta
f2 <- Gen Sdta
forall a. Arbitrary a => Gen a
arbitrary; Pdta
f3 <- Gen Pdta
forall a. Arbitrary a => Gen a
arbitrary;
    SoundFont -> Gen SoundFont
forall (m :: * -> *) a. Monad m => a -> m a
return (SoundFont -> Gen SoundFont) -> SoundFont -> Gen SoundFont
forall a b. (a -> b) -> a -> b
$! Array Word Info -> Sdta -> Pdta -> SoundFont
SoundFont Array Word Info
f1 Sdta
f2 Pdta
f3

-- instance Show SoundFont where

--   show sf = (show $ length $ elems $ sampleData sf) ++ "\n" ++ (show $ length $ show $ articulation sf) ++ "\n"


-- type SamplePointIndex = Word32

-- type SampleData = UArray SamplePointIndex Audio.Sample


data Info = 
    Version Word Word -- Refers to file version of SounfFont RIFF file

  | TargetSoundEngine String -- Refers to target Sound Engine

  | BankName String -- Refers to SoundFont Bank Name

  | RomName String -- Refers to Sound ROM Name

  | RomVersion Word Word -- Refers to Sound ROM Version

  | CreationDate String -- Refers to Date of Creation of the Bank

  | Authors String -- Sound Designers and Engineers of the Bank

  | IntendedProduct String -- Product fot which the bank was intended

  | CopyrightMessage String -- Contains any copyright message

  | Comments String -- Contains any comemnts on the Bank

  | UsedTools String -- The SoundFont tools used to create and alter the bank

  | ReservedInfo String Word L.ByteString
  deriving (Info -> Info -> Bool
(Info -> Info -> Bool) -> (Info -> Info -> Bool) -> Eq Info
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Info -> Info -> Bool
$c/= :: Info -> Info -> Bool
== :: Info -> Info -> Bool
$c== :: Info -> Info -> Bool
Eq,Int -> Info -> ShowS
[Info] -> ShowS
Info -> String
(Int -> Info -> ShowS)
-> (Info -> String) -> ([Info] -> ShowS) -> Show Info
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Info] -> ShowS
$cshowList :: [Info] -> ShowS
show :: Info -> String
$cshow :: Info -> String
showsPrec :: Int -> Info -> ShowS
$cshowsPrec :: Int -> Info -> ShowS
Show)

instance Arbitrary Info where
  arbitrary :: Gen Info
arbitrary = [Gen Info] -> Gen Info
forall a. [Gen a] -> Gen a
oneof [
      do Word16
w1 <- (Word16, Word16) -> Gen Word16
forall a. Random a => (a, a) -> Gen a
choose (Word16
forall a. Bounded a => a
minBound :: Word16, Word16
forall a. Bounded a => a
maxBound)
         Word16
w2 <- (Word16, Word16) -> Gen Word16
forall a. Random a => (a, a) -> Gen a
choose (Word16
forall a. Bounded a => a
minBound :: Word16, Word16
forall a. Bounded a => a
maxBound)
         Info -> Gen Info
forall (m :: * -> *) a. Monad m => a -> m a
return (Info -> Gen Info) -> Info -> Gen Info
forall a b. (a -> b) -> a -> b
$ Word -> Word -> Info
Version (Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
w1) (Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
w2);
    , do Int
l <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
255); String
s <- Int -> Gen String
genStringNul Int
l; Info -> Gen Info
forall (m :: * -> *) a. Monad m => a -> m a
return  (Info -> Gen Info) -> Info -> Gen Info
forall a b. (a -> b) -> a -> b
$ String -> Info
TargetSoundEngine String
s
    , do Int
l <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
255); String
s <- Int -> Gen String
genStringNul Int
l; Info -> Gen Info
forall (m :: * -> *) a. Monad m => a -> m a
return  (Info -> Gen Info) -> Info -> Gen Info
forall a b. (a -> b) -> a -> b
$ String -> Info
BankName String
s
    , do Int
l <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
255); String
s <- Int -> Gen String
genStringNul Int
l; Info -> Gen Info
forall (m :: * -> *) a. Monad m => a -> m a
return  (Info -> Gen Info) -> Info -> Gen Info
forall a b. (a -> b) -> a -> b
$ String -> Info
RomName String
s
    , do Word16
w1 <- (Word16, Word16) -> Gen Word16
forall a. Random a => (a, a) -> Gen a
choose (Word16
forall a. Bounded a => a
minBound :: Word16, Word16
forall a. Bounded a => a
maxBound)
         Word16
w2 <- (Word16, Word16) -> Gen Word16
forall a. Random a => (a, a) -> Gen a
choose (Word16
forall a. Bounded a => a
minBound :: Word16, Word16
forall a. Bounded a => a
maxBound)
         Info -> Gen Info
forall (m :: * -> *) a. Monad m => a -> m a
return (Info -> Gen Info) -> Info -> Gen Info
forall a b. (a -> b) -> a -> b
$ Word -> Word -> Info
RomVersion (Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
w1) (Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
w2)
    , do Int
l <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
255); String
s <- Int -> Gen String
genStringNul Int
l; Info -> Gen Info
forall (m :: * -> *) a. Monad m => a -> m a
return  (Info -> Gen Info) -> Info -> Gen Info
forall a b. (a -> b) -> a -> b
$ String -> Info
CreationDate String
s
    , do Int
l <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
255); String
s <- Int -> Gen String
genStringNul Int
l; Info -> Gen Info
forall (m :: * -> *) a. Monad m => a -> m a
return  (Info -> Gen Info) -> Info -> Gen Info
forall a b. (a -> b) -> a -> b
$ String -> Info
Authors String
s
    , do Int
l <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
255); String
s <- Int -> Gen String
genStringNul Int
l; Info -> Gen Info
forall (m :: * -> *) a. Monad m => a -> m a
return  (Info -> Gen Info) -> Info -> Gen Info
forall a b. (a -> b) -> a -> b
$ String -> Info
IntendedProduct String
s
    , do Int
l <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
255); String
s <- Int -> Gen String
genStringNul Int
l; Info -> Gen Info
forall (m :: * -> *) a. Monad m => a -> m a
return  (Info -> Gen Info) -> Info -> Gen Info
forall a b. (a -> b) -> a -> b
$ String -> Info
CopyrightMessage String
s    
    , do Int
l <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
255); String
s <- Int -> Gen String
genStringNul Int
l; Info -> Gen Info
forall (m :: * -> *) a. Monad m => a -> m a
return  (Info -> Gen Info) -> Info -> Gen Info
forall a b. (a -> b) -> a -> b
$ String -> Info
Comments String
s
    , do Int
l <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
255); String
s <- Int -> Gen String
genStringNul Int
l; Info -> Gen Info
forall (m :: * -> *) a. Monad m => a -> m a
return  (Info -> Gen Info) -> Info -> Gen Info
forall a b. (a -> b) -> a -> b
$ String -> Info
UsedTools String
s
    , do Word
l <- (Word, Word) -> Gen Word
forall a. Random a => (a, a) -> Gen a
choose (Word
0,Word
255); [Word8]
s <- Int -> Gen [Word8]
forall a. Arbitrary a => Int -> Gen [a]
vector (Word -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
l);
         Info -> Gen Info
forall (m :: * -> *) a. Monad m => a -> m a
return  (Info -> Gen Info) -> Info -> Gen Info
forall a b. (a -> b) -> a -> b
$ String -> Word -> ByteString -> Info
ReservedInfo String
"RSRV" Word
l ([Word8] -> ByteString
L.pack [Word8]
s)]
    where
    genStringNul :: Int -> Gen String 
    genStringNul :: Int -> Gen String
genStringNul Int
l = [Gen Char] -> Gen String
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Gen Char] -> Gen String) -> [Gen Char] -> Gen String
forall a b. (a -> b) -> a -> b
$ Int -> Gen Char -> [Gen Char]
forall a. Int -> a -> [a]
replicate Int
l (Gen Char -> [Gen Char]) -> Gen Char -> [Gen Char]
forall a b. (a -> b) -> a -> b
$ (Word8 -> Char) -> Gen Word8 -> Gen Char
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word8 -> Char
w2c (Gen Word8 -> Gen Char) -> Gen Word8 -> Gen Char
forall a b. (a -> b) -> a -> b
$ (Word8, Word8) -> Gen Word8
forall a. Random a => (a, a) -> Gen a
choose (Word8
1,Word8
255)

data Sdta = Sdta {
    Sdta -> SampleData Int16
smpl :: Audio.SampleData Int16
  , Sdta -> Maybe (SampleData Int8)
sm24 :: Maybe (Audio.SampleData Int8)
  } deriving (Sdta -> Sdta -> Bool
(Sdta -> Sdta -> Bool) -> (Sdta -> Sdta -> Bool) -> Eq Sdta
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sdta -> Sdta -> Bool
$c/= :: Sdta -> Sdta -> Bool
== :: Sdta -> Sdta -> Bool
$c== :: Sdta -> Sdta -> Bool
Eq, Int -> Sdta -> ShowS
[Sdta] -> ShowS
Sdta -> String
(Int -> Sdta -> ShowS)
-> (Sdta -> String) -> ([Sdta] -> ShowS) -> Show Sdta
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Sdta] -> ShowS
$cshowList :: [Sdta] -> ShowS
show :: Sdta -> String
$cshow :: Sdta -> String
showsPrec :: Int -> Sdta -> ShowS
$cshowsPrec :: Int -> Sdta -> ShowS
Show)

instance Arbitrary Sdta where
  arbitrary :: Gen Sdta
arbitrary = do
    Word
sn <- (Word, Word) -> Gen Word
forall a. Random a => (a, a) -> Gen a
choose (Word
1,Word
1024)
    SampleData Int16
smpl1 <- Word -> Gen (SampleData Int16)
forall e i (a :: * -> * -> *).
(Arbitrary e, Num i, IArray a e, Ix i) =>
Word -> Gen (a i e)
arrayGen Word
sn
    [Gen Sdta] -> Gen Sdta
forall a. [Gen a] -> Gen a
oneof [
        Sdta -> Gen Sdta
forall (m :: * -> *) a. Monad m => a -> m a
return (Sdta -> Gen Sdta) -> Sdta -> Gen Sdta
forall a b. (a -> b) -> a -> b
$! SampleData Int16 -> Maybe (SampleData Int8) -> Sdta
Sdta SampleData Int16
smpl1 Maybe (SampleData Int8)
forall a. Maybe a
Nothing
      , do SampleData Int8
sm24' <- Word -> Gen (SampleData Int8)
forall e i (a :: * -> * -> *).
(Arbitrary e, Num i, IArray a e, Ix i) =>
Word -> Gen (a i e)
arrayGen Word
sn
           Sdta -> Gen Sdta
forall (m :: * -> *) a. Monad m => a -> m a
return (Sdta -> Gen Sdta) -> Sdta -> Gen Sdta
forall a b. (a -> b) -> a -> b
$! SampleData Int16 -> Maybe (SampleData Int8) -> Sdta
Sdta SampleData Int16
smpl1 (SampleData Int8 -> Maybe (SampleData Int8)
forall a. a -> Maybe a
Just SampleData Int8
sm24')
      ]

data Pdta = Pdta {
    Pdta -> Array Word Phdr
phdrs :: Array Word Phdr
  , Pdta -> Array Word Bag
pbags :: Array Word Bag
  , Pdta -> Array Word Mod
pmods :: Array Word Mod
  , Pdta -> Array Word Generator
pgens :: Array Word Generator
  , Pdta -> Array Word Inst
insts :: Array Word Inst
  , Pdta -> Array Word Bag
ibags :: Array Word Bag
  , Pdta -> Array Word Mod
imods :: Array Word Mod
  , Pdta -> Array Word Generator
igens :: Array Word Generator
  , Pdta -> Array Word Shdr
shdrs :: Array Word Shdr
  } deriving (Pdta -> Pdta -> Bool
(Pdta -> Pdta -> Bool) -> (Pdta -> Pdta -> Bool) -> Eq Pdta
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Pdta -> Pdta -> Bool
$c/= :: Pdta -> Pdta -> Bool
== :: Pdta -> Pdta -> Bool
$c== :: Pdta -> Pdta -> Bool
Eq, Int -> Pdta -> ShowS
[Pdta] -> ShowS
Pdta -> String
(Int -> Pdta -> ShowS)
-> (Pdta -> String) -> ([Pdta] -> ShowS) -> Show Pdta
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Pdta] -> ShowS
$cshowList :: [Pdta] -> ShowS
show :: Pdta -> String
$cshow :: Pdta -> String
showsPrec :: Int -> Pdta -> ShowS
$cshowsPrec :: Int -> Pdta -> ShowS
Show)
  
instance Arbitrary Pdta where
  arbitrary :: Gen Pdta
arbitrary = do
    Array Word Phdr
f1 <- Gen (Array Word Phdr)
forall a. Arbitrary a => Gen a
arbitrary; Array Word Bag
f2 <- Gen (Array Word Bag)
forall a. Arbitrary a => Gen a
arbitrary; Array Word Mod
f3 <- Gen (Array Word Mod)
forall a. Arbitrary a => Gen a
arbitrary; Array Word Generator
f4 <- Gen (Array Word Generator)
forall a. Arbitrary a => Gen a
arbitrary;
    Array Word Inst
f5 <- Gen (Array Word Inst)
forall a. Arbitrary a => Gen a
arbitrary; Array Word Bag
f6 <- Gen (Array Word Bag)
forall a. Arbitrary a => Gen a
arbitrary; Array Word Mod
f7 <- Gen (Array Word Mod)
forall a. Arbitrary a => Gen a
arbitrary; Array Word Generator
f8 <- Gen (Array Word Generator)
forall a. Arbitrary a => Gen a
arbitrary;
    Array Word Shdr
f9 <- Gen (Array Word Shdr)
forall a. Arbitrary a => Gen a
arbitrary;
    Pdta -> Gen Pdta
forall (m :: * -> *) a. Monad m => a -> m a
return (Pdta -> Gen Pdta) -> Pdta -> Gen Pdta
forall a b. (a -> b) -> a -> b
$! Array Word Phdr
-> Array Word Bag
-> Array Word Mod
-> Array Word Generator
-> Array Word Inst
-> Array Word Bag
-> Array Word Mod
-> Array Word Generator
-> Array Word Shdr
-> Pdta
Pdta Array Word Phdr
f1 Array Word Bag
f2 Array Word Mod
f3 Array Word Generator
f4 Array Word Inst
f5 Array Word Bag
f6 Array Word Mod
f7 Array Word Generator
f8 Array Word Shdr
f9

data Phdr = Phdr {
    Phdr -> String
presetName :: String
  , Phdr -> Word
preset :: Word
  , Phdr -> Word
bank :: Word
  , Phdr -> Word
presetBagNdx :: Word
  , Phdr -> Word
library :: Word
  , Phdr -> Word
genre :: Word
  , Phdr -> Word
morphology :: Word
  } deriving (Phdr -> Phdr -> Bool
(Phdr -> Phdr -> Bool) -> (Phdr -> Phdr -> Bool) -> Eq Phdr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Phdr -> Phdr -> Bool
$c/= :: Phdr -> Phdr -> Bool
== :: Phdr -> Phdr -> Bool
$c== :: Phdr -> Phdr -> Bool
Eq, Int -> Phdr -> ShowS
[Phdr] -> ShowS
Phdr -> String
(Int -> Phdr -> ShowS)
-> (Phdr -> String) -> ([Phdr] -> ShowS) -> Show Phdr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Phdr] -> ShowS
$cshowList :: [Phdr] -> ShowS
show :: Phdr -> String
$cshow :: Phdr -> String
showsPrec :: Int -> Phdr -> ShowS
$cshowsPrec :: Int -> Phdr -> ShowS
Show)

instance Arbitrary Phdr where
  arbitrary :: Gen Phdr
arbitrary = do
    Word
n <- (Word, Word) -> Gen Word
forall a. Random a => (a, a) -> Gen a
choose (Word
0,Word
20)
    String
presetName' <- Word -> Gen String
stringNulGen Word
n
    Word16
preset' <- (Word16, Word16) -> Gen Word16
forall a. Random a => (a, a) -> Gen a
choose (Word16
forall a. Bounded a => a
minBound :: Word16, Word16
forall a. Bounded a => a
maxBound)
    Word16
bank' <- (Word16, Word16) -> Gen Word16
forall a. Random a => (a, a) -> Gen a
choose (Word16
forall a. Bounded a => a
minBound :: Word16, Word16
forall a. Bounded a => a
maxBound)
    Word16
presetBagNdx' <- (Word16, Word16) -> Gen Word16
forall a. Random a => (a, a) -> Gen a
choose (Word16
forall a. Bounded a => a
minBound :: Word16, Word16
forall a. Bounded a => a
maxBound)
    Word32
library' <- (Word32, Word32) -> Gen Word32
forall a. Random a => (a, a) -> Gen a
choose (Word32
forall a. Bounded a => a
minBound :: Word32, Word32
forall a. Bounded a => a
maxBound)
    Word32
genre' <- (Word32, Word32) -> Gen Word32
forall a. Random a => (a, a) -> Gen a
choose (Word32
forall a. Bounded a => a
minBound :: Word32, Word32
forall a. Bounded a => a
maxBound)
    Word32
morphology' <- (Word32, Word32) -> Gen Word32
forall a. Random a => (a, a) -> Gen a
choose (Word32
forall a. Bounded a => a
minBound :: Word32, Word32
forall a. Bounded a => a
maxBound)
    Phdr -> Gen Phdr
forall (m :: * -> *) a. Monad m => a -> m a
return (Phdr -> Gen Phdr) -> Phdr -> Gen Phdr
forall a b. (a -> b) -> a -> b
$ Phdr :: String -> Word -> Word -> Word -> Word -> Word -> Word -> Phdr
Phdr {
        presetName :: String
presetName = String
presetName'
      , preset :: Word
preset = Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Word) -> Word16 -> Word
forall a b. (a -> b) -> a -> b
$ Word16
preset'
      , bank :: Word
bank = Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Word) -> Word16 -> Word
forall a b. (a -> b) -> a -> b
$ Word16
bank'
      , presetBagNdx :: Word
presetBagNdx = Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Word) -> Word16 -> Word
forall a b. (a -> b) -> a -> b
$ Word16
presetBagNdx'
      , library :: Word
library = Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word) -> Word32 -> Word
forall a b. (a -> b) -> a -> b
$ Word32
library'
      , genre :: Word
genre = Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word) -> Word32 -> Word
forall a b. (a -> b) -> a -> b
$ Word32
genre'
      , morphology :: Word
morphology = Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word32 -> Word) -> Word32 -> Word
forall a b. (a -> b) -> a -> b
$ Word32
morphology'
      }

data Bag = Bag {
    Bag -> Word
genNdx :: Word
  , Bag -> Word
modNdx :: Word
  } deriving (Bag -> Bag -> Bool
(Bag -> Bag -> Bool) -> (Bag -> Bag -> Bool) -> Eq Bag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Bag -> Bag -> Bool
$c/= :: Bag -> Bag -> Bool
== :: Bag -> Bag -> Bool
$c== :: Bag -> Bag -> Bool
Eq, Int -> Bag -> ShowS
[Bag] -> ShowS
Bag -> String
(Int -> Bag -> ShowS)
-> (Bag -> String) -> ([Bag] -> ShowS) -> Show Bag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Bag] -> ShowS
$cshowList :: [Bag] -> ShowS
show :: Bag -> String
$cshow :: Bag -> String
showsPrec :: Int -> Bag -> ShowS
$cshowsPrec :: Int -> Bag -> ShowS
Show)
  
instance Arbitrary Bag where
  arbitrary :: Gen Bag
arbitrary = do
    Word16
genNdx' <- (Word16, Word16) -> Gen Word16
forall a. Random a => (a, a) -> Gen a
choose (Word16
forall a. Bounded a => a
minBound :: Word16, Word16
forall a. Bounded a => a
maxBound)
    Word16
modNdx' <- (Word16, Word16) -> Gen Word16
forall a. Random a => (a, a) -> Gen a
choose (Word16
forall a. Bounded a => a
minBound :: Word16, Word16
forall a. Bounded a => a
maxBound)    
    Bag -> Gen Bag
forall (m :: * -> *) a. Monad m => a -> m a
return (Bag -> Gen Bag) -> Bag -> Gen Bag
forall a b. (a -> b) -> a -> b
$! Bag :: Word -> Word -> Bag
Bag {
        genNdx :: Word
genNdx = Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
genNdx'
      , modNdx :: Word
modNdx = Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
modNdx'}

data Mod = Mod {
    Mod -> Word
srcOper :: Word
  , Mod -> Word
destOper :: Word
  , Mod -> Int
amount :: Int
  , Mod -> Word
amtSrcOper :: Word
  , Mod -> Word
transOper :: Word
  } deriving (Mod -> Mod -> Bool
(Mod -> Mod -> Bool) -> (Mod -> Mod -> Bool) -> Eq Mod
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Mod -> Mod -> Bool
$c/= :: Mod -> Mod -> Bool
== :: Mod -> Mod -> Bool
$c== :: Mod -> Mod -> Bool
Eq, Int -> Mod -> ShowS
[Mod] -> ShowS
Mod -> String
(Int -> Mod -> ShowS)
-> (Mod -> String) -> ([Mod] -> ShowS) -> Show Mod
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Mod] -> ShowS
$cshowList :: [Mod] -> ShowS
show :: Mod -> String
$cshow :: Mod -> String
showsPrec :: Int -> Mod -> ShowS
$cshowsPrec :: Int -> Mod -> ShowS
Show)
  
instance Arbitrary Mod where
  arbitrary :: Gen Mod
arbitrary = do
    Word16
srcOper' <- (Word16, Word16) -> Gen Word16
forall a. Random a => (a, a) -> Gen a
choose (Word16
forall a. Bounded a => a
minBound :: Word16, Word16
forall a. Bounded a => a
maxBound)
    Word16
destOper' <- (Word16, Word16) -> Gen Word16
forall a. Random a => (a, a) -> Gen a
choose (Word16
forall a. Bounded a => a
minBound :: Word16, Word16
forall a. Bounded a => a
maxBound)    
    Int16
amount' <- (Int16, Int16) -> Gen Int16
forall a. Random a => (a, a) -> Gen a
choose (Int16
forall a. Bounded a => a
minBound :: Int16, Int16
forall a. Bounded a => a
maxBound)
    Word16
amtSrcOper' <- (Word16, Word16) -> Gen Word16
forall a. Random a => (a, a) -> Gen a
choose (Word16
forall a. Bounded a => a
minBound :: Word16, Word16
forall a. Bounded a => a
maxBound)    
    Word16
transOper' <- (Word16, Word16) -> Gen Word16
forall a. Random a => (a, a) -> Gen a
choose (Word16
forall a. Bounded a => a
minBound :: Word16, Word16
forall a. Bounded a => a
maxBound)                
    Mod -> Gen Mod
forall (m :: * -> *) a. Monad m => a -> m a
return (Mod -> Gen Mod) -> Mod -> Gen Mod
forall a b. (a -> b) -> a -> b
$! Mod :: Word -> Word -> Int -> Word -> Word -> Mod
Mod {
        srcOper :: Word
srcOper = Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
srcOper'
      , destOper :: Word
destOper = Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
destOper'
      , amount :: Int
amount = Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int16
amount'
      , amtSrcOper :: Word
amtSrcOper = Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
amtSrcOper'
      , transOper :: Word
transOper = Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
transOper'
      }

data Generator =
  -- Oscillator

  StartAddressOffset Int | -- 0 sample start fine offset

  EndAddressOffset Int | -- 1 sample end fine offset

  LoopStartAddressOffset Int | -- 2 sample start loop fine offset

  LoopEndAddressOffset Int |  -- 3 sample end loop file offset

  StartAddressCoarseOffset Int | -- 4 sample start coarse offset

  ModLfoToPitch Int | -- 5 main fm: modLfo-> pitch

  VibLfoToPitch Int | -- 6 aux fm:  vibLfo-> pitch

  ModEnvToPitch Int | -- 7 pitch env: modEnv(aux)-> pitch


  -- Filter

  InitFc Int | -- 8 initial filter cutoff

  InitQ Int | -- 9 filter Q

  ModLfoToFc Int | -- 10 filter modulation: lfo1 -> filter cutoff

  ModEnvToFc Int | -- 11 filter env: modEnv(aux)-> filter cutoff


  
  EndAddressCoarseOffset Int | -- 12 initial volume

  
  -- Amplifier

  ModLfoToVol Int | -- 13 tremolo: lfo1-> volume

  -- 14 unused


  -- Effects

  Chorus Int | -- 15 chorus

  Reverb Int | -- 16 reverb

  Pan Int | -- 17 pan

  -- 18 unused

  -- 19 unused

  -- 20 unused


  -- Modulation LFO

  DelayModLfo Int | -- 21 delay 

  FreqModLfo Int | -- 22 frequency


  -- Vibrato LFO

  DelayVibLfo Int | -- 23 delay 

  FreqVibLfo Int | -- 24 frequency


  -- Modulation Envelope

  DelayModEnv Int | -- 25 delay 

  AttackModEnv Int | -- 26 attack

  HoldModEnv Int | -- 27 hold

  DecayModEnv Int | -- 28 decay

  SustainModEnv Int | -- 29 sustain

  ReleaseModEnv Int | -- 30 release

  KeyToModEnvHold Int | -- 31 key scaling coefficient

  KeyToModEnvDecay Int | -- 32 key scaling coefficient


  -- Volume Envelope (ampl/vol)

  DelayVolEnv Int | -- 33 delay 

  AttackVolEnv Int | -- 34 attack

  HoldVolEnv Int | -- 35 hold

  DecayVolEnv Int | -- 36 decay

  SustainVolEnv Int | -- 37 sustain

  ReleaseVolEnv Int | -- 38 release

  KeyToVolEnvHold Int | -- 39 key scaling coefficient

  KeyToVolEnvDecay Int | -- 40 key scaling coefficient


  -- Preset

  InstIndex Word | -- 41

  -- 42

  KeyRange Word Word | -- 43

  VelRange Word Word | -- 44

  LoopStartAddressCoarseOffset Int | -- 45 

  Key Word | -- 46

  Vel Word | -- 47

  InitAtten Int | -- 48

  -- 49 unused

  LoopEndAddressCoarseOffset Int | -- 50


  CoarseTune Int | -- 51

  FineTune Int | -- 52

  SampleIndex Word | -- 53

  SampleMode Audio.SampleMode | -- 54

  --  55 unused

  ScaleTuning Int | -- 56

  ExclusiveClass Int | -- 57

       
  RootKey Word | -- 58

  -- 59 unused

  ReservedGen Int Int -- 60 single constructor for all unused generators

  deriving (Generator -> Generator -> Bool
(Generator -> Generator -> Bool)
-> (Generator -> Generator -> Bool) -> Eq Generator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Generator -> Generator -> Bool
$c/= :: Generator -> Generator -> Bool
== :: Generator -> Generator -> Bool
$c== :: Generator -> Generator -> Bool
Eq, Int -> Generator -> ShowS
[Generator] -> ShowS
Generator -> String
(Int -> Generator -> ShowS)
-> (Generator -> String)
-> ([Generator] -> ShowS)
-> Show Generator
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Generator] -> ShowS
$cshowList :: [Generator] -> ShowS
show :: Generator -> String
$cshow :: Generator -> String
showsPrec :: Int -> Generator -> ShowS
$cshowsPrec :: Int -> Generator -> ShowS
Show)

instance Arbitrary Generator where
  arbitrary :: Gen Generator
arbitrary = do
    Int
i <- (Int16, Int16) -> Gen Int16
forall a. Random a => (a, a) -> Gen a
choose (Int16
forall a. Bounded a => a
minBound :: Int16, Int16
forall a. Bounded a => a
maxBound)  Gen Int16 -> (Int16 -> Gen Int) -> Gen Int
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> Gen Int
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> Gen Int) -> (Int16 -> Int) -> Int16 -> Gen Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    Word
w <- (Word16, Word16) -> Gen Word16
forall a. Random a => (a, a) -> Gen a
choose (Word16
forall a. Bounded a => a
minBound :: Word16, Word16
forall a. Bounded a => a
maxBound)  Gen Word16 -> (Word16 -> Gen Word) -> Gen Word
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word -> Gen Word
forall (m :: * -> *) a. Monad m => a -> m a
return (Word -> Gen Word) -> (Word16 -> Word) -> Word16 -> Gen Word
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    Int
i' <- (Int16, Int16) -> Gen Int16
forall a. Random a => (a, a) -> Gen a
choose (Int16
60 :: Int16, Int16
forall a. Bounded a => a
maxBound)  Gen Int16 -> (Int16 -> Gen Int) -> Gen Int
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> Gen Int
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> Gen Int) -> (Int16 -> Int) -> Int16 -> Gen Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    Word
r1 <- (Word, Word) -> Gen Word
forall a. Random a => (a, a) -> Gen a
choose (Word
0,Word
127)
    Word
r2 <- (Word, Word) -> Gen Word
forall a. Random a => (a, a) -> Gen a
choose (Word
0,Word
127)
    SampleMode
smplMode' <- Gen SampleMode
forall a. Arbitrary a => Gen a
arbitrary
    [Gen Generator] -> Gen Generator
forall a. [Gen a] -> Gen a
oneof ([Gen Generator] -> Gen Generator)
-> [Gen Generator] -> Gen Generator
forall a b. (a -> b) -> a -> b
$ (Generator -> Gen Generator) -> [Generator] -> [Gen Generator]
forall a b. (a -> b) -> [a] -> [b]
map Generator -> Gen Generator
forall (m :: * -> *) a. Monad m => a -> m a
return [
        Int -> Generator
StartAddressOffset Int
i
      , Int -> Generator
EndAddressOffset Int
i 
      , Int -> Generator
LoopStartAddressOffset Int
i
      , Int -> Generator
LoopEndAddressOffset Int
i
      , Int -> Generator
StartAddressCoarseOffset Int
i
      , Int -> Generator
ModLfoToPitch Int
i
      , Int -> Generator
VibLfoToPitch Int
i
      , Int -> Generator
ModEnvToPitch Int
i
      
      , Int -> Generator
InitFc Int
i
      , Int -> Generator
InitQ Int
i
      , Int -> Generator
ModLfoToFc Int
i
      , Int -> Generator
ModEnvToFc Int
i
    
      , Int -> Generator
EndAddressCoarseOffset Int
i
      , Int -> Generator
ModLfoToVol Int
i
    
      , Int -> Generator
Chorus Int
i
      , Int -> Generator
Reverb Int
i
      , Int -> Generator
Pan Int
i
      , Int -> Generator
DelayModLfo Int
i
      , Int -> Generator
FreqModLfo Int
i
    
      , Int -> Generator
DelayVibLfo Int
i
      , Int -> Generator
FreqVibLfo Int
i
    
      , Int -> Generator
DelayModEnv Int
i
      , Int -> Generator
AttackModEnv Int
i
      , Int -> Generator
HoldModEnv Int
i
      , Int -> Generator
DecayModEnv Int
i
      , Int -> Generator
SustainModEnv Int
i
      , Int -> Generator
ReleaseModEnv Int
i
      , Int -> Generator
KeyToModEnvHold Int
i
      , Int -> Generator
KeyToModEnvDecay Int
i
    
      , Int -> Generator
DelayVolEnv Int
i
      , Int -> Generator
AttackVolEnv Int
i
      , Int -> Generator
HoldVolEnv Int
i
      , Int -> Generator
DecayVolEnv Int
i
      , Int -> Generator
SustainVolEnv Int
i
      , Int -> Generator
ReleaseVolEnv Int
i
      , Int -> Generator
KeyToVolEnvHold Int
i
      , Int -> Generator
KeyToVolEnvDecay Int
i
    
      , Word -> Generator
InstIndex Word
w
    
      , Word -> Word -> Generator
KeyRange Word
r1 Word
r2
      , Word -> Word -> Generator
VelRange Word
r2 Word
r2
      , Int -> Generator
LoopStartAddressCoarseOffset Int
i
      , Word -> Generator
Key Word
w
      , Word -> Generator
Vel Word
w
      , Int -> Generator
InitAtten Int
i
    
      , Int -> Generator
LoopEndAddressCoarseOffset Int
i
    
      , Int -> Generator
CoarseTune Int
i
      , Int -> Generator
FineTune Int
i
      , Word -> Generator
SampleIndex Word
w
      , SampleMode -> Generator
SampleMode SampleMode
smplMode'
    
      , Int -> Generator
ScaleTuning Int
i
      , Int -> Generator
ExclusiveClass Int
i
         
      , Word -> Generator
RootKey Word
w
    
      , Int -> Int -> Generator
ReservedGen Int
i' Int
i]

isSampleIndex :: Generator -> Bool
isSampleIndex :: Generator -> Bool
isSampleIndex Generator
g = case Generator
g of
  SampleIndex Word
_ -> Bool
True
  Generator
_ -> Bool
False 

isInstIndex :: Generator -> Bool
isInstIndex :: Generator -> Bool
isInstIndex Generator
g = case Generator
g of
  InstIndex Word
_ -> Bool
True
  Generator
_ -> Bool
False

data Inst = Inst {
    Inst -> String
instName :: String
  , Inst -> Word
instBagNdx :: Word
  } deriving (Inst -> Inst -> Bool
(Inst -> Inst -> Bool) -> (Inst -> Inst -> Bool) -> Eq Inst
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Inst -> Inst -> Bool
$c/= :: Inst -> Inst -> Bool
== :: Inst -> Inst -> Bool
$c== :: Inst -> Inst -> Bool
Eq, Int -> Inst -> ShowS
[Inst] -> ShowS
Inst -> String
(Int -> Inst -> ShowS)
-> (Inst -> String) -> ([Inst] -> ShowS) -> Show Inst
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Inst] -> ShowS
$cshowList :: [Inst] -> ShowS
show :: Inst -> String
$cshow :: Inst -> String
showsPrec :: Int -> Inst -> ShowS
$cshowsPrec :: Int -> Inst -> ShowS
Show)

instance Arbitrary Inst where
  arbitrary :: Gen Inst
arbitrary = do
    Word
n <- (Word, Word) -> Gen Word
forall a. Random a => (a, a) -> Gen a
choose (Word
0,Word
20)
    String
instName' <- Word -> Gen String
stringNulGen Word
n
    Word16
instBagNdx' <- (Word16, Word16) -> Gen Word16
forall a. Random a => (a, a) -> Gen a
choose (Word16
forall a. Bounded a => a
maxBound :: Word16, Word16
forall a. Bounded a => a
minBound)
    Inst -> Gen Inst
forall (m :: * -> *) a. Monad m => a -> m a
return (Inst -> Gen Inst) -> Inst -> Gen Inst
forall a b. (a -> b) -> a -> b
$! Inst :: String -> Word -> Inst
Inst {
        instName :: String
instName = String
instName'
      , instBagNdx :: Word
instBagNdx = Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Word) -> Word16 -> Word
forall a b. (a -> b) -> a -> b
$ Word16
instBagNdx'}

data Shdr = Shdr {
    Shdr -> String
sampleName :: String
  , Shdr -> Word
start :: Word
  , Shdr -> Word
end :: Word
  , Shdr -> Word
startLoop :: Word
  , Shdr -> Word
endLoop :: Word
  , Shdr -> Word
sampleRate :: Word
  , Shdr -> Word
originalPitch :: Word
  , Shdr -> Int
pitchCorrection :: Int
  , Shdr -> Word
sampleLink :: Word
  , Shdr -> Word
sampleType :: Word
  } deriving (Shdr -> Shdr -> Bool
(Shdr -> Shdr -> Bool) -> (Shdr -> Shdr -> Bool) -> Eq Shdr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Shdr -> Shdr -> Bool
$c/= :: Shdr -> Shdr -> Bool
== :: Shdr -> Shdr -> Bool
$c== :: Shdr -> Shdr -> Bool
Eq, Int -> Shdr -> ShowS
[Shdr] -> ShowS
Shdr -> String
(Int -> Shdr -> ShowS)
-> (Shdr -> String) -> ([Shdr] -> ShowS) -> Show Shdr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Shdr] -> ShowS
$cshowList :: [Shdr] -> ShowS
show :: Shdr -> String
$cshow :: Shdr -> String
showsPrec :: Int -> Shdr -> ShowS
$cshowsPrec :: Int -> Shdr -> ShowS
Show)

instance Arbitrary Shdr where
  arbitrary :: Gen Shdr
arbitrary = do
    Word
n <- (Word, Word) -> Gen Word
forall a. Random a => (a, a) -> Gen a
choose (Word
0,Word
20)
    String
sampleName' <- Word -> Gen String
stringNulGen Word
n
    Word32
start' <- (Word32, Word32) -> Gen Word32
forall a. Random a => (a, a) -> Gen a
choose (Word32
forall a. Bounded a => a
minBound :: Word32, Word32
forall a. Bounded a => a
maxBound)
    Word32
end' <- (Word32, Word32) -> Gen Word32
forall a. Random a => (a, a) -> Gen a
choose (Word32
forall a. Bounded a => a
minBound :: Word32, Word32
forall a. Bounded a => a
maxBound)
    Word32
startLoop' <- (Word32, Word32) -> Gen Word32
forall a. Random a => (a, a) -> Gen a
choose (Word32
forall a. Bounded a => a
minBound :: Word32, Word32
forall a. Bounded a => a
maxBound)
    Word32
endLoop' <- (Word32, Word32) -> Gen Word32
forall a. Random a => (a, a) -> Gen a
choose (Word32
forall a. Bounded a => a
minBound :: Word32, Word32
forall a. Bounded a => a
maxBound)
    Word32
sampleRate' <- (Word32, Word32) -> Gen Word32
forall a. Random a => (a, a) -> Gen a
choose (Word32
forall a. Bounded a => a
minBound :: Word32, Word32
forall a. Bounded a => a
maxBound)
    Word8
originalPitch' <- (Word8, Word8) -> Gen Word8
forall a. Random a => (a, a) -> Gen a
choose (Word8
forall a. Bounded a => a
minBound :: Word8, Word8
forall a. Bounded a => a
maxBound)
    Int8
pitchCorrection' <- (Int8, Int8) -> Gen Int8
forall a. Random a => (a, a) -> Gen a
choose (Int8
forall a. Bounded a => a
minBound :: Int8, Int8
forall a. Bounded a => a
maxBound)
    Word16
sampleLink' <- (Word16, Word16) -> Gen Word16
forall a. Random a => (a, a) -> Gen a
choose (Word16
forall a. Bounded a => a
minBound :: Word16, Word16
forall a. Bounded a => a
maxBound)
    Word16
sampleType' <- (Word16, Word16) -> Gen Word16
forall a. Random a => (a, a) -> Gen a
choose (Word16
forall a. Bounded a => a
minBound :: Word16, Word16
forall a. Bounded a => a
maxBound)    
    Shdr -> Gen Shdr
forall (m :: * -> *) a. Monad m => a -> m a
return (Shdr -> Gen Shdr) -> Shdr -> Gen Shdr
forall a b. (a -> b) -> a -> b
$ Shdr :: String
-> Word
-> Word
-> Word
-> Word
-> Word
-> Word
-> Int
-> Word
-> Word
-> Shdr
Shdr {
        sampleName :: String
sampleName = String
sampleName'
      , start :: Word
start = Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
start'
      , end :: Word
end = Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
end'
      , startLoop :: Word
startLoop = Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
startLoop'
      , endLoop :: Word
endLoop = Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
endLoop'
      , sampleRate :: Word
sampleRate = Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
sampleRate'
      , originalPitch :: Word
originalPitch = Word8 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
originalPitch'
      , pitchCorrection :: Int
pitchCorrection = Int8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int8
pitchCorrection'
      , sampleLink :: Word
sampleLink = Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
sampleLink'
      , sampleType :: Word
sampleType = Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
sampleType'
      }

---- SoundFont import


importFile :: FilePath -> IO (Either String SoundFont)
importFile :: String -> IO (Either String SoundFont)
importFile String
n = do
  ByteString
bs <- String -> IO ByteString
L.readFile String
n
  Either String SoundFont -> IO (Either String SoundFont)
forall (m :: * -> *) a. Monad m => a -> m a
return (Either String SoundFont -> IO (Either String SoundFont))
-> Either String SoundFont -> IO (Either String SoundFont)
forall a b. (a -> b) -> a -> b
$! Parser SoundFont -> ByteString -> Either String SoundFont
forall a. Parser a -> ByteString -> Either String a
runParser Parser SoundFont
parseSoundFont ByteString
bs

exportFile :: FilePath -> SoundFont ->  IO ()
exportFile :: String -> SoundFont -> IO ()
exportFile String
f SoundFont
sf = do
  let bs :: ByteString
bs = Builder -> ByteString
toLazyByteString (Builder -> ByteString) -> Builder -> ByteString
forall a b. (a -> b) -> a -> b
$ SoundFont -> Builder
buildSoundFont SoundFont
sf
  String -> ByteString -> IO ()
L.writeFile String
f ByteString
bs 

parseSoundFont :: Parser SoundFont
parseSoundFont :: Parser SoundFont
parseSoundFont = do
  String
_ <- String -> Parser String
string String
"RIFF"
  Word32
_ <- Parser Word32
getWord32le -- chunkSize

  String
_ <- String -> Parser String
string String
"sfbk"
  Array Word Info
infos' <- Parser (Array Word Info)
parseInfos
  Sdta
sdta' <- Parser Sdta
parseSdta
  Pdta
pdta' <- Parser Pdta
parsePdta
  SoundFont -> Parser SoundFont
forall (m :: * -> *) a. Monad m => a -> m a
return (SoundFont -> Parser SoundFont) -> SoundFont -> Parser SoundFont
forall a b. (a -> b) -> a -> b
$! SoundFont :: Array Word Info -> Sdta -> Pdta -> SoundFont
SoundFont {
      infos :: Array Word Info
infos = Array Word Info
infos'
    , sdta :: Sdta
sdta = Sdta
sdta'
    , pdta :: Pdta
pdta = Pdta
pdta'
    }

buildSoundFont :: SoundFont -> Builder
buildSoundFont :: SoundFont -> Builder
buildSoundFont SoundFont
sf = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [
    String -> Builder
putString String
"RIFF"
  , Word32 -> Builder
putWord32le (Word32 -> Builder) -> Word32 -> Builder
forall a b. (a -> b) -> a -> b
$ Int64 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
chunkSize
  , ByteString -> Builder
fromLazyByteString ByteString
bs]
  where
  chunkSize :: Int64
chunkSize = ByteString -> Int64
L.length ByteString
bs
  bs :: ByteString
bs = Builder -> ByteString
toLazyByteString (Builder -> ByteString) -> Builder -> ByteString
forall a b. (a -> b) -> a -> b
$ [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [
      String -> Builder
putString String
"sfbk"
    , Array Word Info -> Builder
buildInfos (SoundFont -> Array Word Info
infos SoundFont
sf)
    , Sdta -> Builder
buildSdta (SoundFont -> Sdta
sdta SoundFont
sf)
    , Pdta -> Builder
buildPdta (SoundFont -> Pdta
pdta SoundFont
sf)]

--buildSoundFont :: SoundFont -> Builder

--buildSoundFont sf = mconcat [


parseInfos :: Parser (Array Word Info)
parseInfos :: Parser (Array Word Info)
parseInfos = do
  String
_ <- String -> Parser String
string String
"LIST"
  Word32
_ <- Parser Word32
getWord32le -- chunkSize

  String
_ <- String -> Parser String
string String
"INFO"
  [Info]
infos' <- Parser Info -> Parser [Info]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser Info
p
  Array Word Info -> Parser (Array Word Info)
forall (m :: * -> *) a. Monad m => a -> m a
return (Array Word Info -> Parser (Array Word Info))
-> Array Word Info -> Parser (Array Word Info)
forall a b. (a -> b) -> a -> b
$! (Word, Word) -> [Info] -> Array Word Info
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
(i, i) -> [e] -> a i e
listArray (Word
0, [Info] -> Word
forall i a. Num i => [a] -> i
genericLength [Info]
infos' Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) [Info]
infos'
  where
  p :: Parser Info
p = [Parser Info] -> Parser Info
forall a. [Parser a] -> Parser a
choice [
      do String
n <- Int -> Parser String
getString Int
4; Word32
_ <- Word32 -> Parser Word32
word32le Word32
4; Word16
w1 <- Parser Word16
getWord16le; Word16
w2 <- Parser Word16
getWord16le;
         case String
n of
           String
"ifil" -> Info -> Parser Info
forall (m :: * -> *) a. Monad m => a -> m a
return (Info -> Parser Info) -> Info -> Parser Info
forall a b. (a -> b) -> a -> b
$! Word -> Word -> Info
Version (Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
w1) (Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
w2)
           String
"iver" -> Info -> Parser Info
forall (m :: * -> *) a. Monad m => a -> m a
return (Info -> Parser Info) -> Info -> Parser Info
forall a b. (a -> b) -> a -> b
$! Word -> Word -> Info
RomVersion (Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
w1) (Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
w2)
           String
_ -> String -> Parser Info
forall (m :: * -> *) a. MonadFail m => String -> m a
fail []
    , do String
n <- Int -> Parser String
getString Int
4; Word32
l <- (Word32 -> Bool) -> Parser Word32 -> Parser Word32
forall a. (Show a, Eq a) => (a -> Bool) -> Parser a -> Parser a
expect (Word32 -> Word32 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word32
256) Parser Word32
getWord32le; String
s <- Parser String
getStringNul;  
         Word64 -> Parser ()
skip (Word32 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
l Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
- String -> Word64
forall i a. Num i => [a] -> i
genericLength String
s Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
- Word64
1);
         case String
n of
           String
"isng" -> Info -> Parser Info
forall (m :: * -> *) a. Monad m => a -> m a
return (Info -> Parser Info) -> Info -> Parser Info
forall a b. (a -> b) -> a -> b
$! String -> Info
TargetSoundEngine String
s
           String
"INAM" -> Info -> Parser Info
forall (m :: * -> *) a. Monad m => a -> m a
return (Info -> Parser Info) -> Info -> Parser Info
forall a b. (a -> b) -> a -> b
$! String -> Info
BankName String
s
           String
"irom" -> Info -> Parser Info
forall (m :: * -> *) a. Monad m => a -> m a
return (Info -> Parser Info) -> Info -> Parser Info
forall a b. (a -> b) -> a -> b
$! String -> Info
RomName String
s
           String
"ICRD" -> Info -> Parser Info
forall (m :: * -> *) a. Monad m => a -> m a
return (Info -> Parser Info) -> Info -> Parser Info
forall a b. (a -> b) -> a -> b
$! String -> Info
CreationDate String
s
           String
"IENG" -> Info -> Parser Info
forall (m :: * -> *) a. Monad m => a -> m a
return (Info -> Parser Info) -> Info -> Parser Info
forall a b. (a -> b) -> a -> b
$! String -> Info
Authors String
s
           String
"IPRD" -> Info -> Parser Info
forall (m :: * -> *) a. Monad m => a -> m a
return (Info -> Parser Info) -> Info -> Parser Info
forall a b. (a -> b) -> a -> b
$! String -> Info
IntendedProduct String
s
           String
"ICOP" -> Info -> Parser Info
forall (m :: * -> *) a. Monad m => a -> m a
return (Info -> Parser Info) -> Info -> Parser Info
forall a b. (a -> b) -> a -> b
$! String -> Info
CopyrightMessage String
s
           String
"ICMT" -> Info -> Parser Info
forall (m :: * -> *) a. Monad m => a -> m a
return (Info -> Parser Info) -> Info -> Parser Info
forall a b. (a -> b) -> a -> b
$! String -> Info
Comments String
s
           String
"ISFT" -> Info -> Parser Info
forall (m :: * -> *) a. Monad m => a -> m a
return (Info -> Parser Info) -> Info -> Parser Info
forall a b. (a -> b) -> a -> b
$! String -> Info
UsedTools String
s
           String
_ -> String -> Parser Info
forall (m :: * -> *) a. MonadFail m => String -> m a
fail []
    , do String
n <- (String -> Bool) -> Parser String -> Parser String
forall a. (Show a, Eq a) => (a -> Bool) -> Parser a -> Parser a
expect ( String -> String -> Bool
forall a. Eq a => a -> a -> Bool
/= String
"LIST") (Int -> Parser String
getString Int
4)
         Word32
l <- Parser Word32
getWord32le 
         ByteString
bs <- Int64 -> Parser ByteString
getLazyByteString (Word32 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
l)
         Info -> Parser Info
forall (m :: * -> *) a. Monad m => a -> m a
return (Info -> Parser Info) -> Info -> Parser Info
forall a b. (a -> b) -> a -> b
$! String -> Word -> ByteString -> Info
ReservedInfo String
n (Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
l) ByteString
bs]

buildInfos :: (Array Word Info) -> Builder
buildInfos :: Array Word Info -> Builder
buildInfos Array Word Info
infos' = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [
    String -> Builder
putString String
"LIST"
  , Word32 -> Builder
putWord32le (Word32 -> Builder) -> Word32 -> Builder
forall a b. (a -> b) -> a -> b
$ (Int64 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int64 -> Word32) -> Int64 -> Word32
forall a b. (a -> b) -> a -> b
$ ByteString -> Int64
L.length ByteString
bs) Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
+ Word32
4
  , String -> Builder
putString String
"INFO"
  , ByteString -> Builder
fromLazyByteString ByteString
bs]
  where
  bs :: ByteString
bs = Builder -> ByteString
toLazyByteString (Builder -> ByteString) -> Builder -> ByteString
forall a b. (a -> b) -> a -> b
$ [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat ([Builder] -> Builder) -> [Builder] -> Builder
forall a b. (a -> b) -> a -> b
$ (Info -> Builder) -> [Info] -> [Builder]
forall a b. (a -> b) -> [a] -> [b]
map Info -> Builder
buildInfo ([Info] -> [Builder]) -> [Info] -> [Builder]
forall a b. (a -> b) -> a -> b
$ Array Word Info -> [Info]
forall (a :: * -> * -> *) e i. (IArray a e, Ix i) => a i e -> [e]
elems Array Word Info
infos'

{-
Specification says that 'ifil' 'isgn' and 'INAM' fields are mandatory
but I am not checking it during parsing
-}


buildInfo :: Info -> Builder
buildInfo :: Info -> Builder
buildInfo (Version Word
w1 Word
w2) = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat
  [String -> Builder
putString String
"ifil", Word32 -> Builder
putWord32le Word32
4,
   Word16 -> Builder
putWord16le (Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
w1), Word16 -> Builder
putWord16le (Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
w2)]
buildInfo (RomVersion Word
w1 Word
w2) = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat
  [String -> Builder
putString String
"iver", Word32 -> Builder
putWord32le Word32
4,
   Word16 -> Builder
putWord16le (Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
w1), Word16 -> Builder
putWord16le (Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
w2)]
buildInfo (TargetSoundEngine String
s) = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [String -> Builder
putString String
"isng", String -> Builder
buildInfoString String
s]
buildInfo (BankName String
s) = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [String -> Builder
putString String
"INAM", String -> Builder
buildInfoString String
s]
buildInfo (RomName String
s) = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [String -> Builder
putString String
"irom", String -> Builder
buildInfoString String
s]
buildInfo (CreationDate String
s) = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [String -> Builder
putString String
"ICRD", String -> Builder
buildInfoString String
s]
buildInfo (Authors String
s) = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [String -> Builder
putString String
"IENG", String -> Builder
buildInfoString String
s]
buildInfo (IntendedProduct String
s) = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [String -> Builder
putString String
"IPRD", String -> Builder
buildInfoString String
s]
buildInfo (CopyrightMessage String
s) = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [String -> Builder
putString String
"ICOP", String -> Builder
buildInfoString String
s]
buildInfo (Comments String
s) = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [String -> Builder
putString String
"ICMT", String -> Builder
buildInfoString String
s]
buildInfo (UsedTools String
s) = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [String -> Builder
putString String
"ISFT", String -> Builder
buildInfoString String
s]
buildInfo (ReservedInfo String
n Word
l ByteString
bs) = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat
  [String -> Builder
putString String
n, Word32 -> Builder
putWord32le (Word -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
l), ByteString -> Builder
fromLazyByteString ByteString
bs]
  
buildInfoString :: String -> Builder
buildInfoString :: String -> Builder
buildInfoString String
s = if (Word32 -> Word32 -> Word32
forall a. Integral a => a -> a -> a
mod Word32
l Word32
2 Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32
0)
  then [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [Word32 -> Builder
putWord32le (Word32
l Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
+ Word32
2), String -> Builder
putString String
s, Word8 -> Builder
putWord8 Word8
0, Word8 -> Builder
putWord8 Word8
0]
  else [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [Word32 -> Builder
putWord32le (Word32
l Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
+ Word32
1), String -> Builder
putString String
s, Word8 -> Builder
putWord8 Word8
0]
  where
  l :: Word32
l = Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ String -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length String
s
  
parseSdta :: Parser Sdta
parseSdta :: Parser Sdta
parseSdta = do
  String
_ <- String -> Parser String
string String
"LIST"
  Int
sdtaSize <- Parser Word32
getWord32le Parser Word32 -> (Word32 -> Parser Int) -> Parser Int
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> Parser Int
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> Parser Int) -> (Word32 -> Int) -> Word32 -> Parser Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Word32 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  String
_ <- String -> Parser String
string String
"sdta"
  String
_ <- String -> Parser String
string String
"smpl"
  Int
smplSize <- Parser Word32
getWord32le  Parser Word32 -> (Word32 -> Parser Int) -> Parser Int
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> Parser Int
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> Parser Int) -> (Word32 -> Int) -> Word32 -> Parser Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Word32 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  Bool -> Parser () -> Parser ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int -> Bool
forall a. Integral a => a -> Bool
odd Int
smplSize) (Parser () -> Parser ()) -> Parser () -> Parser ()
forall a b. (a -> b) -> a -> b
$ String -> Parser ()
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"'smplSize' must not be odd number"
  let sn :: Int
sn = Int -> Int -> Int
forall a. Integral a => a -> a -> a
div Int
smplSize Int
2
  SampleData Int16
smpl' <- Int -> Parser Int16 -> Parser (SampleData Int16)
forall a.
(MArray IOUArray a IO, IArray UArray a) =>
Int -> Parser a -> Parser (SampleData a)
Audio.parseSampleData Int
sn Parser Int16
getInt16le
  [Parser Sdta] -> Parser Sdta
forall a. [Parser a] -> Parser a
choice [
      do Bool -> Parser ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Int
smplSize Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== (Int
sdtaSize Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
12))
         Sdta -> Parser Sdta
forall (m :: * -> *) a. Monad m => a -> m a
return (Sdta -> Parser Sdta) -> Sdta -> Parser Sdta
forall a b. (a -> b) -> a -> b
$! Sdta :: SampleData Int16 -> Maybe (SampleData Int8) -> Sdta
Sdta {smpl :: SampleData Int16
smpl = SampleData Int16
smpl', sm24 :: Maybe (SampleData Int8)
sm24 =  Maybe (SampleData Int8)
forall a. Maybe a
Nothing}
    , do String
_ <- String -> Parser String
string String
"sm24"
         let sm24Size :: Int
sm24Size = if Int -> Bool
forall a. Integral a => a -> Bool
odd Int
sn then Int
sn Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1 else Int
sn 
         Word32
_ <- Word32 -> Parser Word32
word32le (Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
sm24Size)
         SampleData Int8
sm24' <- Int -> Parser Int8 -> Parser (SampleData Int8)
forall a.
(MArray IOUArray a IO, IArray UArray a) =>
Int -> Parser a -> Parser (SampleData a)
Audio.parseSampleData Int
sn Parser Int8
getInt8
         Word64 -> Parser ()
skip (Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word64) -> Int -> Word64
forall a b. (a -> b) -> a -> b
$ Int
sm24Size Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
sn)
         Sdta -> Parser Sdta
forall (m :: * -> *) a. Monad m => a -> m a
return (Sdta -> Parser Sdta) -> Sdta -> Parser Sdta
forall a b. (a -> b) -> a -> b
$! Sdta :: SampleData Int16 -> Maybe (SampleData Int8) -> Sdta
Sdta{ smpl :: SampleData Int16
smpl = SampleData Int16
smpl', sm24 :: Maybe (SampleData Int8)
sm24 = SampleData Int8 -> Maybe (SampleData Int8)
forall a. a -> Maybe a
Just SampleData Int8
sm24'}
    ]

buildSdta :: Sdta -> Builder
buildSdta :: Sdta -> Builder
buildSdta (Sdta SampleData Int16
smpl1 Maybe (SampleData Int8)
Nothing) = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [
    String -> Builder
putString String
"LIST"
  , Word32 -> Builder
putWord32le (Word32 -> Builder) -> Word32 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ Int
sdtaSize
  , String -> Builder
putString String
"sdta"
  , String -> Builder
putString String
"smpl"
  , Word32 -> Builder
putWord32le (Word32 -> Builder) -> Word32 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ Int
smplSize
  , (Int16 -> Builder) -> SampleData Int16 -> Builder
forall a.
IArray UArray a =>
(a -> Builder) -> SampleData a -> Builder
Audio.buildSampleData Int16 -> Builder
putInt16le SampleData Int16
smpl1]
  where smplSize :: Int
smplSize = (SampleData Int16 -> Int
forall a. IArray UArray a => SampleData a -> Int
Audio.sampleNumber SampleData Int16
smpl1) Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
2
        sdtaSize :: Int
sdtaSize = Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
smplSize
buildSdta (Sdta SampleData Int16
smpl1 (Just SampleData Int8
sd8)) = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [
    String -> Builder
putString String
"LIST"
  , Word32 -> Builder
putWord32le (Word32 -> Builder) -> Word32 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ Int
sdtaSize
  , String -> Builder
putString String
"sdta"
  , String -> Builder
putString String
"smpl"
  , Word32 -> Builder
putWord32le (Word32 -> Builder) -> Word32 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ Int
smplSize
  , (Int16 -> Builder) -> SampleData Int16 -> Builder
forall a.
IArray UArray a =>
(a -> Builder) -> SampleData a -> Builder
Audio.buildSampleData Int16 -> Builder
putInt16le SampleData Int16
smpl1
  , String -> Builder
putString String
"sm24"
  , Word32 -> Builder
putWord32le (Word32 -> Builder) -> Word32 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ Int
sm24Size
  , (Int8 -> Builder) -> SampleData Int8 -> Builder
forall a.
IArray UArray a =>
(a -> Builder) -> SampleData a -> Builder
Audio.buildSampleData Int8 -> Builder
putInt8 SampleData Int8
sd8
  , [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat ([Builder] -> Builder) -> [Builder] -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Builder -> [Builder]
forall i a. Integral i => i -> a -> [a]
genericReplicate (Int
sm24Size Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
sn) (Builder -> [Builder]) -> Builder -> [Builder]
forall a b. (a -> b) -> a -> b
$ Word8 -> Builder
putWord8 Word8
0]
  where sn :: Int
sn = SampleData Int16 -> Int
forall a. IArray UArray a => SampleData a -> Int
Audio.sampleNumber SampleData Int16
smpl1
        smplSize :: Int
smplSize = Int
sn Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
2
        sm24Size :: Int
sm24Size = if Int -> Bool
forall a. Integral a => a -> Bool
odd Int
sn then Int
sn Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1 else Int
sn
        sdtaSize :: Int
sdtaSize = Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
smplSize Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
sm24Size

parsePdta :: Parser Pdta
parsePdta :: Parser Pdta
parsePdta = do
  String
_ <- String -> Parser String
string String
"LIST"
  Word32
_ <- Parser Word32
getWord32le -- pdtaSize

  String
_ <- String -> Parser String
string String
"pdta"
  Array Word Phdr
phdrs' <- String -> Word -> Parser Phdr -> Parser (Array Word Phdr)
forall a. String -> Word -> Parser a -> Parser (Array Word a)
parseSubchunk String
"phdr" Word
38 Parser Phdr
parsePhdr
  Array Word Bag
pbags' <- String -> Word -> Parser Bag -> Parser (Array Word Bag)
forall a. String -> Word -> Parser a -> Parser (Array Word a)
parseSubchunk String
"pbag" Word
4 Parser Bag
parseBag
  Array Word Mod
pmods' <- String -> Word -> Parser Mod -> Parser (Array Word Mod)
forall a. String -> Word -> Parser a -> Parser (Array Word a)
parseSubchunk String
"pmod" Word
10 Parser Mod
parseMod
  Array Word Generator
pgens' <- String -> Word -> Parser Generator -> Parser (Array Word Generator)
forall a. String -> Word -> Parser a -> Parser (Array Word a)
parseSubchunk String
"pgen" Word
4  Parser Generator
parseGen
  Array Word Inst
insts' <- String -> Word -> Parser Inst -> Parser (Array Word Inst)
forall a. String -> Word -> Parser a -> Parser (Array Word a)
parseSubchunk String
"inst" Word
22  Parser Inst
parseInst  
  Array Word Bag
ibags' <- String -> Word -> Parser Bag -> Parser (Array Word Bag)
forall a. String -> Word -> Parser a -> Parser (Array Word a)
parseSubchunk String
"ibag" Word
4 Parser Bag
parseBag
  Array Word Mod
imods' <- String -> Word -> Parser Mod -> Parser (Array Word Mod)
forall a. String -> Word -> Parser a -> Parser (Array Word a)
parseSubchunk String
"imod" Word
10 Parser Mod
parseMod
  Array Word Generator
igens' <- String -> Word -> Parser Generator -> Parser (Array Word Generator)
forall a. String -> Word -> Parser a -> Parser (Array Word a)
parseSubchunk String
"igen" Word
4  Parser Generator
parseGen
  Array Word Shdr
shdrs' <- String -> Word -> Parser Shdr -> Parser (Array Word Shdr)
forall a. String -> Word -> Parser a -> Parser (Array Word a)
parseSubchunk String
"shdr" Word
46 Parser Shdr
parseShdr
  Pdta -> Parser Pdta
forall (m :: * -> *) a. Monad m => a -> m a
return (Pdta -> Parser Pdta) -> Pdta -> Parser Pdta
forall a b. (a -> b) -> a -> b
$! Array Word Phdr
-> Array Word Bag
-> Array Word Mod
-> Array Word Generator
-> Array Word Inst
-> Array Word Bag
-> Array Word Mod
-> Array Word Generator
-> Array Word Shdr
-> Pdta
Pdta Array Word Phdr
phdrs' Array Word Bag
pbags' Array Word Mod
pmods' Array Word Generator
pgens' Array Word Inst
insts' Array Word Bag
ibags' Array Word Mod
imods' Array Word Generator
igens' Array Word Shdr
shdrs'

buildPdta :: Pdta -> Builder
buildPdta :: Pdta -> Builder
buildPdta Pdta
pdta1 = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [
    String -> Builder
putString String
"LIST"
  , Word32 -> Builder
putWord32le (Word32 -> Builder) -> Word32 -> Builder
forall a b. (a -> b) -> a -> b
$ Int64 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
chunkSize
  , ByteString -> Builder
fromLazyByteString ByteString
bs]
  where
  chunkSize :: Int64
chunkSize = ByteString -> Int64
L.length ByteString
bs
  bs :: ByteString
bs = Builder -> ByteString
toLazyByteString (Builder -> ByteString) -> Builder -> ByteString
forall a b. (a -> b) -> a -> b
$ [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [
      String -> Builder
putString String
"pdta"
    , String -> Word -> (Phdr -> Builder) -> Array Word Phdr -> Builder
forall a.
String -> Word -> (a -> Builder) -> Array Word a -> Builder
buildSubchunk String
"phdr" Word
38 Phdr -> Builder
buildPhdr (Pdta -> Array Word Phdr
phdrs Pdta
pdta1)
    , String -> Word -> (Bag -> Builder) -> Array Word Bag -> Builder
forall a.
String -> Word -> (a -> Builder) -> Array Word a -> Builder
buildSubchunk String
"pbag"  Word
4 Bag -> Builder
buildBag  (Pdta -> Array Word Bag
pbags Pdta
pdta1)
    , String -> Word -> (Mod -> Builder) -> Array Word Mod -> Builder
forall a.
String -> Word -> (a -> Builder) -> Array Word a -> Builder
buildSubchunk String
"pmod" Word
10 Mod -> Builder
buildMod  (Pdta -> Array Word Mod
pmods Pdta
pdta1)
    , String
-> Word
-> (Generator -> Builder)
-> Array Word Generator
-> Builder
forall a.
String -> Word -> (a -> Builder) -> Array Word a -> Builder
buildSubchunk String
"pgen"  Word
4 Generator -> Builder
buildGen  (Pdta -> Array Word Generator
pgens Pdta
pdta1)
    , String -> Word -> (Inst -> Builder) -> Array Word Inst -> Builder
forall a.
String -> Word -> (a -> Builder) -> Array Word a -> Builder
buildSubchunk String
"inst" Word
22 Inst -> Builder
buildInst (Pdta -> Array Word Inst
insts Pdta
pdta1)
    , String -> Word -> (Bag -> Builder) -> Array Word Bag -> Builder
forall a.
String -> Word -> (a -> Builder) -> Array Word a -> Builder
buildSubchunk String
"ibag"  Word
4 Bag -> Builder
buildBag  (Pdta -> Array Word Bag
ibags Pdta
pdta1)
    , String -> Word -> (Mod -> Builder) -> Array Word Mod -> Builder
forall a.
String -> Word -> (a -> Builder) -> Array Word a -> Builder
buildSubchunk String
"imod" Word
10 Mod -> Builder
buildMod  (Pdta -> Array Word Mod
imods Pdta
pdta1)
    , String
-> Word
-> (Generator -> Builder)
-> Array Word Generator
-> Builder
forall a.
String -> Word -> (a -> Builder) -> Array Word a -> Builder
buildSubchunk String
"igen"  Word
4 Generator -> Builder
buildGen  (Pdta -> Array Word Generator
igens Pdta
pdta1)    
    , String -> Word -> (Shdr -> Builder) -> Array Word Shdr -> Builder
forall a.
String -> Word -> (a -> Builder) -> Array Word a -> Builder
buildSubchunk String
"shdr" Word
46 Shdr -> Builder
buildShdr (Pdta -> Array Word Shdr
shdrs Pdta
pdta1)    
    ]

-- For some subchunks minimal number of records is two

-- but this check can be done later I am skiping it here

parseSubchunk :: String -> Word -> (Parser a) -> Parser (Array Word a)
parseSubchunk :: String -> Word -> Parser a -> Parser (Array Word a)
parseSubchunk String
s Word
size Parser a
p = do
  String
_ <- String -> Parser String
string String
s
  Word
chunkSize <- (Word -> Bool) -> Parser Word -> Parser Word
forall a. (Show a, Eq a) => (a -> Bool) -> Parser a -> Parser a
expect (\Word
w -> Word -> Word -> Word
forall a. Integral a => a -> a -> a
mod Word
w Word
size Word -> Word -> Bool
forall a. Eq a => a -> a -> Bool
== Word
0) (Parser Word32
getWord32le Parser Word32 -> (Word32 -> Parser Word) -> Parser Word
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word -> Parser Word
forall (m :: * -> *) a. Monad m => a -> m a
return (Word -> Parser Word) -> (Word32 -> Word) -> Word32 -> Parser Word
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral)
  let n :: Word
n = Word -> Word -> Word
forall a. Integral a => a -> a -> a
div Word
chunkSize Word
size
  [a]
cs <- [Parser a] -> Parser [a]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence (Word -> Parser a -> [Parser a]
forall i a. Integral i => i -> a -> [a]
genericReplicate Word
n Parser a
p)
  Array Word a -> Parser (Array Word a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Array Word a -> Parser (Array Word a))
-> Array Word a -> Parser (Array Word a)
forall a b. (a -> b) -> a -> b
$! (Word, Word) -> [a] -> Array Word a
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
(i, i) -> [e] -> a i e
listArray (Word
0, Word
n Word -> Word -> Word
forall a. Num a => a -> a -> a
- Word
1) [a]
cs

buildSubchunk :: String -> Word -> (a -> Builder) -> (Array Word a) ->  Builder
buildSubchunk :: String -> Word -> (a -> Builder) -> Array Word a -> Builder
buildSubchunk String
s Word
size a -> Builder
b Array Word a
a = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [
    String -> Builder
putString String
s
  , Word32 -> Builder
putWord32le (Word32 -> Builder) -> Word32 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word32) -> Word -> Word32
forall a b. (a -> b) -> a -> b
$ (Word
1 Word -> Word -> Word
forall a. Num a => a -> a -> a
+ ((Word, Word) -> Word
forall a b. (a, b) -> b
snd ((Word, Word) -> Word) -> (Word, Word) -> Word
forall a b. (a -> b) -> a -> b
$ Array Word a -> (Word, Word)
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds Array Word a
a)) Word -> Word -> Word
forall a. Num a => a -> a -> a
* Word
size
  , [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat ([Builder] -> Builder) -> [Builder] -> Builder
forall a b. (a -> b) -> a -> b
$ (a -> Builder) -> [a] -> [Builder]
forall a b. (a -> b) -> [a] -> [b]
map a -> Builder
b ([a] -> [Builder]) -> [a] -> [Builder]
forall a b. (a -> b) -> a -> b
$ Array Word a -> [a]
forall (a :: * -> * -> *) e i. (IArray a e, Ix i) => a i e -> [e]
elems Array Word a
a]
  
parsePhdr :: Parser Phdr  
parsePhdr :: Parser Phdr
parsePhdr = do
  String
presetName' <- Int64 -> Parser ByteString
getLazyByteString Int64
20
                 Parser ByteString -> (ByteString -> Parser String) -> Parser String
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> Parser String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Parser String)
-> (ByteString -> String) -> ByteString -> Parser String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word8 -> Char) -> [Word8] -> String
forall a b. (a -> b) -> [a] -> [b]
map Word8 -> Char
w2c ([Word8] -> String)
-> (ByteString -> [Word8]) -> ByteString -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [Word8]
L.unpack (ByteString -> [Word8])
-> (ByteString -> ByteString) -> ByteString -> [Word8]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word8 -> Bool) -> ByteString -> ByteString
L.takeWhile ( Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word8
0)
  Word
preset' <- Parser Word16
getWord16le Parser Word16 -> (Word16 -> Parser Word) -> Parser Word
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word -> Parser Word
forall (m :: * -> *) a. Monad m => a -> m a
return (Word -> Parser Word) -> (Word16 -> Word) -> Word16 -> Parser Word
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  Word
bank' <- Parser Word16
getWord16le Parser Word16 -> (Word16 -> Parser Word) -> Parser Word
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word -> Parser Word
forall (m :: * -> *) a. Monad m => a -> m a
return (Word -> Parser Word) -> (Word16 -> Word) -> Word16 -> Parser Word
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  Word
presetBagNdx' <- Parser Word16
getWord16le Parser Word16 -> (Word16 -> Parser Word) -> Parser Word
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word -> Parser Word
forall (m :: * -> *) a. Monad m => a -> m a
return (Word -> Parser Word) -> (Word16 -> Word) -> Word16 -> Parser Word
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  Word
library' <- Parser Word32
getWord32le Parser Word32 -> (Word32 -> Parser Word) -> Parser Word
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word -> Parser Word
forall (m :: * -> *) a. Monad m => a -> m a
return (Word -> Parser Word) -> (Word32 -> Word) -> Word32 -> Parser Word
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  Word
genre' <- Parser Word32
getWord32le Parser Word32 -> (Word32 -> Parser Word) -> Parser Word
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word -> Parser Word
forall (m :: * -> *) a. Monad m => a -> m a
return (Word -> Parser Word) -> (Word32 -> Word) -> Word32 -> Parser Word
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  Word
morphology' <- Parser Word32
getWord32le Parser Word32 -> (Word32 -> Parser Word) -> Parser Word
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word -> Parser Word
forall (m :: * -> *) a. Monad m => a -> m a
return (Word -> Parser Word) -> (Word32 -> Word) -> Word32 -> Parser Word
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  Phdr -> Parser Phdr
forall (m :: * -> *) a. Monad m => a -> m a
return (Phdr -> Parser Phdr) -> Phdr -> Parser Phdr
forall a b. (a -> b) -> a -> b
$ Phdr :: String -> Word -> Word -> Word -> Word -> Word -> Word -> Phdr
Phdr {
      presetName :: String
presetName = String
presetName'
    , preset :: Word
preset = Word
preset'
    , bank :: Word
bank = Word
bank'
    , presetBagNdx :: Word
presetBagNdx = Word
presetBagNdx'
    , library :: Word
library = Word
library'
    , genre :: Word
genre = Word
genre'
    , morphology :: Word
morphology = Word
morphology'
    }

buildPhdr :: Phdr -> Builder  
buildPhdr :: Phdr -> Builder
buildPhdr Phdr
phdr = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [
      String -> Builder
putString (String -> Builder) -> String -> Builder
forall a b. (a -> b) -> a -> b
$ Phdr -> String
presetName Phdr
phdr
    , [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat ([Builder] -> Builder) -> [Builder] -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Builder -> [Builder]
forall a. Int -> a -> [a]
replicate (Int
20 Int -> Int -> Int
forall a. Num a => a -> a -> a
- String -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (Phdr -> String
presetName Phdr
phdr)) (Word8 -> Builder
putWord8 Word8
0) 
    , Word16 -> Builder
putWord16le (Word16 -> Builder) -> Word16 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word16) -> Word -> Word16
forall a b. (a -> b) -> a -> b
$ Phdr -> Word
preset Phdr
phdr
    , Word16 -> Builder
putWord16le (Word16 -> Builder) -> Word16 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word16) -> Word -> Word16
forall a b. (a -> b) -> a -> b
$ Phdr -> Word
bank Phdr
phdr
    , Word16 -> Builder
putWord16le (Word16 -> Builder) -> Word16 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word16) -> Word -> Word16
forall a b. (a -> b) -> a -> b
$ Phdr -> Word
presetBagNdx Phdr
phdr
    , Word32 -> Builder
putWord32le (Word32 -> Builder) -> Word32 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word32) -> Word -> Word32
forall a b. (a -> b) -> a -> b
$ Phdr -> Word
library Phdr
phdr
    , Word32 -> Builder
putWord32le (Word32 -> Builder) -> Word32 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word32) -> Word -> Word32
forall a b. (a -> b) -> a -> b
$ Phdr -> Word
genre Phdr
phdr
    , Word32 -> Builder
putWord32le (Word32 -> Builder) -> Word32 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word32) -> Word -> Word32
forall a b. (a -> b) -> a -> b
$ Phdr -> Word
morphology Phdr
phdr    
    ]

parseBag :: Parser Bag
parseBag :: Parser Bag
parseBag = do
    Word16
genNdx' <- Parser Word16
getWord16le
    Word16
modNdx' <- Parser Word16
getWord16le
    Bag -> Parser Bag
forall (m :: * -> *) a. Monad m => a -> m a
return (Bag -> Parser Bag) -> Bag -> Parser Bag
forall a b. (a -> b) -> a -> b
$! Bag :: Word -> Word -> Bag
Bag {
        genNdx :: Word
genNdx = Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
genNdx'
      , modNdx :: Word
modNdx = Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
modNdx'}
    
buildBag :: Bag -> Builder  
buildBag :: Bag -> Builder
buildBag Bag
bag = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [
      Word16 -> Builder
putWord16le (Word16 -> Builder) -> Word16 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word16) -> Word -> Word16
forall a b. (a -> b) -> a -> b
$ Bag -> Word
genNdx Bag
bag
    , Word16 -> Builder
putWord16le (Word16 -> Builder) -> Word16 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word16) -> Word -> Word16
forall a b. (a -> b) -> a -> b
$ Bag -> Word
modNdx Bag
bag]

parseMod :: Parser Mod
parseMod :: Parser Mod
parseMod = do
    Word16
srcOper' <- Parser Word16
getWord16le
    Word16
destOper' <- Parser Word16
getWord16le
    Int16
amount' <- Parser Int16
getInt16le
    Word16
amtSrcOper' <- Parser Word16
getWord16le
    Word16
transOper' <- Parser Word16
getWord16le
    Mod -> Parser Mod
forall (m :: * -> *) a. Monad m => a -> m a
return (Mod -> Parser Mod) -> Mod -> Parser Mod
forall a b. (a -> b) -> a -> b
$! Mod :: Word -> Word -> Int -> Word -> Word -> Mod
Mod {
        srcOper :: Word
srcOper = Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
srcOper'
      , destOper :: Word
destOper = Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
destOper'
      , amount :: Int
amount = Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int16
amount'
      , amtSrcOper :: Word
amtSrcOper = Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
amtSrcOper'
      , transOper :: Word
transOper = Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
transOper'
      }
    
buildMod :: Mod -> Builder
buildMod :: Mod -> Builder
buildMod Mod
m = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [
      Word16 -> Builder
putWord16le (Word16 -> Builder) -> Word16 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word16) -> Word -> Word16
forall a b. (a -> b) -> a -> b
$ Mod -> Word
srcOper Mod
m
    , Word16 -> Builder
putWord16le (Word16 -> Builder) -> Word16 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word16) -> Word -> Word16
forall a b. (a -> b) -> a -> b
$ Mod -> Word
destOper Mod
m
    , Word16 -> Builder
putWord16le (Word16 -> Builder) -> Word16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word16) -> Int -> Word16
forall a b. (a -> b) -> a -> b
$ Mod -> Int
amount Mod
m
    , Word16 -> Builder
putWord16le (Word16 -> Builder) -> Word16 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word16) -> Word -> Word16
forall a b. (a -> b) -> a -> b
$ Mod -> Word
amtSrcOper Mod
m
    , Word16 -> Builder
putWord16le (Word16 -> Builder) -> Word16 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word16) -> Word -> Word16
forall a b. (a -> b) -> a -> b
$ Mod -> Word
transOper Mod
m
    ]

parseGen :: Parser Generator
parseGen :: Parser Generator
parseGen = [Parser Generator] -> Parser Generator
forall a. [Parser a] -> Parser a
choice [
    Int16 -> Parser Int16
int16le  Int16
0 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
StartAddressOffset (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le  Int16
1 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
EndAddressOffset (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le  Int16
2 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
LoopStartAddressOffset (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le  Int16
3 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
LoopEndAddressOffset (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le  Int16
4 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
StartAddressCoarseOffset (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le  Int16
5 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
ModLfoToPitch (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le  Int16
6 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
VibLfoToPitch (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le  Int16
7 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
ModEnvToPitch (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral

  , Int16 -> Parser Int16
int16le  Int16
8 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
InitFc (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le  Int16
9 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
InitQ (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
10 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
ModLfoToFc (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
11 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
ModEnvToFc (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    
  , Int16 -> Parser Int16
int16le Int16
12 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
EndAddressCoarseOffset (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
13 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
ModLfoToVol (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    
  , Int16 -> Parser Int16
int16le Int16
15 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
Chorus (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
16 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
Reverb (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
17 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
Pan (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    
  , Int16 -> Parser Int16
int16le Int16
21 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
DelayModLfo (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
22 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
FreqModLfo (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    
  , Int16 -> Parser Int16
int16le Int16
23 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
DelayVibLfo (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
24 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
FreqVibLfo (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    
  , Int16 -> Parser Int16
int16le Int16
25 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
DelayModEnv (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
26 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
AttackModEnv (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
27 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
HoldModEnv (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
28 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
DecayModEnv (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
29 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
SustainModEnv (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
30 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
ReleaseModEnv (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
31 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
KeyToModEnvHold (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
32 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
KeyToModEnvDecay (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    
  , Int16 -> Parser Int16
int16le Int16
33 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
DelayVolEnv (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
34 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
AttackVolEnv (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
35 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
HoldVolEnv (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
36 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
DecayVolEnv (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
37 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
SustainVolEnv (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
38 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
ReleaseVolEnv (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
39 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
KeyToVolEnvHold (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
40 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
KeyToVolEnvDecay (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    
  , Int16 -> Parser Int16
int16le Int16
41 Parser Int16 -> Parser Word16 -> Parser Word16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Word16
getWord16le Parser Word16 -> (Word16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Word16 -> Generator) -> Word16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Generator
InstIndex (Word -> Generator) -> (Word16 -> Word) -> Word16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , do Int16
_ <- Int16 -> Parser Int16
int16le Int16
43; Word
a <- Parser Word8
getWord8 Parser Word8 -> (Word8 -> Parser Word) -> Parser Word
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word -> Parser Word
forall (m :: * -> *) a. Monad m => a -> m a
return (Word -> Parser Word) -> (Word8 -> Word) -> Word8 -> Parser Word
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral;
       Word
b <- Parser Word8
getWord8 Parser Word8 -> (Word8 -> Parser Word) -> Parser Word
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word -> Parser Word
forall (m :: * -> *) a. Monad m => a -> m a
return (Word -> Parser Word) -> (Word8 -> Word) -> Word8 -> Parser Word
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral; Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator) -> Generator -> Parser Generator
forall a b. (a -> b) -> a -> b
$ Word -> Word -> Generator
KeyRange Word
a Word
b;
  , do Int16
_ <- Int16 -> Parser Int16
int16le Int16
44; Word
a <- Parser Word8
getWord8 Parser Word8 -> (Word8 -> Parser Word) -> Parser Word
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word -> Parser Word
forall (m :: * -> *) a. Monad m => a -> m a
return (Word -> Parser Word) -> (Word8 -> Word) -> Word8 -> Parser Word
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral;
       Word
b <- Parser Word8
getWord8 Parser Word8 -> (Word8 -> Parser Word) -> Parser Word
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word -> Parser Word
forall (m :: * -> *) a. Monad m => a -> m a
return (Word -> Parser Word) -> (Word8 -> Word) -> Word8 -> Parser Word
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral; Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator) -> Generator -> Parser Generator
forall a b. (a -> b) -> a -> b
$ Word -> Word -> Generator
VelRange Word
a Word
b;
    
  , Int16 -> Parser Int16
int16le Int16
45 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
LoopStartAddressCoarseOffset (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
46 Parser Int16 -> Parser Word16 -> Parser Word16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Word16
getWord16le  Parser Word16 -> (Word16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Word16 -> Generator) -> Word16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Generator
Key (Word -> Generator) -> (Word16 -> Word) -> Word16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
47 Parser Int16 -> Parser Word16 -> Parser Word16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Word16
getWord16le  Parser Word16 -> (Word16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Word16 -> Generator) -> Word16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Generator
Vel (Word -> Generator) -> (Word16 -> Word) -> Word16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
48 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
InitAtten (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
50 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
LoopEndAddressCoarseOffset (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    
  , Int16 -> Parser Int16
int16le Int16
51 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
CoarseTune (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
52 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
FineTune (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
53 Parser Int16 -> Parser Word16 -> Parser Word16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Word16
getWord16le Parser Word16 -> (Word16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Word16 -> Generator) -> Word16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Generator
SampleIndex (Word -> Generator) -> (Word16 -> Word) -> Word16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , do Int16
_ <- Int16 -> Parser Int16
int16le  Int16
54;  Int16
a <- Parser Int16
getInt16le;
       case Int16
a of
         Int16
1 -> Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator) -> Generator -> Parser Generator
forall a b. (a -> b) -> a -> b
$ SampleMode -> Generator
SampleMode SampleMode
Audio.ContLoop
         Int16
3 -> Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator) -> Generator -> Parser Generator
forall a b. (a -> b) -> a -> b
$ SampleMode -> Generator
SampleMode SampleMode
Audio.PressLoop
         Int16
_ -> Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator) -> Generator -> Parser Generator
forall a b. (a -> b) -> a -> b
$ SampleMode -> Generator
SampleMode SampleMode
Audio.NoLoop
  , Int16 -> Parser Int16
int16le Int16
56 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
ScaleTuning (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , Int16 -> Parser Int16
int16le Int16
57 Parser Int16 -> Parser Int16 -> Parser Int16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Int16 -> Generator) -> Int16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Generator
ExclusiveClass (Int -> Generator) -> (Int16 -> Int) -> Int16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
    
  , Int16 -> Parser Int16
int16le Int16
58 Parser Int16 -> Parser Word16 -> Parser Word16
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Word16
getWord16le  Parser Word16 -> (Word16 -> Parser Generator) -> Parser Generator
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator)
-> (Word16 -> Generator) -> Word16 -> Parser Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Generator
RootKey (Word -> Generator) -> (Word16 -> Word) -> Word16 -> Generator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  , do Int16
p1 <- Parser Int16
getInt16le; Int16
p2 <- Parser Int16
getInt16le;
       Generator -> Parser Generator
forall (m :: * -> *) a. Monad m => a -> m a
return (Generator -> Parser Generator) -> Generator -> Parser Generator
forall a b. (a -> b) -> a -> b
$ Int -> Int -> Generator
ReservedGen (Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int16
p1) (Int16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int16
p2)]


buildGen :: Generator -> Builder
buildGen :: Generator -> Builder
buildGen Generator
g = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat ([Builder] -> Builder) -> [Builder] -> Builder
forall a b. (a -> b) -> a -> b
$ case Generator
g of
  StartAddressOffset Int
i       -> [Int16 -> Builder
putInt16le Int16
0, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  EndAddressOffset Int
i         -> [Int16 -> Builder
putInt16le Int16
1, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  LoopStartAddressOffset Int
i   -> [Int16 -> Builder
putInt16le Int16
2, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  LoopEndAddressOffset Int
i     -> [Int16 -> Builder
putInt16le Int16
3, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  StartAddressCoarseOffset Int
i -> [Int16 -> Builder
putInt16le Int16
4, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  ModLfoToPitch Int
i            -> [Int16 -> Builder
putInt16le Int16
5, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  VibLfoToPitch Int
i            -> [Int16 -> Builder
putInt16le Int16
6, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  ModEnvToPitch Int
i            -> [Int16 -> Builder
putInt16le Int16
7, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]

  InitFc Int
i     -> [Int16 -> Builder
putInt16le Int16
8, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  InitQ Int
i      -> [Int16 -> Builder
putInt16le Int16
9, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  ModLfoToFc Int
i -> [Int16 -> Builder
putInt16le Int16
10, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  ModEnvToFc Int
i -> [Int16 -> Builder
putInt16le Int16
11, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
    
  EndAddressCoarseOffset Int
i     -> [Int16 -> Builder
putInt16le Int16
12, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  ModLfoToVol Int
i -> [Int16 -> Builder
putInt16le Int16
13, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
   
  Chorus Int
i -> [Int16 -> Builder
putInt16le Int16
15, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  Reverb Int
i -> [Int16 -> Builder
putInt16le Int16
16, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  Pan Int
i    -> [Int16 -> Builder
putInt16le Int16
17, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  
  DelayModLfo Int
i -> [Int16 -> Builder
putInt16le Int16
21, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  FreqModLfo  Int
i -> [Int16 -> Builder
putInt16le Int16
22, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
    
  DelayVibLfo Int
i -> [Int16 -> Builder
putInt16le Int16
23, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  FreqVibLfo Int
i  -> [Int16 -> Builder
putInt16le Int16
24, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
    
  DelayModEnv Int
i      -> [Int16 -> Builder
putInt16le Int16
25, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  AttackModEnv Int
i     -> [Int16 -> Builder
putInt16le Int16
26, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  HoldModEnv Int
i       -> [Int16 -> Builder
putInt16le Int16
27, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  DecayModEnv Int
i      -> [Int16 -> Builder
putInt16le Int16
28, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  SustainModEnv Int
i    -> [Int16 -> Builder
putInt16le Int16
29, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  ReleaseModEnv Int
i    -> [Int16 -> Builder
putInt16le Int16
30, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  KeyToModEnvHold Int
i  -> [Int16 -> Builder
putInt16le Int16
31, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  KeyToModEnvDecay Int
i -> [Int16 -> Builder
putInt16le Int16
32, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
    
  DelayVolEnv Int
i      -> [Int16 -> Builder
putInt16le Int16
33, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  AttackVolEnv Int
i     -> [Int16 -> Builder
putInt16le Int16
34, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  HoldVolEnv Int
i       -> [Int16 -> Builder
putInt16le Int16
35, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  DecayVolEnv Int
i      -> [Int16 -> Builder
putInt16le Int16
36, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  SustainVolEnv Int
i    -> [Int16 -> Builder
putInt16le Int16
37, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  ReleaseVolEnv Int
i    -> [Int16 -> Builder
putInt16le Int16
38, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  KeyToVolEnvHold Int
i  -> [Int16 -> Builder
putInt16le Int16
39, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  KeyToVolEnvDecay Int
i -> [Int16 -> Builder
putInt16le Int16
40, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
    
  InstIndex Word
i  -> [Int16 -> Builder
putInt16le Int16
41, Word16 -> Builder
putWord16le (Word16 -> Builder) -> Word16 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
i]
  KeyRange Word
a Word
b -> [Int16 -> Builder
putInt16le Int16
43, Word8 -> Builder
putWord8 (Word8 -> Builder) -> Word8 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
a, Word8 -> Builder
putWord8 (Word8 -> Builder) -> Word8 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
b]
  VelRange Word
a Word
b -> [Int16 -> Builder
putInt16le Int16
44, Word8 -> Builder
putWord8 (Word8 -> Builder) -> Word8 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
a, Word8 -> Builder
putWord8 (Word8 -> Builder) -> Word8 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
b]

  LoopStartAddressCoarseOffset Int
i  -> [Int16 -> Builder
putInt16le Int16
45, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  Key Word
i                           -> [Word16 -> Builder
putWord16le Word16
46, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
i]
  Vel Word
i                           -> [Word16 -> Builder
putWord16le Word16
47, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
i]
  InitAtten Int
i                     -> [Int16 -> Builder
putInt16le Int16
48, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  LoopEndAddressCoarseOffset Int
i    -> [Int16 -> Builder
putInt16le Int16
50, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
    
  CoarseTune Int
i  -> [Int16 -> Builder
putInt16le Int16
51, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  FineTune Int
i    -> [Int16 -> Builder
putInt16le Int16
52, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  SampleIndex Word
i -> [Int16 -> Builder
putInt16le Int16
53, Word16 -> Builder
putWord16le (Word16 -> Builder) -> Word16 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
i]
  
  SampleMode SampleMode
Audio.ContLoop  -> [Int16 -> Builder
putInt16le Int16
54, Int16 -> Builder
putInt16le Int16
1]
  SampleMode SampleMode
Audio.PressLoop -> [Int16 -> Builder
putInt16le Int16
54, Int16 -> Builder
putInt16le Int16
3]
  SampleMode SampleMode
Audio.NoLoop    -> [Int16 -> Builder
putInt16le Int16
54, Int16 -> Builder
putInt16le Int16
2]
  --56

  ScaleTuning Int
i -> [Int16 -> Builder
putInt16le Int16
56, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
  ExclusiveClass Int
i -> [Int16 -> Builder
putInt16le Int16
57, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i]
    
  RootKey Word
i -> [Int16 -> Builder
putInt16le Int16
58, Word16 -> Builder
putWord16le (Word16 -> Builder) -> Word16 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
i]
  ReservedGen Int
i1 Int
i2 ->  [Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i1, Int16 -> Builder
putInt16le (Int16 -> Builder) -> Int16 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i2]

parseInst :: Parser Inst  
parseInst :: Parser Inst
parseInst = do
  String
instName' <- Int64 -> Parser ByteString
getLazyByteString Int64
20
               Parser ByteString -> (ByteString -> Parser String) -> Parser String
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> Parser String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Parser String)
-> (ByteString -> String) -> ByteString -> Parser String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word8 -> Char) -> [Word8] -> String
forall a b. (a -> b) -> [a] -> [b]
map Word8 -> Char
w2c ([Word8] -> String)
-> (ByteString -> [Word8]) -> ByteString -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [Word8]
L.unpack (ByteString -> [Word8])
-> (ByteString -> ByteString) -> ByteString -> [Word8]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word8 -> Bool) -> ByteString -> ByteString
L.takeWhile ( Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word8
0)
  Word
instBagNdx' <- Parser Word16
getWord16le Parser Word16 -> (Word16 -> Parser Word) -> Parser Word
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word -> Parser Word
forall (m :: * -> *) a. Monad m => a -> m a
return (Word -> Parser Word) -> (Word16 -> Word) -> Word16 -> Parser Word
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral
  Inst -> Parser Inst
forall (m :: * -> *) a. Monad m => a -> m a
return (Inst -> Parser Inst) -> Inst -> Parser Inst
forall a b. (a -> b) -> a -> b
$ Inst :: String -> Word -> Inst
Inst {
      instName :: String
instName = String
instName'
    , instBagNdx :: Word
instBagNdx = Word
instBagNdx'}

buildInst :: Inst -> Builder  
buildInst :: Inst -> Builder
buildInst Inst
i = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [
      String -> Builder
putString (String -> Builder) -> String -> Builder
forall a b. (a -> b) -> a -> b
$ Inst -> String
instName Inst
i
    , [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat ([Builder] -> Builder) -> [Builder] -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Builder -> [Builder]
forall a. Int -> a -> [a]
replicate (Int
20 Int -> Int -> Int
forall a. Num a => a -> a -> a
- String -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (Inst -> String
instName Inst
i)) (Word8 -> Builder
putWord8 Word8
0) 
    , Word16 -> Builder
putWord16le (Word16 -> Builder) -> Word16 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word16) -> Word -> Word16
forall a b. (a -> b) -> a -> b
$ Inst -> Word
instBagNdx Inst
i]

parseShdr :: Parser Shdr  
parseShdr :: Parser Shdr
parseShdr = do
  String
sampleName' <- Int64 -> Parser ByteString
getLazyByteString Int64
20
                 Parser ByteString -> (ByteString -> Parser String) -> Parser String
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> Parser String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Parser String)
-> (ByteString -> String) -> ByteString -> Parser String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word8 -> Char) -> [Word8] -> String
forall a b. (a -> b) -> [a] -> [b]
map Word8 -> Char
w2c ([Word8] -> String)
-> (ByteString -> [Word8]) -> ByteString -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [Word8]
L.unpack (ByteString -> [Word8])
-> (ByteString -> ByteString) -> ByteString -> [Word8]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word8 -> Bool) -> ByteString -> ByteString
L.takeWhile ( Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word8
0)
  Word32
start' <- Parser Word32
getWord32le
  Word32
end' <- Parser Word32
getWord32le
  Word32
startLoop' <- Parser Word32
getWord32le
  Word32
endLoop' <- Parser Word32
getWord32le  
  Word32
sampleRate' <- Parser Word32
getWord32le
  Word8
originalPitch' <- Parser Word8
getWord8
  Int8
pitchCorrection' <- Parser Int8
getInt8
  Word16
sampleLink' <- Parser Word16
getWord16le
  Word16
sampleType' <- Parser Word16
getWord16le
  Shdr -> Parser Shdr
forall (m :: * -> *) a. Monad m => a -> m a
return (Shdr -> Parser Shdr) -> Shdr -> Parser Shdr
forall a b. (a -> b) -> a -> b
$ Shdr :: String
-> Word
-> Word
-> Word
-> Word
-> Word
-> Word
-> Int
-> Word
-> Word
-> Shdr
Shdr {
      sampleName :: String
sampleName = String
sampleName'
    , start :: Word
start = Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
start'
    , end :: Word
end = Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
end'
    , startLoop :: Word
startLoop = Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
startLoop'
    , endLoop :: Word
endLoop = Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
endLoop'
    , sampleRate :: Word
sampleRate = Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
sampleRate'
    , originalPitch :: Word
originalPitch = Word8 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
originalPitch'
    , pitchCorrection :: Int
pitchCorrection = Int8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int8
pitchCorrection'
    , sampleLink :: Word
sampleLink = Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
sampleLink'
    , sampleType :: Word
sampleType = Word16 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
sampleType'
    }

buildShdr :: Shdr -> Builder  
buildShdr :: Shdr -> Builder
buildShdr Shdr
shdr = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat [
      String -> Builder
putString (String -> Builder) -> String -> Builder
forall a b. (a -> b) -> a -> b
$ Shdr -> String
sampleName Shdr
shdr
    , [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat ([Builder] -> Builder) -> [Builder] -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Builder -> [Builder]
forall a. Int -> a -> [a]
replicate (Int
20 Int -> Int -> Int
forall a. Num a => a -> a -> a
- String -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (Shdr -> String
sampleName Shdr
shdr)) (Word8 -> Builder
putWord8 Word8
0) 
    , Word32 -> Builder
putWord32le (Word32 -> Builder) -> Word32 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word32) -> Word -> Word32
forall a b. (a -> b) -> a -> b
$ Shdr -> Word
start Shdr
shdr
    , Word32 -> Builder
putWord32le (Word32 -> Builder) -> Word32 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word32) -> Word -> Word32
forall a b. (a -> b) -> a -> b
$ Shdr -> Word
end Shdr
shdr    
    , Word32 -> Builder
putWord32le (Word32 -> Builder) -> Word32 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word32) -> Word -> Word32
forall a b. (a -> b) -> a -> b
$ Shdr -> Word
startLoop Shdr
shdr
    , Word32 -> Builder
putWord32le (Word32 -> Builder) -> Word32 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word32) -> Word -> Word32
forall a b. (a -> b) -> a -> b
$ Shdr -> Word
endLoop Shdr
shdr
    , Word32 -> Builder
putWord32le (Word32 -> Builder) -> Word32 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word32) -> Word -> Word32
forall a b. (a -> b) -> a -> b
$ Shdr -> Word
sampleRate Shdr
shdr
    , Word8 -> Builder
putWord8    (Word8 -> Builder) -> Word8 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word8) -> Word -> Word8
forall a b. (a -> b) -> a -> b
$ Shdr -> Word
originalPitch Shdr
shdr
    , Int8 -> Builder
putInt8     (Int8 -> Builder) -> Int8 -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Int8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int8) -> Int -> Int8
forall a b. (a -> b) -> a -> b
$ Shdr -> Int
pitchCorrection Shdr
shdr    
    , Word16 -> Builder
putWord16le (Word16 -> Builder) -> Word16 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word16) -> Word -> Word16
forall a b. (a -> b) -> a -> b
$ Shdr -> Word
sampleLink Shdr
shdr
    , Word16 -> Builder
putWord16le (Word16 -> Builder) -> Word16 -> Builder
forall a b. (a -> b) -> a -> b
$ Word -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Word16) -> Word -> Word16
forall a b. (a -> b) -> a -> b
$ Shdr -> Word
sampleType Shdr
shdr
    ]