-----------------------------------------------------------------------------
-- |
-- Module      :  Graphics.UI.SDL.Mixer.Channels
-- Copyright   :  (c) David Himmelstrup 2005
-- License     :  BSD-like
--
-- Maintainer  :  lemmih@gmail.com
-- Stability   :  provisional
-- Portability :  portable
--
-----------------------------------------------------------------------------
module Graphics.UI.SDL.Mixer.Channels
    ( allocateChannels
    , volume
    , tryPlayChannel
    , playChannel
    , tryFadeInChannel
    , fadeInChannel
    , tryFadeInChannelTimed
    , fadeInChannelTimed
    , pause
    , resume
    , haltChannel
    , expireChannel
    , fadeOutChannel
    , isChannelPlaying
    , numChannelsPlaying
    , isChannelPaused
    , numChannelsPaused
    , fadingChannel
    , getChunk
    ) where

import Foreign(Ptr, newForeignPtr_, toBool, withForeignPtr)

import Graphics.UI.SDL.Mixer.Types(Fading, Channel, Chunk, ChunkStruct)
import Graphics.UI.SDL.General(unwrapInt)

-- int Mix_AllocateChannels(int numchans)
foreign import ccall unsafe "Mix_AllocateChannels" allocateChannels :: Int -> IO Int

-- int Mix_Volume(int channel, int volume)
foreign import ccall unsafe "Mix_Volume" volume :: Int -> Int -> IO Int

tryPlayChannel :: Channel -> Chunk -> Int -> IO Int
tryPlayChannel :: Int -> Chunk -> Int -> IO Int
tryPlayChannel Int
channel Chunk
chunk Int
loops
    = Int -> Chunk -> Int -> Int -> IO Int
tryPlayChannelTimed Int
channel Chunk
chunk Int
loops (-Int
1)

playChannel :: Channel -> Chunk -> Int -> IO Int
playChannel :: Int -> Chunk -> Int -> IO Int
playChannel Int
channel Chunk
chunk Int
loops
    = Int -> Chunk -> Int -> Int -> IO Int
playChannelTimed Int
channel Chunk
chunk Int
loops (-Int
1)

-- int Mix_PlayChannelTimed(int channel, Mix_Chunk *chunk, int loops, int ticks)
foreign import ccall unsafe "Mix_PlayChannelTimed" mixPlayChannelTimed
    :: Int -> Ptr ChunkStruct -> Int -> Int -> IO Int
tryPlayChannelTimed :: Channel -> Chunk -> Int -> Int -> IO Int
tryPlayChannelTimed :: Int -> Chunk -> Int -> Int -> IO Int
tryPlayChannelTimed Int
channel Chunk
chunk Int
loops Int
ticks
    = Chunk -> (Ptr ChunkStruct -> IO Int) -> IO Int
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr Chunk
chunk ((Ptr ChunkStruct -> IO Int) -> IO Int)
-> (Ptr ChunkStruct -> IO Int) -> IO Int
forall a b. (a -> b) -> a -> b
$ \Ptr ChunkStruct
chunkPtr ->
      Int -> Ptr ChunkStruct -> Int -> Int -> IO Int
mixPlayChannelTimed Int
channel Ptr ChunkStruct
chunkPtr Int
loops Int
ticks

playChannelTimed :: Channel -> Chunk -> Int -> Int -> IO Int
playChannelTimed :: Int -> Chunk -> Int -> Int -> IO Int
playChannelTimed Int
channel Chunk
chunk Int
loops Int
ticks
    = (Int -> Bool) -> String -> IO Int -> IO Int
unwrapInt (Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/=(-Int
1)) String
"Mix_PlayChannelTimed"
                (Int -> Chunk -> Int -> Int -> IO Int
tryPlayChannelTimed Int
channel Chunk
chunk Int
loops Int
ticks)

tryFadeInChannel :: Channel -> Chunk -> Int -> Int -> IO Int
tryFadeInChannel :: Int -> Chunk -> Int -> Int -> IO Int
tryFadeInChannel Int
channel Chunk
chunk Int
loops Int
ms
    = Int -> Chunk -> Int -> Int -> Int -> IO Int
tryFadeInChannelTimed Int
channel Chunk
chunk Int
loops Int
ms (-Int
1)

fadeInChannel :: Channel -> Chunk -> Int -> Int -> IO Int
fadeInChannel :: Int -> Chunk -> Int -> Int -> IO Int
fadeInChannel Int
channel Chunk
chunk Int
loops Int
ms
    = Int -> Chunk -> Int -> Int -> Int -> IO Int
fadeInChannelTimed Int
channel Chunk
chunk Int
loops Int
ms (-Int
1)

-- int Mix_FadeInChannelTimed(int channel, Mix_Chunk *chunk, int loops, int ms, int ticks)
foreign import ccall unsafe "Mix_FadeInChannelTimed" mixFadeInChannelTimed
    :: Int -> Ptr ChunkStruct -> Int -> Int -> Int -> IO Int
tryFadeInChannelTimed :: Channel -> Chunk -> Int -> Int -> Int -> IO Int
tryFadeInChannelTimed :: Int -> Chunk -> Int -> Int -> Int -> IO Int
tryFadeInChannelTimed Int
channel Chunk
chunk Int
loops Int
ms Int
ticks
    = Chunk -> (Ptr ChunkStruct -> IO Int) -> IO Int
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr Chunk
chunk ((Ptr ChunkStruct -> IO Int) -> IO Int)
-> (Ptr ChunkStruct -> IO Int) -> IO Int
forall a b. (a -> b) -> a -> b
$ \Ptr ChunkStruct
chunkPtr ->
      Int -> Ptr ChunkStruct -> Int -> Int -> Int -> IO Int
mixFadeInChannelTimed Int
channel Ptr ChunkStruct
chunkPtr Int
loops Int
ms Int
ticks

fadeInChannelTimed :: Channel -> Chunk -> Int -> Int -> Int -> IO Int
fadeInChannelTimed :: Int -> Chunk -> Int -> Int -> Int -> IO Int
fadeInChannelTimed Int
channel Chunk
chunk Int
loops Int
ms Int
ticks
    = (Int -> Bool) -> String -> IO Int -> IO Int
unwrapInt (Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/=(-Int
1)) String
"Mix_FadeInChannelTimed"
                (Int -> Chunk -> Int -> Int -> Int -> IO Int
tryFadeInChannelTimed Int
channel Chunk
chunk Int
loops Int
ms Int
ticks)


-- void Mix_Pause(int channel)
foreign import ccall unsafe "Mix_Pause" pause :: Channel -> IO ()

-- void Mix_Resume(int channel)
foreign import ccall unsafe "Mix_Resume" resume :: Channel -> IO ()

-- int Mix_HaltChannel(int channel)
foreign import ccall unsafe "Mix_HaltChannel" mixHaltChannel :: Int -> IO Int
haltChannel :: Channel -> IO ()
haltChannel :: Int -> IO ()
haltChannel Int
channel = Int -> IO Int
mixHaltChannel Int
channel IO Int -> IO () -> IO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- int Mix_ExpireChannel(int channel, int ticks)
foreign import ccall unsafe "Mix_ExpireChannel" expireChannel :: Channel -> Int -> IO Int

-- int Mix_FadeOutChannel(int channel, int ms)
foreign import ccall unsafe "Mix_FadeOutChannel" fadeOutChannel :: Channel -> Int -> IO Int

-- int Mix_Playing(int channel)
foreign import ccall unsafe "Mix_Playing" mixPlaying :: Int -> IO Int

isChannelPlaying :: Channel -> IO Bool
isChannelPlaying :: Int -> IO Bool
isChannelPlaying = (Int -> Bool) -> IO Int -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> Bool
forall a. (Eq a, Num a) => a -> Bool
toBool (IO Int -> IO Bool) -> (Int -> IO Int) -> Int -> IO Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> IO Int
mixPlaying

numChannelsPlaying :: IO Int
numChannelsPlaying :: IO Int
numChannelsPlaying = Int -> IO Int
mixPlaying (-Int
1)

-- int Mix_Paused(int channel)
foreign import ccall unsafe "Mix_Paused" mixPaused :: Int -> IO Int

isChannelPaused :: Channel -> IO Bool
isChannelPaused :: Int -> IO Bool
isChannelPaused = (Int -> Bool) -> IO Int -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> Bool
forall a. (Eq a, Num a) => a -> Bool
toBool (IO Int -> IO Bool) -> (Int -> IO Int) -> Int -> IO Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> IO Int
mixPaused

numChannelsPaused :: IO Int
numChannelsPaused :: IO Int
numChannelsPaused = Int -> IO Int
mixPaused (-Int
1)

-- Mix_Fading Mix_FadingChannel(int which)
foreign import ccall unsafe "Mix_FadingChannel" mixFadingChannel :: Int -> IO Int
fadingChannel :: Channel -> IO Fading
fadingChannel :: Int -> IO Fading
fadingChannel = (Int -> Fading) -> IO Int -> IO Fading
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> Fading
forall a. Enum a => Int -> a
toEnum (IO Int -> IO Fading) -> (Int -> IO Int) -> Int -> IO Fading
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> IO Int
mixFadingChannel

-- Mix_Chunk *Mix_GetChunk(int channel)
foreign import ccall unsafe "Mix_GetChunk" mixGetChunk :: Int -> IO (Ptr ChunkStruct)
getChunk :: Channel -> IO Chunk
getChunk :: Int -> IO Chunk
getChunk Int
ch = Ptr ChunkStruct -> IO Chunk
forall a. Ptr a -> IO (ForeignPtr a)
newForeignPtr_ (Ptr ChunkStruct -> IO Chunk) -> IO (Ptr ChunkStruct) -> IO Chunk
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Int -> IO (Ptr ChunkStruct)
mixGetChunk Int
ch