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

-- |

-- 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
$c== :: SoundFont -> SoundFont -> Bool
== :: SoundFont -> SoundFont -> Bool
$c/= :: SoundFont -> SoundFont -> Bool
/= :: 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
$cshowsPrec :: Int -> SoundFont -> ShowS
showsPrec :: Int -> SoundFont -> ShowS
$cshow :: SoundFont -> String
show :: SoundFont -> String
$cshowList :: [SoundFont] -> ShowS
showList :: [SoundFont] -> ShowS
Show)

instance Arbitrary SoundFont where
  arbitrary :: Gen SoundFont
arbitrary = do
    f1 <- Gen (Array Word Info)
forall a. Arbitrary a => Gen a
arbitrary; f2 <- arbitrary; f3 <- arbitrary;
    return $! SoundFont f1 f2 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
$c== :: Info -> Info -> Bool
== :: Info -> Info -> Bool
$c/= :: Info -> Info -> Bool
/= :: 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
$cshowsPrec :: Int -> Info -> ShowS
showsPrec :: Int -> Info -> ShowS
$cshow :: Info -> String
show :: Info -> String
$cshowList :: [Info] -> ShowS
showList :: [Info] -> ShowS
Show)

instance Arbitrary Info where
  arbitrary :: Gen Info
arbitrary = [Gen Info] -> Gen Info
forall a. HasCallStack => [Gen a] -> Gen a
oneof [
      do 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)
         w2 <- choose (minBound :: Word16, maxBound)
         return $ Version (fromIntegral w1) (fromIntegral w2);
    , do l <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
255); s <- genStringNul l; return  $ TargetSoundEngine s
    , do l <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
255); s <- genStringNul l; return  $ BankName s
    , do l <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
255); s <- genStringNul l; return  $ RomName s
    , do 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)
         w2 <- choose (minBound :: Word16, maxBound)
         return $ RomVersion (fromIntegral w1) (fromIntegral w2)
    , do l <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
255); s <- genStringNul l; return  $ CreationDate s
    , do l <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
255); s <- genStringNul l; return  $ Authors s
    , do l <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
255); s <- genStringNul l; return  $ IntendedProduct s
    , do l <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
255); s <- genStringNul l; return  $ CopyrightMessage s    
    , do l <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
255); s <- genStringNul l; return  $ Comments s
    , do l <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
255); s <- genStringNul l; return  $ UsedTools s
    , do l <- (Word, Word) -> Gen Word
forall a. Random a => (a, a) -> Gen a
choose (Word
0,Word
255); s <- vector (fromIntegral l);
         return  $ ReservedInfo "RSRV" l (L.pack 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)
forall (m :: * -> *) a. Monad m => [m a] -> m [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 a b. (a -> b) -> Gen a -> Gen b
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
$c== :: Sdta -> Sdta -> Bool
== :: Sdta -> Sdta -> Bool
$c/= :: Sdta -> Sdta -> Bool
/= :: 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
$cshowsPrec :: Int -> Sdta -> ShowS
showsPrec :: Int -> Sdta -> ShowS
$cshow :: Sdta -> String
show :: Sdta -> String
$cshowList :: [Sdta] -> ShowS
showList :: [Sdta] -> ShowS
Show)

instance Arbitrary Sdta where
  arbitrary :: Gen Sdta
arbitrary = do
    sn <- (Word, Word) -> Gen Word
forall a. Random a => (a, a) -> Gen a
choose (Word
1,Word
1024)
    smpl1 <- arrayGen sn
    oneof [
        return $! Sdta smpl1 Nothing
      , do sm24' <- arrayGen sn
           return $! Sdta smpl1 (Just 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
$c== :: Pdta -> Pdta -> Bool
== :: Pdta -> Pdta -> Bool
$c/= :: Pdta -> Pdta -> Bool
/= :: 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
$cshowsPrec :: Int -> Pdta -> ShowS
showsPrec :: Int -> Pdta -> ShowS
$cshow :: Pdta -> String
show :: Pdta -> String
$cshowList :: [Pdta] -> ShowS
showList :: [Pdta] -> ShowS
Show)
  
instance Arbitrary Pdta where
  arbitrary :: Gen Pdta
arbitrary = do
    f1 <- Gen (Array Word Phdr)
forall a. Arbitrary a => Gen a
arbitrary; f2 <- arbitrary; f3 <- arbitrary; f4 <- arbitrary;
    f5 <- arbitrary; f6 <- arbitrary; f7 <- arbitrary; f8 <- arbitrary;
    f9 <- arbitrary;
    return $! Pdta f1 f2 f3 f4 f5 f6 f7 f8 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
$c== :: Phdr -> Phdr -> Bool
== :: Phdr -> Phdr -> Bool
$c/= :: Phdr -> Phdr -> Bool
/= :: 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
$cshowsPrec :: Int -> Phdr -> ShowS
showsPrec :: Int -> Phdr -> ShowS
$cshow :: Phdr -> String
show :: Phdr -> String
$cshowList :: [Phdr] -> ShowS
showList :: [Phdr] -> ShowS
Show)

instance Arbitrary Phdr where
  arbitrary :: Gen Phdr
arbitrary = do
    n <- (Word, Word) -> Gen Word
forall a. Random a => (a, a) -> Gen a
choose (Word
0,Word
20)
    presetName' <- stringNulGen n
    preset' <- choose (minBound :: Word16, maxBound)
    bank' <- choose (minBound :: Word16, maxBound)
    presetBagNdx' <- choose (minBound :: Word16, maxBound)
    library' <- choose (minBound :: Word32, maxBound)
    genre' <- choose (minBound :: Word32, maxBound)
    morphology' <- choose (minBound :: Word32, maxBound)
    return $ Phdr {
        presetName = presetName'
      , preset = fromIntegral $ preset'
      , bank = fromIntegral $ bank'
      , presetBagNdx = fromIntegral $ presetBagNdx'
      , library = fromIntegral $ library'
      , genre = fromIntegral $ genre'
      , morphology = fromIntegral $ 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
$c== :: Bag -> Bag -> Bool
== :: Bag -> Bag -> Bool
$c/= :: Bag -> Bag -> Bool
/= :: 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
$cshowsPrec :: Int -> Bag -> ShowS
showsPrec :: Int -> Bag -> ShowS
$cshow :: Bag -> String
show :: Bag -> String
$cshowList :: [Bag] -> ShowS
showList :: [Bag] -> ShowS
Show)
  
instance Arbitrary Bag where
  arbitrary :: Gen Bag
arbitrary = do
    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)
    modNdx' <- choose (minBound :: Word16, maxBound)    
    return $! Bag {
        genNdx = fromIntegral genNdx'
      , modNdx = fromIntegral 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
$c== :: Mod -> Mod -> Bool
== :: Mod -> Mod -> Bool
$c/= :: Mod -> Mod -> Bool
/= :: 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
$cshowsPrec :: Int -> Mod -> ShowS
showsPrec :: Int -> Mod -> ShowS
$cshow :: Mod -> String
show :: Mod -> String
$cshowList :: [Mod] -> ShowS
showList :: [Mod] -> ShowS
Show)
  
instance Arbitrary Mod where
  arbitrary :: Gen Mod
arbitrary = do
    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)
    destOper' <- choose (minBound :: Word16, maxBound)    
    amount' <- choose (minBound :: Int16, maxBound)
    amtSrcOper' <- choose (minBound :: Word16, maxBound)    
    transOper' <- choose (minBound :: Word16, maxBound)                
    return $! Mod {
        srcOper = fromIntegral srcOper'
      , destOper = fromIntegral destOper'
      , amount = fromIntegral amount'
      , amtSrcOper = fromIntegral amtSrcOper'
      , transOper = fromIntegral 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
$c== :: Generator -> Generator -> Bool
== :: Generator -> Generator -> Bool
$c/= :: Generator -> Generator -> Bool
/= :: 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
$cshowsPrec :: Int -> Generator -> ShowS
showsPrec :: Int -> Generator -> ShowS
$cshow :: Generator -> String
show :: Generator -> String
$cshowList :: [Generator] -> ShowS
showList :: [Generator] -> ShowS
Show)

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

instance Arbitrary Inst where
  arbitrary :: Gen Inst
arbitrary = do
    n <- (Word, Word) -> Gen Word
forall a. Random a => (a, a) -> Gen a
choose (Word
0,Word
20)
    instName' <- stringNulGen n
    instBagNdx' <- choose (maxBound :: Word16, minBound)
    return $! Inst {
        instName = instName'
      , instBagNdx = fromIntegral $ 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
$c== :: Shdr -> Shdr -> Bool
== :: Shdr -> Shdr -> Bool
$c/= :: Shdr -> Shdr -> Bool
/= :: 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
$cshowsPrec :: Int -> Shdr -> ShowS
showsPrec :: Int -> Shdr -> ShowS
$cshow :: Shdr -> String
show :: Shdr -> String
$cshowList :: [Shdr] -> ShowS
showList :: [Shdr] -> ShowS
Show)

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

---- SoundFont import


importFile :: FilePath -> IO (Either String SoundFont)
importFile :: String -> IO (Either String SoundFont)
importFile String
n = do
  bs <- String -> IO ByteString
L.readFile String
n
  return $! runParser parseSoundFont 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 -> Parser String
string String
"RIFF"
  _ <- getWord32le -- chunkSize

  _ <- string "sfbk"
  infos' <- parseInfos
  sdta' <- parseSdta
  pdta' <- parsePdta
  return $! SoundFont {
      infos = infos'
    , sdta = sdta'
    , 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 -> Parser String
string String
"LIST"
  _ <- getWord32le -- chunkSize

  _ <- string "INFO"
  infos' <- many p
  return $! listArray (0, genericLength infos' - 1) infos'
  where
  p :: Parser Info
p = [Parser Info] -> Parser Info
forall a. [Parser a] -> Parser a
choice [
      do n <- Int -> Parser String
getString Int
4; _ <- word32le 4; w1 <- getWord16le; w2 <- getWord16le;
         case n of
           String
"ifil" -> Info -> Parser Info
forall a. a -> Parser a
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 a. a -> Parser a
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 a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail []
    , do n <- Int -> Parser String
getString Int
4; l <- expect (<= 256) getWord32le; s <- getStringNul;  
         skip (fromIntegral l - genericLength s - 1);
         case n of
           String
"isng" -> Info -> Parser Info
forall a. a -> Parser a
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 a. a -> Parser a
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 a. a -> Parser a
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 a. a -> Parser a
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 a. a -> Parser a
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 a. a -> Parser a
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 a. a -> Parser a
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 a. a -> Parser a
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 a. a -> Parser a
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 a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail []
    , do 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)
         l <- getWord32le 
         bs <- getLazyByteString (fromIntegral l)
         return $! ReservedInfo n (fromIntegral l) 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 a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length String
s
  
parseSdta :: Parser Sdta
parseSdta :: Parser Sdta
parseSdta = do
  _ <- String -> Parser String
string String
"LIST"
  sdtaSize <- getWord32le >>= return .fromIntegral
  _ <- string "sdta"
  _ <- string "smpl"
  smplSize <- getWord32le  >>= return .fromIntegral
  when (odd smplSize) $ fail "'smplSize' must not be odd number"
  let sn = Int -> Int -> Int
forall a. Integral a => a -> a -> a
div Int
smplSize Int
2
  smpl' <- Audio.parseSampleData sn getInt16le
  choice [
      do guard (smplSize == (sdtaSize - 12))
         return $! Sdta {smpl = smpl', sm24 =  Nothing}
    , do _ <- string "sm24"
         let 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 
         _ <- word32le (fromIntegral sm24Size)
         sm24' <- Audio.parseSampleData sn getInt8
         skip (fromIntegral $ sm24Size - sn)
         return $! Sdta{ smpl = smpl', sm24 = Just 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 -> Parser String
string String
"LIST"
  _ <- getWord32le -- pdtaSize

  _ <- string "pdta"
  phdrs' <- parseSubchunk "phdr" 38 parsePhdr
  pbags' <- parseSubchunk "pbag" 4 parseBag
  pmods' <- parseSubchunk "pmod" 10 parseMod
  pgens' <- parseSubchunk "pgen" 4  parseGen
  insts' <- parseSubchunk "inst" 22  parseInst  
  ibags' <- parseSubchunk "ibag" 4 parseBag
  imods' <- parseSubchunk "imod" 10 parseMod
  igens' <- parseSubchunk "igen" 4  parseGen
  shdrs' <- parseSubchunk "shdr" 46 parseShdr
  return $! Pdta phdrs' pbags' pmods' pgens' insts' ibags' imods' igens' 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 :: forall a. String -> Word -> Parser a -> Parser (Array Word a)
parseSubchunk String
s Word
size Parser a
p = do
  _ <- String -> Parser String
string String
s
  chunkSize <- 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) (getWord32le >>= return . fromIntegral)
  let n = Word -> Word -> Word
forall a. Integral a => a -> a -> a
div Word
chunkSize Word
size
  cs <- sequence (genericReplicate n p)
  return $! listArray (0, n - 1) cs

buildSubchunk :: String -> Word -> (a -> Builder) -> (Array Word a) ->  Builder
buildSubchunk :: forall a.
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 i. Ix i => Array i a -> (i, i)
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
  presetName' <- Int64 -> Parser ByteString
getLazyByteString Int64
20
                 Parser ByteString -> (ByteString -> Parser String) -> Parser String
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> Parser String
forall a. a -> Parser a
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)
  preset' <- getWord16le >>= return . fromIntegral
  bank' <- getWord16le >>= return . fromIntegral
  presetBagNdx' <- getWord16le >>= return . fromIntegral
  library' <- getWord32le >>= return . fromIntegral
  genre' <- getWord32le >>= return . fromIntegral
  morphology' <- getWord32le >>= return . fromIntegral
  return $ Phdr {
      presetName = presetName'
    , preset = preset'
    , bank = bank'
    , presetBagNdx = presetBagNdx'
    , library = library'
    , genre = genre'
    , morphology = 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 a. [a] -> 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
    genNdx' <- Parser Word16
getWord16le
    modNdx' <- getWord16le
    return $! Bag {
        genNdx = fromIntegral genNdx'
      , modNdx = fromIntegral 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
    srcOper' <- Parser Word16
getWord16le
    destOper' <- getWord16le
    amount' <- getInt16le
    amtSrcOper' <- getWord16le
    transOper' <- getWord16le
    return $! Mod {
        srcOper = fromIntegral srcOper'
      , destOper = fromIntegral destOper'
      , amount = fromIntegral amount'
      , amtSrcOper = fromIntegral amtSrcOper'
      , transOper = fromIntegral 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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Word16
getWord16le Parser Word16 -> (Word16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 -> Parser Int16
int16le Int16
43; a <- getWord8 >>= return . fromIntegral;
       b <- getWord8 >>= return . fromIntegral; return $ KeyRange a b;
  , do _ <- Int16 -> Parser Int16
int16le Int16
44; a <- getWord8 >>= return . fromIntegral;
       b <- getWord8 >>= return . fromIntegral; return $ VelRange a b;
    
  , Int16 -> Parser Int16
int16le Int16
45 Parser Int16 -> Parser Int16 -> Parser Int16
forall a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Word16
getWord16le  Parser Word16 -> (Word16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Word16
getWord16le  Parser Word16 -> (Word16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Word16
getWord16le Parser Word16 -> (Word16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 -> Parser Int16
int16le  Int16
54;  a <- getInt16le;
       case a of
         Int16
1 -> Generator -> Parser Generator
forall a. a -> Parser a
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 a. a -> Parser a
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 a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Int16
getInt16le  Parser Int16 -> (Int16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 a b. Parser a -> Parser b -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parser Word16
getWord16le  Parser Word16 -> (Word16 -> Parser Generator) -> Parser Generator
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Generator -> Parser Generator
forall a. a -> Parser a
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 p1 <- Parser Int16
getInt16le; p2 <- getInt16le;
       return $ ReservedGen (fromIntegral p1) (fromIntegral 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
  instName' <- Int64 -> Parser ByteString
getLazyByteString Int64
20
               Parser ByteString -> (ByteString -> Parser String) -> Parser String
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> Parser String
forall a. a -> Parser a
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)
  instBagNdx' <- getWord16le >>= return . fromIntegral
  return $ Inst {
      instName = instName'
    , instBagNdx = 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 a. [a] -> 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
  sampleName' <- Int64 -> Parser ByteString
getLazyByteString Int64
20
                 Parser ByteString -> (ByteString -> Parser String) -> Parser String
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> Parser String
forall a. a -> Parser a
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)
  start' <- getWord32le
  end' <- getWord32le
  startLoop' <- getWord32le
  endLoop' <- getWord32le  
  sampleRate' <- getWord32le
  originalPitch' <- getWord8
  pitchCorrection' <- getInt8
  sampleLink' <- getWord16le
  sampleType' <- getWord16le
  return $ Shdr {
      sampleName = sampleName'
    , start = fromIntegral start'
    , end = fromIntegral end'
    , startLoop = fromIntegral startLoop'
    , endLoop = fromIntegral endLoop'
    , sampleRate = fromIntegral sampleRate'
    , originalPitch = fromIntegral originalPitch'
    , pitchCorrection = fromIntegral pitchCorrection'
    , sampleLink = fromIntegral sampleLink'
    , sampleType = fromIntegral 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 a. [a] -> 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
    ]