module Sound.Frame
   (C(..),
   numberOfChannelsFoldable,
   sizeOfElementFoldable,
   sizeOfElementType,
   paddedSizeOf,
   withSignal,
   ) where

import Data.Word (Word8, Word16, Word32, )
import Data.Int (Int8, Int16, Int32, )
import Foreign.Storable (Storable, sizeOf, alignment, )

import qualified Data.Foldable as Fold


{- |
This is a class for nested tuples used as sample frames.

Should we make Storable a superclass of 'C'?
-}
class C y where
   {- | The argument is not touched and can be undefined -}
   numberOfChannels :: y -> Int
   {- |
   Size of elements.
   In a nested record type, like @Stereo (Stereo a)@,
   it is the size of the atomic element, in our example @a@.
   We assume that the atomic element values all have the same size,
   such that @sizeOfElement undefined@ is defined.
   -}
   sizeOfElement :: y -> Int

{- |
Default implementations for a foldable Frame.
-}
numberOfChannelsFoldable ::
   (C y, Fold.Foldable f) => f y -> Int
numberOfChannelsFoldable :: forall y (f :: * -> *). (C y, Foldable f) => f y -> Int
numberOfChannelsFoldable =
   forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
Fold.foldl' (\Int
n y
y -> Int
n forall a. Num a => a -> a -> a
+ forall y. C y => y -> Int
numberOfChannels y
y) Int
0
--   Fold.sum . fmap numberOfChannels

sizeOfElementFoldable ::
   (C y, Fold.Foldable f) => f y -> Int
sizeOfElementFoldable :: forall y (f :: * -> *). (C y, Foldable f) => f y -> Int
sizeOfElementFoldable =
   forall y. C y => y -> Int
sizeOfElement forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> a
head forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> [a]
Fold.toList

{- |
Returns the size of an undefined element.
This might be more efficient than 'sizeOfElementFoldable'.
-}
sizeOfElementType ::
   (C y) => f y -> Int
sizeOfElementType :: forall y (f :: * -> *). C y => f y -> Int
sizeOfElementType =
   forall y. C y => y -> Int
sizeOfElement forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. f a -> a
elementType


{-# INLINE elementType #-}
elementType :: f a -> a
elementType :: forall (f :: * -> *) a. f a -> a
elementType f a
_ =
   forall a. HasCallStack => [Char] -> a
error [Char]
"Sound.Frame.sizeOfElement may not depend on element values"


instance C Word8 where
   numberOfChannels :: Word8 -> Int
numberOfChannels Word8
_ = Int
1
   sizeOfElement :: Word8 -> Int
sizeOfElement = forall a. Storable a => a -> Int
sizeOf

instance C Int8 where
   numberOfChannels :: Int8 -> Int
numberOfChannels Int8
_ = Int
1
   sizeOfElement :: Int8 -> Int
sizeOfElement = forall a. Storable a => a -> Int
sizeOf

instance C Word16 where
   numberOfChannels :: Word16 -> Int
numberOfChannels Word16
_ = Int
1
   sizeOfElement :: Word16 -> Int
sizeOfElement = forall a. Storable a => a -> Int
sizeOf

instance C Int16 where
   numberOfChannels :: Int16 -> Int
numberOfChannels Int16
_ = Int
1
   sizeOfElement :: Int16 -> Int
sizeOfElement = forall a. Storable a => a -> Int
sizeOf

instance C Word32 where
   numberOfChannels :: Word32 -> Int
numberOfChannels Word32
_ = Int
1
   sizeOfElement :: Word32 -> Int
sizeOfElement = forall a. Storable a => a -> Int
sizeOf

instance C Int32 where
   numberOfChannels :: Int32 -> Int
numberOfChannels Int32
_ = Int
1
   sizeOfElement :: Int32 -> Int
sizeOfElement = forall a. Storable a => a -> Int
sizeOf

instance C Float where
   numberOfChannels :: Float -> Int
numberOfChannels Float
_ = Int
1
   sizeOfElement :: Float -> Int
sizeOfElement = forall a. Storable a => a -> Int
sizeOf

instance C Double where
   numberOfChannels :: Double -> Int
numberOfChannels Double
_ = Int
1
   sizeOfElement :: Double -> Int
sizeOfElement = forall a. Storable a => a -> Int
sizeOf


{- |
Space that an element consumes in a Storable Array.
This is space for the element plus padding.
-}
-- cf. storable-record:FixedArray.roundUp
paddedSizeOf :: Storable a => a -> Int
paddedSizeOf :: forall a. Storable a => a -> Int
paddedSizeOf a
x =
   forall a. Storable a => a -> Int
sizeOf a
x forall a. Num a => a -> a -> a
+ forall a. Integral a => a -> a -> a
mod (- forall a. Storable a => a -> Int
sizeOf a
x) (forall a. Storable a => a -> Int
alignment a
x)


withSignal :: (y -> a) -> (sig y -> a)
withSignal :: forall y a (sig :: * -> *). (y -> a) -> sig y -> a
withSignal y -> a
f sig y
_ = y -> a
f (forall a. HasCallStack => [Char] -> a
error [Char]
"Frame: dummy signal parameter touched")