Data.MediaBus.Basics.Ticks

This module contains the Ticks time unit as well as the corresponding known-at-compile-time StaticTicks time unit. The time stamps are given as quotient of a Rate that indicates the number of Ticks per second.

Documentation

newtype Rate

The known at ompile time, time unit in units per second.

Constructors

Hertz Nat

type Hz r = Hertz r

A more beautiful operator for Hertz

type OnePerPicoSecond = Hz 1000000000000

The maximum representable frequency is 10e12 1/s which corresponds to the resolution of NominalDiffTime, i.e. 1 pico second.

class KnownRate s where

Analogous to KnownNat this (kind-)class is for StaticTicks with a runtime Ticks value.

Minimal complete definition

rateVal

Associated Types

type RateVal s :: Nat

Return the compile time rate value in Hertz

Methods

rateVal :: proxy s -> Integer

Return the runtime rate value in Hertz

Instances

KnownNat r => KnownRate (Hertz r)

Associated Types

type RateVal (Hertz r :: Rate) :: Nat

Methods

rateVal :: proxy (Hertz r) -> Integer

class (KnownRate (GetRate i), SetRate i (GetRate i) ~ i) => HasRate i

Types with a known Rate, e.g. audio media has a sample rate.

Associated Types

type SetRate i (r :: Rate)

Set the static sample rate of the media

type GetRate i :: Rate

The static sample rate of the media

Instances

HasRate c => HasRate (Discontinous c)

Associated Types

type SetRate (Discontinous c) (r :: Rate) :: *

type GetRate (Discontinous c) :: Rate

HasRate c => HasRate (Segment d c)

Associated Types

type SetRate (Segment d c) (r :: Rate) :: *

type GetRate (Segment d c) :: Rate

KnownRate r => HasRate (Audio r c t)

Associated Types

type SetRate (Audio r c t) (r :: Rate) :: *

type GetRate (Audio r c t) :: Rate

class (HasRate i, GetRate i ~ ri, SetRate i rj ~ j, KnownRate rj) => CoerceRate i j ri rj where

Types which contain a rate, but are agnostic of it. The counter example would be if the rate was a type index of a data family.

Minimal complete definition

coerceRate

Methods

coerceRate :: proxy rj -> i -> SetRate i rj

Change the static sample rate, without e.g. resampling

Instances

(HasRate i, (~) Rate (GetRate i) ri, (~) * (SetRate i rj) j, KnownRate rj, CoerceRate i j ri rj) => CoerceRate (Discontinous i) (Discontinous j) ri rj

Methods

coerceRate :: proxy rj -> Discontinous i -> SetRate (Discontinous i) rj

(HasRate i, (~) Rate (GetRate i) ri, (~) * (SetRate i rj) j, KnownRate rj, CoerceRate i j ri rj) => CoerceRate (Segment d i) (Segment d j) ri rj

Methods

coerceRate :: proxy rj -> Segment d i -> SetRate (Segment d i) rj

getRate :: forall i proxy. HasRate i => proxy i -> Integer

Return the Rate as an Integer from a proxy for an instance of HasRate

getRateProxy :: HasRate i => proxy i -> RateProxy (GetRate i)

Return a Proxy for the GetRate from a proxy for an instance of HasRate

data RateProxy :: Rate -> Type where

A proxy type for Rates useful to prevent orphan instances, is seen in the Show instance for RateProxy. If the instance were defined as instance KnownRate r => Show (proxy r) where ... it would be an orphan instance.

Constructors

MkRateProxy :: RateProxy rate

ConvertRateProxy :: proxy rate -> RateProxy rate

Instances

KnownRate r => Show (RateProxy r)

Methods

showsPrec :: Int -> RateProxy r -> ShowS

show :: RateProxy r -> String

showList :: [RateProxy r] -> ShowS

type PeriodDuration i = 1 :/ GetRate i

Return the StaticTicks representing the shortest representable duration of something sampled at a Rate

getPeriodDuration :: forall i proxy. HasRate i => proxy i -> NominalDiffTime

Return the reciprocal of the sample rate, i.e. the duration that one sample spans

coerceRateTo8kHz :: CoerceRate x y rx (Hz 8000) => x -> y

Utility around coerceRate to set the sample rate to 8000 Hz.

coerceRateTo16kHz :: CoerceRate x y rx (Hz 16000) => x -> y

Utility around coerceRate to set the sample rate to 16000 Hz.

coerceRateTo48kHz :: CoerceRate x y rx (Hz 48000) => x -> y

Utility around coerceRate to set the sample rate to 48000 Hz.

coerceToDoubleRate :: forall r s x y. (CoerceRate x y r (Hz (s + s)), KnownRate r, RateVal r ~ s, KnownNat (s + s)) => x -> y

Utility around coerceRate to double the sample rate.

newtype Ticks rate w

An integral time unit such that (time_in_seconds = _ticks * 1/rate)

Constructors

MkTicks w

Instances

Enum w => Enum (Ticks rate w)

Methods

succ :: Ticks rate w -> Ticks rate w

pred :: Ticks rate w -> Ticks rate w

toEnum :: Int -> Ticks rate w

fromEnum :: Ticks rate w -> Int

enumFrom :: Ticks rate w -> [Ticks rate w]

enumFromThen :: Ticks rate w -> Ticks rate w -> [Ticks rate w]

enumFromTo :: Ticks rate w -> Ticks rate w -> [Ticks rate w]

enumFromThenTo :: Ticks rate w -> Ticks rate w -> Ticks rate w -> [Ticks rate w]

Eq w => Eq (Ticks rate w)

Methods

(==) :: Ticks rate w -> Ticks rate w -> Bool

(/=) :: Ticks rate w -> Ticks rate w -> Bool

(LocalOrd w, Integral w) => Integral (Ticks rate w)

Methods

quot :: Ticks rate w -> Ticks rate w -> Ticks rate w

rem :: Ticks rate w -> Ticks rate w -> Ticks rate w

div :: Ticks rate w -> Ticks rate w -> Ticks rate w

mod :: Ticks rate w -> Ticks rate w -> Ticks rate w

quotRem :: Ticks rate w -> Ticks rate w -> (Ticks rate w, Ticks rate w)

divMod :: Ticks rate w -> Ticks rate w -> (Ticks rate w, Ticks rate w)

toInteger :: Ticks rate w -> Integer

Num w => Num (Ticks rate w)

Methods

(+) :: Ticks rate w -> Ticks rate w -> Ticks rate w

(-) :: Ticks rate w -> Ticks rate w -> Ticks rate w

(*) :: Ticks rate w -> Ticks rate w -> Ticks rate w

negate :: Ticks rate w -> Ticks rate w

abs :: Ticks rate w -> Ticks rate w

signum :: Ticks rate w -> Ticks rate w

fromInteger :: Integer -> Ticks rate w

(Eq w, LocalOrd w) => Ord (Ticks rate w)

Methods

compare :: Ticks rate w -> Ticks rate w -> Ordering

(<) :: Ticks rate w -> Ticks rate w -> Bool

(<=) :: Ticks rate w -> Ticks rate w -> Bool

(>) :: Ticks rate w -> Ticks rate w -> Bool

(>=) :: Ticks rate w -> Ticks rate w -> Bool

max :: Ticks rate w -> Ticks rate w -> Ticks rate w

min :: Ticks rate w -> Ticks rate w -> Ticks rate w

(LocalOrd w, Real w) => Real (Ticks rate w)

Methods

toRational :: Ticks rate w -> Rational

(CanBeTicks r w, Show w) => Show (Ticks r w)

Methods

showsPrec :: Int -> Ticks r w -> ShowS

show :: Ticks r w -> String

showList :: [Ticks r w] -> ShowS

Generic (Ticks rate w)

Associated Types

type Rep (Ticks rate w) :: * -> *

Methods

from :: Ticks rate w -> Rep (Ticks rate w) x

to :: Rep (Ticks rate w) x -> Ticks rate w

Arbitrary w => Arbitrary (Ticks rate w)

Methods

arbitrary :: Gen (Ticks rate w)

shrink :: Ticks rate w -> [Ticks rate w]

Default w => Default (Ticks rate w)

Methods

def :: Ticks rate w

NFData w => NFData (Ticks rate w)

Methods

rnf :: Ticks rate w -> ()

Random w => Random (Ticks rate w)

Methods

randomR :: RandomGen g => (Ticks rate w, Ticks rate w) -> g -> (Ticks rate w, g)

random :: RandomGen g => g -> (Ticks rate w, g)

randomRs :: RandomGen g => (Ticks rate w, Ticks rate w) -> g -> [Ticks rate w]

randoms :: RandomGen g => g -> [Ticks rate w]

randomRIO :: (Ticks rate w, Ticks rate w) -> IO (Ticks rate w)

randomIO :: IO (Ticks rate w)

LocalOrd w => LocalOrd (Ticks rate w)

Methods

succeeds :: Ticks rate w -> Ticks rate w -> Bool

type Rep (Ticks rate w)

type Rep (Ticks rate w) = D1 (MetaData "Ticks" "Data.MediaBus.Basics.Ticks" "mediabus-0.3.2.0-EYq50xtGpLQJMwyWVW3Mgi" True) (C1 (MetaCons "MkTicks" PrefixI True) (S1 (MetaSel (Just Symbol "_ticks") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 w)))

type CanBeTicks r w = (KnownRate r, Integral w)

The constraint on the type parameters of 'Ticks

type PicoSeconds = Ticks OnePerPicoSecond Integer

The highest resolution Ticks possible, such that it can still be converted to NominalDiffTime

type Ticks32 r = Ticks r Word32

Alias for Ticks based on a Word32 tick count.

mkTicks32 :: KnownRate r => proxy r -> Word32 -> Ticks32 r

Create a Ticks32 from a Rate given via a proxy and the number of ticks.

type Ticks64 r = Ticks r Word64

Alias for Ticks based on a Word64 tick count.

mkTicks64 :: KnownRate r => proxy r -> Word64 -> Ticks64 r

Create a Ticks64 from a Rate given via a proxy and the number of ticks.

type Ticks32At8000 = Ticks32 (Hz 8000)

Alias for Ticks based on a Word32 tick count with a rate of 8000 ticks per second.

mkTicks32At8000 :: Word32 -> Ticks32At8000

Create a Ticks32At8000 from a tick count.

type Ticks32At16000 = Ticks32 (Hz 16000)

Alias for Ticks based on a Word32 tick count with a rate of 16000 ticks per second.

mkTicks32At16000 :: Word32 -> Ticks32At16000

Create a 'Ticks32At16000 from a tick count.

type Ticks32At48000 = Ticks32 (Hz 48000)

Alias for Ticks based on a Word32 tick count with a rate of 48000 ticks per second.

mkTicks32At48000 :: Word32 -> Ticks32At48000

Create a 'Ticks32At48000 from a tick count.

type Ticks64At8000 = Ticks64 (Hz 8000)

Alias for Ticks based on a Word64 tick count with a rate of 8000 ticks per second.

mkTicks64At8000 :: Word64 -> Ticks64At8000

Create a 'Ticks64At8000 from a tick count.

type Ticks64At16000 = Ticks64 (Hz 16000)

Alias for Ticks based on a Word64 tick count with a rate of 16000 ticks per second.

mkTicks64At16000 :: Word64 -> Ticks64At16000

Create a 'Ticks64At16000 from a tick count.

type Ticks64At48000 = Ticks64 (Hz 48000)

Alias for Ticks based on a Word64 tick count with a rate of 48000 ticks per second.

mkTicks64At48000 :: Word64 -> Ticks64At48000

Create a 'Ticks64At48000 from a tick count.

nominalDiffTime :: forall r w. CanBeTicks r w => Iso' (Ticks r w) NominalDiffTime

A function (an Iso) that converts back-and-forth between Ticks and NominalDiffTimes

convertTicks :: (CanBeTicks r w, CanBeTicks r' w') => Ticks r w -> Ticks r' w'

Transform a Tick value to another Tick value.

data StaticTicks where

Time unit for durations known at compile time.

Constructors

(:/:) :: Nat -> Rate -> StaticTicks

Instances

(KnownRate r, KnownNat t) => HasStaticDuration StaticTicks ((:/) t r)

Associated Types

type SetStaticDuration ((:/) t r) (s :: (:/) t r) (pt :: StaticTicks) :: k

type GetStaticDuration ((:/) t r) (s :: (:/) t r) :: StaticTicks

type GetStaticDuration StaticTicks ((:/) t r)

type GetStaticDuration StaticTicks ((:/) t r) = (:/) t r

type SetStaticDuration StaticTicks ((:/) t r) ((:/) t' r')

type SetStaticDuration StaticTicks ((:/) t r) ((:/) t' r') = (:/) t' r'

class KnownStaticTicks s where

Analog to KnownNat this (kind-)class is for StaticTicks with a runtime Ticks value.

Minimal complete definition

staticTicksVal

Methods

staticTicksVal :: KnownRate r => proxy s -> Ticks r Integer

Instances

(KnownNat d, KnownRate r) => KnownStaticTicks ((:/) d r)

Methods

staticTicksVal :: KnownRate r => proxy (d :/ r) -> Ticks r Integer

type family StaticTicksRate (s :: StaticTicks) :: Rate where ...

Return the Rate value of a promoted StaticTicks.

Equations

StaticTicksRate (t :/ r) = r

type family StaticTicksTicks (s :: StaticTicks) :: Nat where ...

Return the ticks value of a promoted StaticTicks.

Equations

StaticTicksTicks (t :/ r) = t

class HasDuration a where

Types with a duration (e.g. audio samples).

Methods

getDuration :: a -> NominalDiffTime

getDurationTicks :: CanBeTicks r i => a -> Ticks r i

Instances

HasDuration a => HasDuration (Maybe a)

Methods

getDuration :: Maybe a -> NominalDiffTime

getDurationTicks :: CanBeTicks r i => Maybe a -> Ticks r i

HasDuration a => HasDuration (Discontinous a)

Methods

getDuration :: Discontinous a -> NominalDiffTime

getDurationTicks :: CanBeTicks r i => Discontinous a -> Ticks r i

HasStaticDuration StaticTicks d => HasDuration (Segment d x)

Methods

getDuration :: Segment d x -> NominalDiffTime

getDurationTicks :: CanBeTicks r i => Segment d x -> Ticks r i

(KnownRate r, CanBeSample (Pcm c t)) => HasDuration (Audio r c (Raw * t))

Methods

getDuration :: Audio r c (Raw * t) -> NominalDiffTime

getDurationTicks :: CanBeTicks r i => Audio r c (Raw * t) -> Ticks r i

HasDuration c => HasDuration (Frame s t c)

Methods

getDuration :: Frame s t c -> NominalDiffTime

getDurationTicks :: CanBeTicks r i => Frame s t c -> Ticks r i

HasDuration (FrameCtx i s t p)

Methods

getDuration :: FrameCtx i s t p -> NominalDiffTime

getDurationTicks :: CanBeTicks r i => FrameCtx i s t p -> Ticks r i

HasDuration c => HasDuration (Stream i s t p c)

Methods

getDuration :: Stream i s t p c -> NominalDiffTime

getDurationTicks :: CanBeTicks r i => Stream i s t p c -> Ticks r i

class SetTimestamp t (GetTimestamp t) ~ t => HasTimestamp t where

Types that contain a Timestamp

Minimal complete definition

timestamp

Associated Types

type GetTimestamp t

type SetTimestamp t s

Methods

timestamp :: Lens t (SetTimestamp t s) (GetTimestamp t) s

timestamp' :: Lens' t (GetTimestamp t)

Instances

(HasTimestamp a, HasTimestamp b, (~) * (GetTimestamp a) (GetTimestamp b)) => HasTimestamp (Series a b)

Associated Types

type GetTimestamp (Series a b) :: *

type SetTimestamp (Series a b) s :: *

Methods

timestamp :: Functor f => (GetTimestamp (Series a b) -> f s) -> Series a b -> f (SetTimestamp (Series a b) s)

timestamp' :: Lens' (Series a b) (GetTimestamp (Series a b))

HasTimestamp (Frame s t c)

Associated Types

type GetTimestamp (Frame s t c) :: *

type SetTimestamp (Frame s t c) s :: *

Methods

timestamp :: Functor f => (GetTimestamp (Frame s t c) -> f s) -> Frame s t c -> f (SetTimestamp (Frame s t c) s)

timestamp' :: Lens' (Frame s t c) (GetTimestamp (Frame s t c))

HasTimestamp (FrameCtx i s t p)

Associated Types

type GetTimestamp (FrameCtx i s t p) :: *

type SetTimestamp (FrameCtx i s t p) s :: *

Methods

timestamp :: Functor f => (GetTimestamp (FrameCtx i s t p) -> f s) -> FrameCtx i s t p -> f (SetTimestamp (FrameCtx i s t p) s)

timestamp' :: Lens' (FrameCtx i s t p) (GetTimestamp (FrameCtx i s t p))

HasTimestamp (Stream i s t p c)

Associated Types

type GetTimestamp (Stream i s t p c) :: *

type SetTimestamp (Stream i s t p c) s :: *

Methods

timestamp :: Functor f => (GetTimestamp (Stream i s t p c) -> f s) -> Stream i s t p c -> f (SetTimestamp (Stream i s t p c) s)

timestamp' :: Lens' (Stream i s t p c) (GetTimestamp (Stream i s t p c))

class (KnownStaticTicks (GetStaticDuration s), SetStaticDuration s (GetStaticDuration s) ~ s) => HasStaticDuration s

Types that have a duration known at compoile time.

Associated Types

type SetStaticDuration s (pt :: StaticTicks) :: k

type GetStaticDuration s :: StaticTicks

Instances

(KnownRate r, KnownNat t) => HasStaticDuration StaticTicks ((:/) t r)

Associated Types

type SetStaticDuration ((:/) t r) (s :: (:/) t r) (pt :: StaticTicks) :: k

type GetStaticDuration ((:/) t r) (s :: (:/) t r) :: StaticTicks

KnownStaticTicks d => HasStaticDuration * (Segment d x)

Associated Types

type SetStaticDuration (Segment d x) (s :: Segment d x) (pt :: StaticTicks) :: k

type GetStaticDuration (Segment d x) (s :: Segment d x) :: StaticTicks

getStaticDurationTicks :: forall proxy s r t i. (CanBeTicks r i, KnownNat t, HasStaticDuration s, GetStaticDuration s ~ (t :/ r)) => proxy s -> Ticks r i

Convert the StaticDuration that some type has to any Ticks.

getStaticDuration :: forall proxy s. HasStaticDuration s => proxy s -> NominalDiffTime

Convert the StaticDuration that some type has to the number of seconds.

toStaticDurationProxy :: HasStaticDuration s => proxy s -> Proxy (GetStaticDuration s)

Create a Proxy for the StaticTicks type associated with s, this is basically the analogon to the getDuration method - just for types with a duration known at compile time.

ticksFromStaticDuration :: forall proxy rate ticks i. (CanBeTicks rate i, KnownNat ticks) => proxy (ticks :/ rate) -> Ticks rate i

type (:/) ticks rate = ticks :/: rate

Convenient wrapper around MkStaticTicks and MkRate to create a promoted StaticTicks.