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.4.0.1-KxOztWIrQ7SL9k5ZMcQI4H" 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))

setTimestampFromDurations :: forall r t a. (CanBeTicks r t, HasDuration a, HasTimestamp a, GetTimestamp a ~ ()) => a -> Ticks r t -> (SetTimestamp a (Ticks r t), Ticks r t)

Calculate and set a timestamp.

The timestamp of each element is calculated from the sum of the durations of the previous elements stored and the start time stamp t0.

The input elements must be instances of HasTimestamp but with the important condition, that the input timestamp is always unit i.e. (). This prevents meaningful timestamps from being overwritten.

Use removeTimestamp to explicitly remove a timestamp.

removeTimestamp :: HasTimestamp a => a -> SetTimestamp a ()

Explicitly remove a timestamp, by setting the timestamp to ().

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.