-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Multimedia streaming on top of Conduit
--   
--   Please see README.md
@package mediabus
@version 0.3.2.0


-- | This module contains mainly the informative <a>IsMedia</a> type class
--   and corresponding type classes for media lenses.
module Data.MediaBus.Media.Media

-- | Very abstract class of media content types. The only universal feature
--   is that it has a static description.
class (NFData i, Show (MediaDescription i)) => IsMedia i

-- | A proxy type to display static media info via a <a>Show</a> instance
data MediaDescription i
[MkShowMedia] :: (Show (MediaDescription i)) => MediaDescription i

-- | Types that contain an <a>IsMedia</a> instance.
class (IsMedia (MediaFrom s), IsMedia (MediaTo t)) => HasMedia s t where type MediaFrom s type MediaTo t where {
    type family MediaFrom s;
    type family MediaTo t;
}

-- | A <a>Lens</a> for the media within <tt>s</tt>
media :: HasMedia s t => Lens s t (MediaFrom s) (MediaTo t)

-- | Types that contain an <a>IsMedia</a> instance.
type HasMedia' s = (IsMedia (MediaFrom s), HasMedia s s, MediaFrom s ~ MediaTo s)

-- | A simple <a>Lens</a> for the media within <tt>s</tt>
media' :: HasMedia' s => Lens' s (MediaFrom s)

-- | Types that contain an <a>IsMedia</a> instance with the traditional
--   lens-like type parameters
type HasMediaL s t a b = (IsMedia a, HasMedia s t, MediaFrom s ~ a, MediaTo t ~ b)

-- | Like <a>HasMedia</a> but with the **simple** lens-like type parameters
type HasMediaL' s a = (IsMedia a, HasMedia s s, MediaFrom s ~ a, MediaTo s ~ a, MediaFrom s ~ MediaTo s)

-- | Types that contain zero or more <a>IsMedia</a> instance.
class (IsMedia (MediaFromE s), IsMedia (MediaToE t)) => EachMedia s t where type MediaFromE s type MediaToE t eachMedia = media where {
    type family MediaFromE s;
    type family MediaToE t;
}

-- | A <a>Traversal</a> for the media within <tt>s</tt>
eachMedia :: EachMedia s t => Traversal s t (MediaFromE s) (MediaToE t)

-- | A <a>Traversal</a> for the media within <tt>s</tt>
eachMedia :: (EachMedia s t, HasMediaL s t (MediaFromE s) (MediaToE t)) => Traversal s t (MediaFromE s) (MediaToE t)

-- | Types that contain zero or more <a>IsMedia</a> instance.
type EachMedia' s = (IsMedia (MediaFromE s), EachMedia s s, MediaFromE s ~ MediaToE s)

-- | A simple <a>Traversal</a> for the media within <tt>s</tt>
eachMedia' :: EachMedia' s => Traversal' s (MediaFromE s)

-- | Types that contain zero or more <a>IsMedia</a> instance with the
--   traditional lens-like type parameters
type EachMediaL s t a b = (IsMedia a, EachMedia s t, MediaFromE s ~ a, MediaToE t ~ b)

-- | Like <a>EachMedia</a> but with the **simple** lens-like type
--   parameters
type EachMediaL' s a = (IsMedia a, EachMedia s s, MediaFromE s ~ a, MediaToE s ~ a, MediaFromE s ~ MediaToE s)


-- | Channel representation types.
module Data.MediaBus.Media.Channels

-- | Like <tt>KnownNat</tt> but for promoted <a>ChannelLayout</a>s.
class Typeable c => KnownChannelLayout c

-- | Return the <a>ChannelLayout</a> for type <tt>c</tt>
numberOfChannels :: KnownChannelLayout c => proxy c -> Int

-- | A Proxy specifically to prevent orphan instances of e.g. <tt>Proxy
--   channelLayoyt</tt>.
data ChannelLayoutProxy c
[MkChannelLayoutProxy] :: ChannelLayoutProxy c
[ConvertChannelLayoutProxy] :: proxy c -> ChannelLayoutProxy c

-- | Types that have some <a>KnownChannelLayout</a>
class (SetChannelLayout s (ChannelLayout s) ~ s) => HasChannelLayout s where type ChannelLayout s type SetChannelLayout s b where {
    type family ChannelLayout s;
    type family SetChannelLayout s b;
}

-- | Types, e.g samples, that have one or more channels
class EachChannel s t where type ChannelsFrom s type ChannelsTo t where {
    type family ChannelsFrom s;
    type family ChannelsTo t;
}
eachChannel :: EachChannel s t => Traversal s t (ChannelsFrom s) (ChannelsTo t)

-- | A constraint type alias for <a>EachChannel</a> similar to the
--   parameters of type class <a>Each</a> from the lens package.
type EachChannelL s t a b = (EachChannel s t, ChannelsFrom s ~ a, ChannelsTo t ~ b)

-- | A constraint type alias for <a>EachChannel</a> with a simple traversal
type EachChannelL' s a = (EachChannel s s, ChannelsFrom s ~ a, ChannelsTo s ~ a)

-- | A simple <a>Traversal</a> for the channels in samples
type EachChannel' s = (ChannelsFrom s ~ ChannelsTo s, EachChannel s s)

-- | A simple <a>Traversal</a> for the channels in samples
eachChannel' :: EachChannel' i => Traversal' i (ChannelsFrom i)
instance forall k (c :: k). Data.MediaBus.Media.Channels.KnownChannelLayout k c => GHC.Show.Show (Data.MediaBus.Media.Channels.ChannelLayoutProxy k c)


-- | Conduit combinators that make the type of a conduit unambiguous to the
--   compiler via proxies.
module Data.MediaBus.Conduit.TypeAnnotations

-- | Annotate the type of a <a>Conduit</a> where input and output are the
--   same
annotateTypeC :: proxy a -> Conduit a m a -> Conduit a m a

-- | Annotate the input type of a <a>Conduit</a>
annotateTypeCIn :: proxy a -> Conduit a m b -> Conduit a m b

-- | Annotate the output type of a <a>Conduit</a>
annotateTypeCOut :: proxy b -> Conduit a m b -> Conduit a m b

-- | Annotate the output type of a <a>Source</a>
annotateTypeSource :: proxy a -> Source m a -> Source m a

-- | Annotate the input type of a <a>Sink</a>
annotateTypeSink :: proxy a -> Sink a m r -> Sink a m r


-- | Probabilistic tracing conduits using <a>Trace</a>
module Data.MediaBus.Conduit.Trace

-- | For profiling and debugging it can sometimes be useful, to have a
--   circuit breaker, like this conduit, that exists after an given number
--   of items have been processed, and, until then just yields all inputs.
exitAfterC :: Monad m => Int -> Conduit a m a

-- | Receive and trace the <a>Show</a>n value prefixed by a message and
--   then yield down the stream. Since the number of elements sent over a
--   conduit can be tremendous, a tracing probability parameter was added,
--   that can be between <tt>0.0</tt> - <tt>1.0</tt>, and sets the
--   probability of with which a message will be traced. This uses
--   <a>traceM</a> internally. Do not use this for logging.
traceShowC :: (Show a, Monad m) => Double -> String -> Conduit a m a

-- | Like <a>traceShowC</a> but implemented as a <a>Consumer</a> that also
--   returns all received inputs as a list when the conduit terminates.
traceShowSink :: (Show a, Monad m) => Double -> String -> Consumer a m [a]


-- | Logging utilities for <a>Conduit</a>s.
module Data.MediaBus.Conduit.Logging

-- | Prefix all log messages of the given <a>Conduit</a> with a
--   <tt>Text</tt>. This is similar to <a>withLogMessagePrefix</a>.
prefixLogsC :: (ToLogStr prefix, MonadLoggerIO m) => prefix -> ConduitM i o (LoggingT m) r -> ConduitM i o m r


-- | Dubious utilities for <a>Vector</a>
module Data.MediaBus.Basics.VectorExtra

-- | Calculate the number of elements that would fit into the given
--   <a>Vector</a> if it were <a>unsafeCast</a>ed to a vector of elements
--   defined by the first argument.
castedLength :: forall a b proxy. (Storable a, Storable b) => proxy a -> Vector b -> Int


-- | This module contains the <a>SourceId</a> wrapper type, that indicate
--   that something is identifies a single source of media. This could be
--   an RTP SSRC or the IP/Port pair of a network source. The defining
--   characteristic of a <a>SourceId</a> is that every thing that has a
--   certain source id stems from **the same media source**, e.g. the same
--   microphone, audio file, synthesizer,...
module Data.MediaBus.Basics.SourceId

-- | Things that can be uniquely identified by a looking at a (much
--   simpler) representation, the <tt>identity</tt>.
newtype SourceId i
MkSourceId :: i -> SourceId i

-- | An <a>Iso</a> for the value of a <a>SourceId</a>
sourceIdValue :: Iso (SourceId a) (SourceId b) a b

-- | A short alias for <a>SourceId</a> with a <a>Word32</a> value
type SrcId32 = SourceId Word32

-- | A short alias for <a>SourceId</a> with a <a>Word64</a> value
type SrcId64 = SourceId Word64

-- | Type class for a lens over the contained source id
class HasSourceId s t where type SourceIdFrom s type SourceIdTo t where {
    type family SourceIdFrom s;
    type family SourceIdTo t;
}

-- | A lens for the <a>SourceId</a>
sourceId :: HasSourceId s t => Lens s t (SourceIdFrom s) (SourceIdTo t)

-- | Type class with a <a>Traversal</a> for types that may or may not
--   contain anctual source id.
class EachSourceId s t where type SourceIdsFrom s type SourceIdsTo t where {
    type family SourceIdsFrom s;
    type family SourceIdsTo t;
}

-- | A <a>Traversal</a> for the <a>SourceId</a>
eachSourceId :: EachSourceId s t => Traversal s t (SourceIdsFrom s) (SourceIdsTo t)
instance GHC.Generics.Generic (Data.MediaBus.Basics.SourceId.SourceId i)
instance GHC.Classes.Ord i => GHC.Classes.Ord (Data.MediaBus.Basics.SourceId.SourceId i)
instance Data.Default.Class.Default i => Data.Default.Class.Default (Data.MediaBus.Basics.SourceId.SourceId i)
instance Test.QuickCheck.Arbitrary.Arbitrary i => Test.QuickCheck.Arbitrary.Arbitrary (Data.MediaBus.Basics.SourceId.SourceId i)
instance GHC.Classes.Eq i => GHC.Classes.Eq (Data.MediaBus.Basics.SourceId.SourceId i)
instance Control.DeepSeq.NFData i => Control.DeepSeq.NFData (Data.MediaBus.Basics.SourceId.SourceId i)
instance GHC.Show.Show i => GHC.Show.Show (Data.MediaBus.Basics.SourceId.SourceId i)


-- | A series with a start value and consecutive next vaules.
module Data.MediaBus.Basics.Series

-- | A value of a series is either the <a>Start</a> of that series or the
--   <a>Next</a> value in a started series.
data Series a b
Next :: !b -> Series a b
Start :: !a -> Series a b
_Next :: forall a_aq8H b_aq8I b_aqmK. Prism (Series a_aq8H b_aqmK) (Series a_aq8H b_aq8I) b_aqmK b_aq8I
_Start :: forall a_aq8H b_aq8I a_aqmP. Prism (Series a_aqmP b_aq8I) (Series a_aq8H b_aq8I) a_aqmP a_aq8H

-- | A simple version of a series, where the <a>Start</a> value has the
--   same type as the <a>Next</a> value.
type Series' a = Series a a

-- | A class of types with any kind <i>start</i> and <i>next</i> semantics,
--   not necessarily provided by <a>Series</a>.
class AsSeries s a b | s -> a, s -> b

-- | A simple <tt>Prim</tt> to extract a <i>start</i> value
seriesStart' :: AsSeries s a b => Prism' s a

-- | A simple <tt>Prim</tt> to extract a <i>next</i> value
seriesNext' :: AsSeries s a b => Prism' s b

-- | A type class for types that might have a <i>start</i> value.
class (SetSeriesStart s (GetSeriesStart s) ~ s) => AsSeriesStart s where type GetSeriesStart s type SetSeriesStart s t where {
    type family GetSeriesStart s;
    type family SetSeriesStart s t;
}

-- | A <a>Prism</a> for <i>start</i> values
seriesStart :: AsSeriesStart s => Prism s (SetSeriesStart s n) (GetSeriesStart s) n

-- | A type class for types that might have a <i>next</i> value.
class (SetSeriesNext s (GetSeriesNext s) ~ s) => AsSeriesNext s where type GetSeriesNext s type SetSeriesNext s t where {
    type family GetSeriesNext s;
    type family SetSeriesNext s t;
}

-- | A <a>Prism</a> for the <i>next</i> values
seriesNext :: AsSeriesNext s => Prism s (SetSeriesNext s n) (GetSeriesNext s) n
instance (Control.DeepSeq.NFData a, Control.DeepSeq.NFData b) => Control.DeepSeq.NFData (Data.MediaBus.Basics.Series.Series a b)
instance (GHC.Show.Show a, GHC.Show.Show b) => GHC.Show.Show (Data.MediaBus.Basics.Series.Series a b)
instance (GHC.Classes.Ord a, GHC.Classes.Ord b) => GHC.Classes.Ord (Data.MediaBus.Basics.Series.Series a b)
instance (Test.QuickCheck.Arbitrary.Arbitrary a, Test.QuickCheck.Arbitrary.Arbitrary b) => Test.QuickCheck.Arbitrary.Arbitrary (Data.MediaBus.Basics.Series.Series a b)
instance GHC.Base.Functor (Data.MediaBus.Basics.Series.Series a)
instance Data.Bifunctor.Bifunctor Data.MediaBus.Basics.Series.Series
instance Data.MediaBus.Basics.Series.AsSeries (Data.Either.Either a b) a b
instance Data.MediaBus.Basics.Series.AsSeries (Data.MediaBus.Basics.Series.Series a b) a b
instance Data.MediaBus.Basics.Series.AsSeriesStart (Data.Either.Either a b)
instance Data.MediaBus.Basics.Series.AsSeriesStart (Data.MediaBus.Basics.Series.Series a b)
instance Data.MediaBus.Basics.Series.AsSeriesNext (Data.Either.Either a b)
instance Data.MediaBus.Basics.Series.AsSeriesNext (Data.MediaBus.Basics.Series.Series a b)
instance GHC.Generics.Generic (Data.MediaBus.Basics.Series.Series a b)
instance (GHC.Classes.Eq a, GHC.Classes.Eq b) => GHC.Classes.Eq (Data.MediaBus.Basics.Series.Series a b)


-- | Value level <a>Ord</a>er. Sometimes values stored in e.g. <a>Set</a>s
--   have an <a>Ord</a> instance, which does not represent the desired
--   order. In that case use this product type to pass a value along with
--   the value to be for comparison by the <a>Eq</a> and <a>Ord</a>
--   instances.
module Data.MediaBus.Basics.OrderedBy

-- | A wrapper around a <i>payload</i> value paired with a value to be used
--   when <i>comparing</i> that payload value.
data OrderedBy cmp a
MkOrderedBy :: cmp -> a -> OrderedBy cmp a
instance GHC.Classes.Eq cmp => GHC.Classes.Eq (Data.MediaBus.Basics.OrderedBy.OrderedBy cmp a)
instance GHC.Classes.Ord cmp => GHC.Classes.Ord (Data.MediaBus.Basics.OrderedBy.OrderedBy cmp a)

module Data.MediaBus.Basics.Monotone

-- | Class of numbers that are monotone increasing having only a relative
--   order, that is not necessarily transitive.
--   
--   For example, a series of <a>Word8</a> values: <tt>0 64 128 192 0 64
--   128 ...</tt> could be interpreted as a monotone series of consecutive
--   increasing values, that wrap around after 255. But note that the
--   <a>Ord</a> instance is not sufficient to express that <tt>0</tt>
--   <a>succeeds</a> <tt>192</tt>, since <a>Ord</a> ensures complete
--   transitivity and therefore <tt>0 &lt; 192</tt>.
class LocalOrd a
succeeds :: LocalOrd a => a -> a -> Bool
instance Data.MediaBus.Basics.Monotone.LocalOrd GHC.Word.Word8
instance Data.MediaBus.Basics.Monotone.LocalOrd GHC.Word.Word16
instance Data.MediaBus.Basics.Monotone.LocalOrd GHC.Word.Word32
instance Data.MediaBus.Basics.Monotone.LocalOrd GHC.Word.Word64
instance Data.MediaBus.Basics.Monotone.LocalOrd GHC.Int.Int8
instance Data.MediaBus.Basics.Monotone.LocalOrd GHC.Int.Int16
instance Data.MediaBus.Basics.Monotone.LocalOrd GHC.Int.Int32
instance Data.MediaBus.Basics.Monotone.LocalOrd GHC.Int.Int64
instance Data.MediaBus.Basics.Monotone.LocalOrd GHC.Types.Int


-- | This modules contains the <a>SeqNum</a> newtype wrapper to indicate
--   that a type is a sequence number.
module Data.MediaBus.Basics.Sequence

-- | The newtype wrapper that indicates that something is a sequence
--   number.
newtype SeqNum s
MkSeqNum :: s -> SeqNum s

-- | An <a>Iso</a> between a <a>SeqNum</a> and its' value.
fromSeqNum :: Iso (SeqNum a) (SeqNum b) a b

-- | A <a>Word8</a> based sequence number.
type SeqNum8 = SeqNum Word8

-- | A <a>Word16</a> based sequence number.
type SeqNum16 = SeqNum Word16

-- | A <a>Word32</a> based sequence number.
type SeqNum32 = SeqNum Word32

-- | A <a>Word64</a> based sequence number.
type SeqNum64 = SeqNum Word64

-- | A class for types providing a lens to a sequence number.
class SetSeqNum t (GetSeqNum t) ~ t => HasSeqNum t where type GetSeqNum t type SetSeqNum t s where {
    type family GetSeqNum t;
    type family SetSeqNum t s;
}

-- | A lens for the sequence number contained in <tt>t</tt>
seqNum :: HasSeqNum t => Lens t (SetSeqNum t s) (GetSeqNum t) s
instance System.Random.Random s => System.Random.Random (Data.MediaBus.Basics.Sequence.SeqNum s)
instance GHC.Generics.Generic (Data.MediaBus.Basics.Sequence.SeqNum s)
instance Data.Default.Class.Default s => Data.Default.Class.Default (Data.MediaBus.Basics.Sequence.SeqNum s)
instance Test.QuickCheck.Arbitrary.Arbitrary s => Test.QuickCheck.Arbitrary.Arbitrary (Data.MediaBus.Basics.Sequence.SeqNum s)
instance Data.MediaBus.Basics.Monotone.LocalOrd s => Data.MediaBus.Basics.Monotone.LocalOrd (Data.MediaBus.Basics.Sequence.SeqNum s)
instance GHC.Enum.Enum s => GHC.Enum.Enum (Data.MediaBus.Basics.Sequence.SeqNum s)
instance GHC.Enum.Bounded s => GHC.Enum.Bounded (Data.MediaBus.Basics.Sequence.SeqNum s)
instance GHC.Classes.Eq s => GHC.Classes.Eq (Data.MediaBus.Basics.Sequence.SeqNum s)
instance GHC.Num.Num s => GHC.Num.Num (Data.MediaBus.Basics.Sequence.SeqNum s)
instance (GHC.Real.Real a, GHC.Num.Num a, GHC.Classes.Eq a, Data.MediaBus.Basics.Monotone.LocalOrd a) => GHC.Real.Real (Data.MediaBus.Basics.Sequence.SeqNum a)
instance (GHC.Real.Integral a, GHC.Enum.Enum a, GHC.Real.Real a, GHC.Classes.Eq a, Data.MediaBus.Basics.Monotone.LocalOrd a) => GHC.Real.Integral (Data.MediaBus.Basics.Sequence.SeqNum a)
instance Control.DeepSeq.NFData s => Control.DeepSeq.NFData (Data.MediaBus.Basics.Sequence.SeqNum s)
instance Data.MediaBus.Basics.Sequence.HasSeqNum (Data.MediaBus.Basics.Sequence.SeqNum s)
instance GHC.Show.Show s => GHC.Show.Show (Data.MediaBus.Basics.Sequence.SeqNum s)
instance (GHC.Classes.Eq a, Data.MediaBus.Basics.Monotone.LocalOrd a) => GHC.Classes.Ord (Data.MediaBus.Basics.Sequence.SeqNum a)
instance (Data.MediaBus.Basics.Sequence.HasSeqNum a, Data.MediaBus.Basics.Sequence.HasSeqNum b, Data.MediaBus.Basics.Sequence.GetSeqNum a ~ Data.MediaBus.Basics.Sequence.GetSeqNum b) => Data.MediaBus.Basics.Sequence.HasSeqNum (Data.MediaBus.Basics.Series.Series a b)


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

-- | The known at ompile time, time unit in units per second.
newtype Rate
Hertz :: Nat -> Rate

-- | A more beautiful operator for <a>Hertz</a>
type Hz r = Hertz r

-- | The maximum representable frequency is <tt>10e12 1/s</tt> which
--   corresponds to the resolution of <a>NominalDiffTime</a>, i.e. 1 pico
--   second.
type OnePerPicoSecond = Hz 1000000000000

-- | Analogous to <a>KnownNat</a> this (kind-)class is for
--   <a>StaticTicks</a> with a runtime <a>Ticks</a> value.
class KnownRate (s :: Rate) where type RateVal s :: Nat where {
    type family RateVal s :: Nat;
}

-- | Return the runtime rate value in Hertz
rateVal :: KnownRate s => proxy s -> Integer

-- | Types with a known <a>Rate</a>, e.g. audio media has a sample rate.
class (KnownRate (GetRate i), SetRate i (GetRate i) ~ i) => HasRate i where type SetRate i (r :: Rate) type GetRate i :: Rate where {
    type family SetRate i (r :: Rate);
    type family GetRate i :: Rate;
}

-- | 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.
class (HasRate i, GetRate i ~ ri, SetRate i rj ~ j, KnownRate rj) => CoerceRate i j ri rj

-- | Change the static sample rate, without e.g. resampling
coerceRate :: CoerceRate i j ri rj => proxy rj -> i -> SetRate i rj

-- | Return the <a>Rate</a> as an <a>Integer</a> from a proxy for an
--   instance of <a>HasRate</a>
getRate :: forall i proxy. HasRate i => proxy i -> Integer

-- | Return a <a>Proxy</a> for the <a>GetRate</a> from a proxy for an
--   instance of <a>HasRate</a>
getRateProxy :: HasRate i => proxy i -> RateProxy (GetRate i)

-- | A proxy type for <a>Rate</a>s useful to prevent orphan instances, is
--   seen in the <a>Show</a> instance for <a>RateProxy</a>. If the instance
--   were defined as <tt>instance KnownRate r =&gt; Show (proxy r) where
--   ... </tt> it would be an orphan instance.
data RateProxy :: Rate -> Type
[MkRateProxy] :: RateProxy rate
[ConvertRateProxy] :: proxy rate -> RateProxy rate

-- | Return the <a>StaticTicks</a> representing the shortest representable
--   duration of something sampled at a <a>Rate</a>
type PeriodDuration i = 1 :/ GetRate i

-- | Return the reciprocal of the sample rate, i.e. the duration that one
--   sample spans
getPeriodDuration :: forall i proxy. HasRate i => proxy i -> NominalDiffTime

-- | Utility around <a>coerceRate</a> to set the sample rate to 8000 Hz.
coerceRateTo8kHz :: CoerceRate x y rx (Hz 8000) => x -> y

-- | Utility around <a>coerceRate</a> to set the sample rate to 16000 Hz.
coerceRateTo16kHz :: CoerceRate x y rx (Hz 16000) => x -> y

-- | Utility around <a>coerceRate</a> to set the sample rate to 48000 Hz.
coerceRateTo48kHz :: CoerceRate x y rx (Hz 48000) => x -> y

-- | Utility around <a>coerceRate</a> to double the sample rate.
coerceToDoubleRate :: forall r s x y. (CoerceRate x y r (Hz (s + s)), KnownRate r, RateVal r ~ s, KnownNat (s + s)) => x -> y

-- | An integral time unit such that (time_in_seconds = _ticks * 1/rate)
newtype Ticks (rate :: Rate) w
MkTicks :: w -> Ticks w

-- | The constraint on the type parameters of 'Ticks
type CanBeTicks (r :: Rate) w = (KnownRate r, Integral w)

-- | The highest resolution <a>Ticks</a> possible, such that it can still
--   be converted to <a>NominalDiffTime</a>
type PicoSeconds = Ticks OnePerPicoSecond Integer

-- | Alias for <a>Ticks</a> based on a <a>Word32</a> tick count.
type Ticks32 r = Ticks r Word32

-- | Create a <a>Ticks32</a> from a <a>Rate</a> given via a proxy and the
--   number of ticks.
mkTicks32 :: KnownRate r => proxy r -> Word32 -> Ticks32 r

-- | Alias for <a>Ticks</a> based on a <a>Word64</a> tick count.
type Ticks64 r = Ticks r Word64

-- | Create a <a>Ticks64</a> from a <a>Rate</a> given via a proxy and the
--   number of ticks.
mkTicks64 :: KnownRate r => proxy r -> Word64 -> Ticks64 r

-- | Alias for <a>Ticks</a> based on a <a>Word32</a> tick count with a rate
--   of 8000 ticks per second.
type Ticks32At8000 = Ticks32 (Hz 8000)

-- | Create a <a>Ticks32At8000</a> from a tick count.
mkTicks32At8000 :: Word32 -> Ticks32At8000

-- | Alias for <a>Ticks</a> based on a <a>Word32</a> tick count with a rate
--   of 16000 ticks per second.
type Ticks32At16000 = Ticks32 (Hz 16000)

-- | Create a 'Ticks32At16000 from a tick count.
mkTicks32At16000 :: Word32 -> Ticks32At16000

-- | Alias for <a>Ticks</a> based on a <a>Word32</a> tick count with a rate
--   of 48000 ticks per second.
type Ticks32At48000 = Ticks32 (Hz 48000)

-- | Create a 'Ticks32At48000 from a tick count.
mkTicks32At48000 :: Word32 -> Ticks32At48000

-- | Alias for <a>Ticks</a> based on a <a>Word64</a> tick count with a rate
--   of 8000 ticks per second.
type Ticks64At8000 = Ticks64 (Hz 8000)

-- | Create a 'Ticks64At8000 from a tick count.
mkTicks64At8000 :: Word64 -> Ticks64At8000

-- | Alias for <a>Ticks</a> based on a <a>Word64</a> tick count with a rate
--   of 16000 ticks per second.
type Ticks64At16000 = Ticks64 (Hz 16000)

-- | Create a 'Ticks64At16000 from a tick count.
mkTicks64At16000 :: Word64 -> Ticks64At16000

-- | Alias for <a>Ticks</a> based on a <a>Word64</a> tick count with a rate
--   of 48000 ticks per second.
type Ticks64At48000 = Ticks64 (Hz 48000)

-- | Create a 'Ticks64At48000 from a tick count.
mkTicks64At48000 :: Word64 -> Ticks64At48000

-- | A function (an <a>Iso</a>) that converts back-and-forth between
--   <tt>Tick</tt>s and <a>NominalDiffTime</a>s
nominalDiffTime :: forall r w. (CanBeTicks r w) => Iso' (Ticks r w) NominalDiffTime

-- | Transform a <tt>Tick</tt> value to another <tt>Tick</tt> value.
convertTicks :: (CanBeTicks r w, CanBeTicks r' w') => Ticks r w -> Ticks r' w'

-- | Time unit for durations known at compile time.
data StaticTicks
[:/:] :: Nat -> Rate -> StaticTicks

-- | Analog to <a>KnownNat</a> this (kind-)class is for <a>StaticTicks</a>
--   with a runtime <a>Ticks</a> value.
class KnownStaticTicks (s :: StaticTicks)
staticTicksVal :: (KnownStaticTicks s, KnownRate r) => proxy s -> Ticks r Integer

-- | Return the <a>Rate</a> value of a promoted <a>StaticTicks</a>.

-- | Return the ticks value of a promoted <a>StaticTicks</a>.

-- | Types with a duration (e.g. audio samples).
class HasDuration a where getDuration !x = from nominalDiffTime # (getDurationTicks x :: PicoSeconds) getDurationTicks !x = nominalDiffTime # getDuration x
getDuration :: HasDuration a => a -> NominalDiffTime
getDurationTicks :: (HasDuration a, CanBeTicks r i) => a -> Ticks r i

-- | Types that contain a <tt>Timestamp</tt>
class SetTimestamp t (GetTimestamp t) ~ t => HasTimestamp t where type GetTimestamp t type SetTimestamp t s timestamp' = timestamp where {
    type family GetTimestamp t;
    type family SetTimestamp t s;
}
timestamp :: HasTimestamp t => Lens t (SetTimestamp t s) (GetTimestamp t) s
timestamp' :: HasTimestamp t => Lens' t (GetTimestamp t)

-- | Types that have a duration known at compoile time.
class (KnownStaticTicks (GetStaticDuration s), SetStaticDuration s (GetStaticDuration s) ~ s) => HasStaticDuration (s :: k) where type SetStaticDuration s (pt :: StaticTicks) :: k type GetStaticDuration s :: StaticTicks type SetStaticDuration s (pt :: StaticTicks) = s where {
    type family SetStaticDuration s (pt :: StaticTicks) :: k;
    type family GetStaticDuration s :: StaticTicks;
    type SetStaticDuration s (pt :: StaticTicks) = s;
}

-- | Convert the <tt>StaticDuration</tt> that some type has to any
--   <a>Ticks</a>.
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 <tt>StaticDuration</tt> that some type has to the number
--   of seconds.
getStaticDuration :: forall proxy s. HasStaticDuration s => proxy s -> NominalDiffTime

-- | Create a <a>Proxy</a> for the <a>StaticTicks</a> type associated with
--   <tt>s</tt>, this is basically the analogon to the <a>getDuration</a>
--   method - just for types with a duration known at compile time.
toStaticDurationProxy :: (HasStaticDuration s) => proxy s -> Proxy (GetStaticDuration s)
ticksFromStaticDuration :: forall proxy rate ticks i. (CanBeTicks rate i, KnownNat ticks) => proxy (ticks :/ rate) -> Ticks rate i

-- | Convenient wrapper around <tt>MkStaticTicks</tt> and <tt>MkRate</tt>
--   to create a promoted <a>StaticTicks</a>.
type (:/) ticks rate = ticks :/: rate
instance System.Random.Random w => System.Random.Random (Data.MediaBus.Basics.Ticks.Ticks rate w)
instance GHC.Generics.Generic (Data.MediaBus.Basics.Ticks.Ticks rate w)
instance Data.Default.Class.Default w => Data.Default.Class.Default (Data.MediaBus.Basics.Ticks.Ticks rate w)
instance Test.QuickCheck.Arbitrary.Arbitrary w => Test.QuickCheck.Arbitrary.Arbitrary (Data.MediaBus.Basics.Ticks.Ticks rate w)
instance GHC.Num.Num w => GHC.Num.Num (Data.MediaBus.Basics.Ticks.Ticks rate w)
instance Data.MediaBus.Basics.Monotone.LocalOrd w => Data.MediaBus.Basics.Monotone.LocalOrd (Data.MediaBus.Basics.Ticks.Ticks rate w)
instance GHC.Enum.Enum w => GHC.Enum.Enum (Data.MediaBus.Basics.Ticks.Ticks rate w)
instance (Data.MediaBus.Basics.Monotone.LocalOrd w, GHC.Real.Integral w) => GHC.Real.Integral (Data.MediaBus.Basics.Ticks.Ticks rate w)
instance (Data.MediaBus.Basics.Monotone.LocalOrd w, GHC.Real.Real w) => GHC.Real.Real (Data.MediaBus.Basics.Ticks.Ticks rate w)
instance GHC.Classes.Eq w => GHC.Classes.Eq (Data.MediaBus.Basics.Ticks.Ticks rate w)
instance GHC.TypeLits.KnownNat r => Data.MediaBus.Basics.Ticks.KnownRate ('Data.MediaBus.Basics.Ticks.Hertz r)
instance Data.MediaBus.Basics.Ticks.KnownRate r => GHC.Show.Show (Data.MediaBus.Basics.Ticks.RateProxy r)
instance Control.DeepSeq.NFData w => Control.DeepSeq.NFData (Data.MediaBus.Basics.Ticks.Ticks rate w)
instance (Data.MediaBus.Basics.Ticks.CanBeTicks r w, GHC.Show.Show w) => GHC.Show.Show (Data.MediaBus.Basics.Ticks.Ticks r w)
instance (GHC.Classes.Eq w, Data.MediaBus.Basics.Monotone.LocalOrd w) => GHC.Classes.Ord (Data.MediaBus.Basics.Ticks.Ticks rate w)
instance (GHC.TypeLits.KnownNat d, Data.MediaBus.Basics.Ticks.KnownRate r) => Data.MediaBus.Basics.Ticks.KnownStaticTicks (d Data.MediaBus.Basics.Ticks.:/ r)
instance Data.MediaBus.Basics.Ticks.HasDuration a => Data.MediaBus.Basics.Ticks.HasDuration (GHC.Base.Maybe a)
instance (Data.MediaBus.Basics.Ticks.KnownRate r, GHC.TypeLits.KnownNat t) => Data.MediaBus.Basics.Ticks.HasStaticDuration Data.MediaBus.Basics.Ticks.StaticTicks (t Data.MediaBus.Basics.Ticks.:/ r)
instance (Data.MediaBus.Basics.Ticks.HasTimestamp a, Data.MediaBus.Basics.Ticks.HasTimestamp b, Data.MediaBus.Basics.Ticks.GetTimestamp a ~ Data.MediaBus.Basics.Ticks.GetTimestamp b) => Data.MediaBus.Basics.Ticks.HasTimestamp (Data.MediaBus.Basics.Series.Series a b)


-- | This module centers around the data family <a>Audio</a> that provides
--   general info about an audio stream, such as sampling rate and channel
--   layout and codec.
module Data.MediaBus.Media.Audio

-- | Family of audio media types, indexed by a sampleRate, a channel layout
--   and a <i>codec</i> parameter. This type family is intended as a basis
--   for all audio media, raw as well as encoded audio.
instance Data.MediaBus.Basics.Ticks.KnownRate r => Data.MediaBus.Basics.Ticks.HasRate (Data.MediaBus.Media.Audio.Audio r c t)
instance Data.MediaBus.Media.Channels.KnownChannelLayout * c => Data.MediaBus.Media.Channels.HasChannelLayout (Data.MediaBus.Media.Audio.Audio r c t)
instance (Data.MediaBus.Media.Media.IsMedia (Data.MediaBus.Media.Audio.Audio r c e), Data.MediaBus.Media.Media.IsMedia (Data.MediaBus.Media.Audio.Audio r' c' e')) => Data.MediaBus.Media.Media.HasMedia (Data.MediaBus.Media.Audio.Audio r c e) (Data.MediaBus.Media.Audio.Audio r' c' e')


-- | Media represented by samples in the time domain. What is meant by
--   media sample? For example the microphone value captured at a certain
--   point in time for mono audio, or the pair of values from the left and
--   right channel of a stereo audio track, or a pixel; the common
--   characteristic is that a sample encompasses the (aggregate) value
--   representing smallest piece of media. A sample may be composed of
--   components, like in a stereo audio sample, or color channels in an YUV
--   pixel, but since they are played/recorded at the same time instances,
--   they form a sample only when combined not when regarded indivudually.
module Data.MediaBus.Media.Samples

-- | Types that are <a>IsMedia</a> instances with sampled content.
class (IsMedia i, HasRate i) => IsSampledMedia i

-- | Always recurring contraints on <tt>Sample</tt> types.
type CanBeSample i = (Typeable i, Eq i, NFData i, Storable i)

-- | A type class for types that contain samples which can be converted
--   into other sample types.
class (CanBeSample (SamplesFrom s), CanBeSample (SamplesTo t)) => EachSample s t where type SamplesFrom s type SamplesTo t where {
    type family SamplesFrom s;
    type family SamplesTo t;
}
eachSample :: EachSample s t => Traversal s t (SamplesFrom s) (SamplesTo t)

-- | A lens-stype type alias for <a>EachSample</a> with the full <tt>s t a
--   b</tt> parameter set.
type EachSampleL s t a b = (EachSample s t, SamplesFrom s ~ a, SamplesTo t ~ b)

-- | A lens-stype type alias for <a>EachSample</a> for cases where
--   <tt><a>SamplesFrom</a> ~ <a>SamplesTo</a></tt> with the full <tt>s
--   a</tt> parameter set.
type EachSampleL' s a = (EachSample s s, SamplesFrom s ~ a, SamplesTo s ~ a)

-- | A lens-stype type alias for <a>EachSample</a> for cases where
--   <tt><a>SamplesFrom</a> ~ <a>SamplesTo</a></tt>
type EachSample' s = (EachSample s s, SamplesFrom s ~ SamplesTo s)

-- | A variant of <a>eachSample</a> for cases where <tt><a>SamplesFrom</a>
--   ~ <a>SamplesTo</a></tt>.
eachSample' :: EachSample' i => Traversal' i (SamplesFrom i)


-- | Media with a content stored in a <tt>Vector</tt>
module Data.MediaBus.Media.Buffer

-- | Always recurring contraints on <tt>Sample</tt> types.
type CanBeSample i = (Typeable i, Eq i, NFData i, Storable i)

-- | Types containing a <a>MediaBuffer</a>
class HasMediaBuffer s t where type MediaBufferFrom s type MediaBufferTo t where {
    type family MediaBufferFrom s;
    type family MediaBufferTo t;
}

-- | A lens for converting the media buffer
mediaBuffer :: HasMediaBuffer s t => Lens s t (MediaBufferFrom s) (MediaBufferTo t)

-- | Like <a>HasMediaBuffer</a> but with <tt>s ~ t</tt> and
--   <tt>MediaBufferFrom s ~ MediaBufferTo t</tt>
type HasMediaBuffer' s = (HasMediaBuffer s s, MediaBufferFrom s ~ MediaBufferTo s)

-- | Like <a>HasMediaBuffer</a> but with the typical lens type parameters
--   <tt>s t a b</tt>
type HasMediaBufferL s t a b = (HasMediaBuffer s t, MediaBufferFrom s ~ a, MediaBufferTo t ~ b)

-- | Like <a>HasMediaBufferL</a> but with the typical **simple** lens type
--   parameters <tt>s a</tt>
type HasMediaBufferL' s a = (HasMediaBuffer s s, MediaBufferFrom s ~ a, MediaBufferTo s ~ a)

-- | Like <a>mediaBuffer</a> but with <tt>s ~ t</tt> and
--   <tt>MediaBufferFrom s ~ MediaBufferTo t</tt>
mediaBuffer' :: HasMediaBuffer' s => Lens' s (MediaBufferFrom s)

-- | A buffer for media data. The type parameter <tt>t</tt> is supposed to
--   be an instance of <tt>IsMedia</tt>.
newtype MediaBuffer t
MkMediaBuffer :: Vector t -> MediaBuffer t

-- | <a>MediaBuffer</a> to <tt>Vector</tt> isomorphism
mediaBufferVector :: Iso (MediaBuffer s) (MediaBuffer t) (Vector s) (Vector t)

-- | Return the number of <tt>BufferElement</tt>s in the <a>MediaBuffer</a>
--   buffer.
mediaBufferLength :: CanBeSample t => MediaBuffer t -> Int

-- | Create a <a>MediaBuffer</a> from a list in O(n).
mediaBufferFromList :: CanBeSample s => [s] -> MediaBuffer s

-- | Convert the media buffer vector contents to a list in O(n).
mediaBufferToList :: CanBeSample s => MediaBuffer s -> [s]

-- | An efficient conversion of a <tt>ByteString</tt> to a
--   <a>MediaBuffer</a>
mediaBufferFromByteString :: CanBeSample a => ByteString -> MediaBuffer a

-- | An efficient conversion of a <a>MediaBuffer</a> to a
--   <tt>ByteString</tt>
mediaBufferToByteString :: CanBeSample a => MediaBuffer a -> ByteString

-- | Create a new <a>MediaBuffer</a> using an <a>ST</a> action that returns
--   a mutable <tt>MVector</tt>.
createMediaBuffer :: CanBeSample t => (forall s. ST s (MVector s t)) -> MediaBuffer t

-- | Modify the underlying <tt>Vector</tt> of some <a>MediaBuffer</a> with
--   a function that is applied to the mutable vector of that
--   <a>MediaBuffer</a>. The function must result in a <a>ST</a> action
--   that does the modifications.
modifyMediaBuffer :: CanBeSample a => (forall s. MVector s a -> ST s ()) -> MediaBuffer a -> MediaBuffer a

-- | Modify the underlying <tt>Vector</tt> of some <a>MediaBuffer</a> with
--   a function that is applied to the mutable vector of that
--   <a>MediaBuffer</a>. The function must result in a <a>ST</a> action
--   that does the modifications.
--   
--   Unsafe because results can be returned, so the <i>thawn</i> mutable
--   vector might escape.
unsafeModifyMediaBuffer :: CanBeSample a => (forall s. MVector s a -> ST s r) -> MediaBuffer a -> (r, MediaBuffer a)
instance (GHC.Classes.Eq t, Foreign.Storable.Storable t) => GHC.Classes.Eq (Data.MediaBus.Media.Buffer.MediaBuffer t)
instance Foreign.Storable.Storable t => GHC.Base.Monoid (Data.MediaBus.Media.Buffer.MediaBuffer t)
instance Control.DeepSeq.NFData (Data.MediaBus.Media.Buffer.MediaBuffer t)
instance GHC.Generics.Generic (Data.MediaBus.Media.Buffer.MediaBuffer t)
instance (Foreign.Storable.Storable a, Foreign.Storable.Storable b) => Control.Lens.Each.Each (Data.MediaBus.Media.Buffer.MediaBuffer a) (Data.MediaBus.Media.Buffer.MediaBuffer b) a b
instance Data.MediaBus.Media.Samples.CanBeSample s => GHC.Exts.IsList (Data.MediaBus.Media.Buffer.MediaBuffer s)
instance (GHC.Show.Show a, Data.MediaBus.Media.Samples.CanBeSample a) => GHC.Show.Show (Data.MediaBus.Media.Buffer.MediaBuffer a)
instance Data.MediaBus.Media.Samples.CanBeSample sampleType => Data.Default.Class.Default (Data.MediaBus.Media.Buffer.MediaBuffer sampleType)


-- | Discontinous content. Some media streams, like e.g. RTP streams
--   received via UDP, have the characteristic, that some times packages
--   are lost. This module provides a type that is isomorphic to
--   <a>Maybe</a> to indicate that the content for a media frame is
--   missing. It might take some effort to detect missing content, like a
--   jitter buffer, or the comparison of sequence numbers.
--   
--   TODO: Create a gap detection mechanism, a simple stateful monad that
--   knows the next timestamp etc.
module Data.MediaBus.Media.Discontinous

-- | Content that can be <a>Missing</a>.
data Discontinous a

-- | A place holder for frame content that is missing
Missing :: Discontinous a

-- | Available content
Got :: !a -> Discontinous a
_Missing :: forall a_aEbS. Prism' (Discontinous a_aEbS) ()
_Got :: forall a_aEbS a_aEE9. Prism (Discontinous a_aEE9) (Discontinous a_aEbS) a_aEE9 a_aEbS
instance Data.MediaBus.Basics.Ticks.HasDuration a => Data.MediaBus.Basics.Ticks.HasDuration (Data.MediaBus.Media.Discontinous.Discontinous a)
instance Data.MediaBus.Media.Media.EachMedia a b => Data.MediaBus.Media.Media.EachMedia (Data.MediaBus.Media.Discontinous.Discontinous a) (Data.MediaBus.Media.Discontinous.Discontinous b)
instance Data.MediaBus.Media.Samples.EachSample a b => Data.MediaBus.Media.Samples.EachSample (Data.MediaBus.Media.Discontinous.Discontinous a) (Data.MediaBus.Media.Discontinous.Discontinous b)
instance Data.MediaBus.Media.Channels.EachChannel a b => Data.MediaBus.Media.Channels.EachChannel (Data.MediaBus.Media.Discontinous.Discontinous a) (Data.MediaBus.Media.Discontinous.Discontinous b)
instance Data.MediaBus.Basics.Ticks.HasRate c => Data.MediaBus.Basics.Ticks.HasRate (Data.MediaBus.Media.Discontinous.Discontinous c)
instance (Data.MediaBus.Basics.Ticks.HasRate i, Data.MediaBus.Basics.Ticks.GetRate i ~ ri, Data.MediaBus.Basics.Ticks.SetRate i rj ~ j, Data.MediaBus.Basics.Ticks.KnownRate rj, Data.MediaBus.Basics.Ticks.CoerceRate i j ri rj) => Data.MediaBus.Basics.Ticks.CoerceRate (Data.MediaBus.Media.Discontinous.Discontinous i) (Data.MediaBus.Media.Discontinous.Discontinous j) ri rj
instance GHC.Generics.Generic (Data.MediaBus.Media.Discontinous.Discontinous a)
instance GHC.Show.Show a => GHC.Show.Show (Data.MediaBus.Media.Discontinous.Discontinous a)
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Data.MediaBus.Media.Discontinous.Discontinous a)
instance Data.Default.Class.Default (Data.MediaBus.Media.Discontinous.Discontinous a)


-- | Media segments with a fixed duration
module Data.MediaBus.Media.Segment

-- | A segment is some content with a fixed (type level) duration.
newtype Segment (duration :: StaticTicks) c
MkSegment :: c -> Segment c

-- | An <a>Iso</a> for the <a>Segment</a> newtype.
segmentContent :: Iso (Segment d c) (Segment d c') c c'

-- | Class of types that support splitting values into parts with a certain
--   duration.
class CanSegment a

-- | Try to split the packet into the a part which has the given duration
--   and a rest. If it is not possible to split of the desired duration,
--   e.g. because the input data is too short, return <a>Nothing</a>.
splitAfterDuration :: (CanSegment a, HasStaticDuration d) => proxy d -> a -> Maybe (Segment d a, a)
instance GHC.Classes.Eq c => GHC.Classes.Eq (Data.MediaBus.Media.Segment.Segment duration c)
instance GHC.Base.Functor (Data.MediaBus.Media.Segment.Segment duration)
instance Test.QuickCheck.Arbitrary.Arbitrary c => Test.QuickCheck.Arbitrary.Arbitrary (Data.MediaBus.Media.Segment.Segment duration c)
instance Data.Default.Class.Default c => Data.Default.Class.Default (Data.MediaBus.Media.Segment.Segment duration c)
instance Control.DeepSeq.NFData c => Control.DeepSeq.NFData (Data.MediaBus.Media.Segment.Segment duration c)
instance Data.MediaBus.Media.Media.HasMedia c c' => Data.MediaBus.Media.Media.HasMedia (Data.MediaBus.Media.Segment.Segment d c) (Data.MediaBus.Media.Segment.Segment d c')
instance Data.MediaBus.Media.Samples.EachSample c c' => Data.MediaBus.Media.Samples.EachSample (Data.MediaBus.Media.Segment.Segment d c) (Data.MediaBus.Media.Segment.Segment d c')
instance Data.MediaBus.Media.Channels.EachChannel c c' => Data.MediaBus.Media.Channels.EachChannel (Data.MediaBus.Media.Segment.Segment d c) (Data.MediaBus.Media.Segment.Segment d c')
instance Data.MediaBus.Basics.Ticks.HasRate c => Data.MediaBus.Basics.Ticks.HasRate (Data.MediaBus.Media.Segment.Segment d c)
instance (Data.MediaBus.Basics.Ticks.HasRate i, Data.MediaBus.Basics.Ticks.GetRate i ~ ri, Data.MediaBus.Basics.Ticks.SetRate i rj ~ j, Data.MediaBus.Basics.Ticks.KnownRate rj, Data.MediaBus.Basics.Ticks.CoerceRate i j ri rj) => Data.MediaBus.Basics.Ticks.CoerceRate (Data.MediaBus.Media.Segment.Segment d i) (Data.MediaBus.Media.Segment.Segment d j) ri rj
instance (Data.MediaBus.Basics.Ticks.HasStaticDuration Data.MediaBus.Basics.Ticks.StaticTicks d, GHC.Show.Show c) => GHC.Show.Show (Data.MediaBus.Media.Segment.Segment d c)
instance Data.MediaBus.Basics.Ticks.KnownStaticTicks d => Data.MediaBus.Basics.Ticks.HasStaticDuration * (Data.MediaBus.Media.Segment.Segment d x)
instance Data.MediaBus.Basics.Ticks.HasStaticDuration Data.MediaBus.Basics.Ticks.StaticTicks d => Data.MediaBus.Basics.Ticks.HasDuration (Data.MediaBus.Media.Segment.Segment d x)


-- | Type class for media content that has <i>blank</i> values, that
--   represent a neutral media content such as silence or a black image.
module Data.MediaBus.Media.Blank

-- | Types that have a dynamic duration, for example a audio sample
--   buffers, can implement this type class to provide methods for
--   generating blank media content (e.g. silence) for a certain duration.
class CanGenerateBlankMedia a where blankFor dt = blankForTicks (nominalDiffTime # dt :: PicoSeconds) blankForTicks ticks = blankFor (from nominalDiffTime # ticks)

-- | Generate the value that represents neutral media content, and has at
--   least the given duration.
blankFor :: CanGenerateBlankMedia a => NominalDiffTime -> a

-- | Generate the value that represents neutral media content, and has at
--   least the given duration given as <a>Ticks</a>
blankForTicks :: (CanGenerateBlankMedia a, CanBeTicks r i) => Ticks r i -> a

-- | Types that can have <i>blank</i> values.
class CanBeBlank a

-- | Generate the value that represents neutral media content.
blank :: CanBeBlank a => a
instance (Data.MediaBus.Basics.Ticks.HasStaticDuration Data.MediaBus.Basics.Ticks.StaticTicks d, Data.MediaBus.Media.Blank.CanGenerateBlankMedia a) => Data.MediaBus.Media.Blank.CanBeBlank (Data.MediaBus.Media.Segment.Segment d a)


-- | Sub-types of <a>Audio</a> for uncompressed audio.
module Data.MediaBus.Media.Audio.Raw

-- | An indicator for uncompressed audio with a given per sample encoding
--   type.
data Raw encoding

-- | A family of multi-channel audio samples, this will be stored in a
--   <a>MediaBuffer</a> if audio is represented by <tt>Audio r (Pcm c
--   t)</tt>

-- | An isomorphism for <a>Audio</a> and <a>MediaBuffer</a>
pcmMediaBuffer :: Iso (Audio r c (Raw t)) (Audio r' c' (Raw t')) (MediaBuffer (Pcm c t)) (MediaBuffer (Pcm c' t'))

-- | Types of per channel PCM audio sample value.
class (CanBeBlank a, CanBeSample a, Arbitrary a) => IsPcmValue a

-- | Calculate the average of two pcm samples
pcmAverage :: IsPcmValue a => a -> a -> a
instance (Data.MediaBus.Basics.Ticks.KnownRate r, Data.MediaBus.Media.Samples.CanBeSample (Data.MediaBus.Media.Audio.Raw.Pcm c t), Data.MediaBus.Media.Blank.CanBeBlank (Data.MediaBus.Media.Audio.Raw.Pcm c t)) => Data.MediaBus.Media.Blank.CanGenerateBlankMedia (Data.MediaBus.Media.Audio.Audio r c (Data.MediaBus.Media.Audio.Raw.Raw * t))
instance (Data.MediaBus.Basics.Ticks.KnownRate r, Data.MediaBus.Media.Samples.CanBeSample (Data.MediaBus.Media.Audio.Raw.Pcm c t)) => Data.MediaBus.Basics.Ticks.HasDuration (Data.MediaBus.Media.Audio.Audio r c (Data.MediaBus.Media.Audio.Raw.Raw * t))
instance Data.MediaBus.Media.Samples.CanBeSample (Data.MediaBus.Media.Audio.Raw.Pcm c t) => Control.DeepSeq.NFData (Data.MediaBus.Media.Audio.Audio r c (Data.MediaBus.Media.Audio.Raw.Raw * t))
instance Data.MediaBus.Media.Samples.CanBeSample (Data.MediaBus.Media.Audio.Raw.Pcm c t) => GHC.Classes.Eq (Data.MediaBus.Media.Audio.Audio r c (Data.MediaBus.Media.Audio.Raw.Raw * t))
instance (Data.Typeable.Internal.Typeable * t, Data.MediaBus.Basics.Ticks.KnownRate r, Data.MediaBus.Media.Channels.KnownChannelLayout * c, Data.MediaBus.Media.Samples.CanBeSample (Data.MediaBus.Media.Audio.Raw.Pcm c t)) => Data.MediaBus.Media.Media.IsMedia (Data.MediaBus.Media.Audio.Audio r c (Data.MediaBus.Media.Audio.Raw.Raw * t))
instance forall k (t :: k) (r :: Data.MediaBus.Basics.Ticks.Rate) c. (Data.Typeable.Internal.Typeable k t, Data.MediaBus.Basics.Ticks.KnownRate r, Data.MediaBus.Media.Channels.KnownChannelLayout * c) => GHC.Show.Show (Data.MediaBus.Media.Media.MediaDescription * (Data.MediaBus.Media.Audio.Audio r c (Data.MediaBus.Media.Audio.Raw.Raw k t)))
instance (Data.Typeable.Internal.Typeable * t, Data.MediaBus.Basics.Ticks.KnownRate r, Data.MediaBus.Media.Channels.KnownChannelLayout * c, Data.MediaBus.Media.Samples.CanBeSample (Data.MediaBus.Media.Audio.Raw.Pcm c t), GHC.Show.Show (Data.MediaBus.Media.Audio.Raw.Pcm c t)) => GHC.Show.Show (Data.MediaBus.Media.Audio.Audio r c (Data.MediaBus.Media.Audio.Raw.Raw * t))
instance (Data.MediaBus.Media.Samples.CanBeSample (Data.MediaBus.Media.Audio.Raw.Pcm ca a), Data.MediaBus.Media.Samples.CanBeSample (Data.MediaBus.Media.Audio.Raw.Pcm cb b)) => Data.MediaBus.Media.Buffer.HasMediaBuffer (Data.MediaBus.Media.Audio.Audio r ca (Data.MediaBus.Media.Audio.Raw.Raw * a)) (Data.MediaBus.Media.Audio.Audio r' cb (Data.MediaBus.Media.Audio.Raw.Raw * b))
instance (Data.MediaBus.Media.Samples.CanBeSample (Data.MediaBus.Media.Audio.Raw.Pcm c t), Data.MediaBus.Media.Samples.CanBeSample (Data.MediaBus.Media.Audio.Raw.Pcm c' t')) => Data.MediaBus.Media.Samples.EachSample (Data.MediaBus.Media.Audio.Audio r c (Data.MediaBus.Media.Audio.Raw.Raw * t)) (Data.MediaBus.Media.Audio.Audio r' c' (Data.MediaBus.Media.Audio.Raw.Raw * t'))
instance (Data.MediaBus.Media.Samples.CanBeSample (Data.MediaBus.Media.Audio.Raw.Pcm c t), Data.MediaBus.Media.Samples.CanBeSample (Data.MediaBus.Media.Audio.Raw.Pcm c' t'), Data.MediaBus.Media.Samples.EachSampleL (Data.MediaBus.Media.Audio.Audio r c (Data.MediaBus.Media.Audio.Raw.Raw * t)) (Data.MediaBus.Media.Audio.Audio r' c' (Data.MediaBus.Media.Audio.Raw.Raw * t')) (Data.MediaBus.Media.Audio.Raw.Pcm c t) (Data.MediaBus.Media.Audio.Raw.Pcm c' t'), Data.MediaBus.Media.Channels.EachChannelL (Data.MediaBus.Media.Audio.Raw.Pcm c t) (Data.MediaBus.Media.Audio.Raw.Pcm c' t') t t') => Data.MediaBus.Media.Channels.EachChannel (Data.MediaBus.Media.Audio.Audio r c (Data.MediaBus.Media.Audio.Raw.Raw * t)) (Data.MediaBus.Media.Audio.Audio r' c' (Data.MediaBus.Media.Audio.Raw.Raw * t'))
instance (Data.MediaBus.Media.Samples.CanBeSample (Data.MediaBus.Media.Audio.Raw.Pcm c t), Data.MediaBus.Basics.Ticks.KnownRate r) => Data.MediaBus.Media.Segment.CanSegment (Data.MediaBus.Media.Audio.Audio r c (Data.MediaBus.Media.Audio.Raw.Raw * t))
instance Data.MediaBus.Media.Samples.CanBeSample (Data.MediaBus.Media.Audio.Raw.Pcm c t) => GHC.Base.Monoid (Data.MediaBus.Media.Audio.Audio r c (Data.MediaBus.Media.Audio.Raw.Raw * t))


-- | Single channel (Mono) PCM audio
module Data.MediaBus.Media.Audio.Raw.Mono

-- | The channel layout indicator type for **mono** audio
data Mono
instance GHC.Enum.Enum s => GHC.Enum.Enum (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Mono.Mono s)
instance GHC.Real.Real s => GHC.Real.Real (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Mono.Mono s)
instance GHC.Real.Integral s => GHC.Real.Integral (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Mono.Mono s)
instance GHC.Classes.Ord s => GHC.Classes.Ord (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Mono.Mono s)
instance GHC.Num.Num s => GHC.Num.Num (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Mono.Mono s)
instance Data.MediaBus.Media.Audio.Raw.IsPcmValue s => Data.MediaBus.Media.Audio.Raw.IsPcmValue (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Mono.Mono s)
instance Test.QuickCheck.Arbitrary.Arbitrary s => Test.QuickCheck.Arbitrary.Arbitrary (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Mono.Mono s)
instance Data.Default.Class.Default s => Data.Default.Class.Default (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Mono.Mono s)
instance Foreign.Storable.Storable s => Foreign.Storable.Storable (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Mono.Mono s)
instance GHC.Classes.Eq s => GHC.Classes.Eq (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Mono.Mono s)
instance Control.DeepSeq.NFData s => Control.DeepSeq.NFData (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Mono.Mono s)
instance Data.MediaBus.Media.Blank.CanBeBlank s => Data.MediaBus.Media.Blank.CanBeBlank (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Mono.Mono s)
instance Data.MediaBus.Media.Channels.KnownChannelLayout * Data.MediaBus.Media.Audio.Raw.Mono.Mono
instance (Data.MediaBus.Media.Audio.Raw.IsPcmValue a, Data.MediaBus.Media.Audio.Raw.IsPcmValue b) => Data.MediaBus.Media.Channels.EachChannel (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Mono.Mono a) (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Mono.Mono b)
instance GHC.Show.Show s => GHC.Show.Show (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Mono.Mono s)


-- | This module defines the 16-bit PCM audio sample type.
module Data.MediaBus.Media.Audio.Raw.Signed16bit

-- | A value representing a signed PCM audio sample with a width of 16 bit.
newtype S16
MkS16 :: Int16 -> S16

-- | An <a>Iso</a> from/to the sample value of an <a>S16</a>
s16Sample :: Iso' S16 Int16
instance Data.Default.Class.Default Data.MediaBus.Media.Audio.Raw.Signed16bit.S16
instance GHC.Num.Num Data.MediaBus.Media.Audio.Raw.Signed16bit.S16
instance Foreign.Storable.Storable Data.MediaBus.Media.Audio.Raw.Signed16bit.S16
instance Control.DeepSeq.NFData Data.MediaBus.Media.Audio.Raw.Signed16bit.S16
instance Data.Bits.Bits Data.MediaBus.Media.Audio.Raw.Signed16bit.S16
instance Test.QuickCheck.Arbitrary.Arbitrary Data.MediaBus.Media.Audio.Raw.Signed16bit.S16
instance GHC.Classes.Ord Data.MediaBus.Media.Audio.Raw.Signed16bit.S16
instance GHC.Classes.Eq Data.MediaBus.Media.Audio.Raw.Signed16bit.S16
instance GHC.Show.Show Data.MediaBus.Media.Audio.Raw.Signed16bit.S16
instance Data.MediaBus.Media.Blank.CanBeBlank Data.MediaBus.Media.Audio.Raw.Signed16bit.S16
instance Data.MediaBus.Media.Audio.Raw.IsPcmValue Data.MediaBus.Media.Audio.Raw.Signed16bit.S16


-- | This module defines the **Alaw** audio sample type, as well as
--   compading conversion functions from/to <a>S16</a> values.
module Data.MediaBus.Media.Audio.Raw.Alaw

-- | A PCM audio sample represented by a single byte, that can be converted
--   to a signed 13bit audio sample.
data ALaw

-- | See
--   <a>http://opensource.apple.com//source/tcl/tcl-20/tcl_ext/snack/snack/generic/g711.c</a>
--   
--   <pre>
--   Linear Input Code	 Compressed Code
--   -----------------  ---------------
--     0000000wxyza         000wxyz
--     0000001wxyza         001wxyz
--     000001wxyzab         010wxyz
--     00001wxyzabc         011wxyz
--     0001wxyzabcd         100wxyz
--     001wxyzabcde         101wxyz
--     01wxyzabcdef         110wxyz
--     1wxyzabcdefg         111wxyz
--   </pre>
--   
--   For further information see John C. Bellamy's Digital Telephony, 1982,
--   John Wiley &amp; Sons, pps 98-111 and 472-476.
encodeALawSample :: S16 -> ALaw

-- | Uncompress an alaw sample into a linear 16 signed value, see
--   <a>encodeALawSample</a> for more information.
decodeALawSample :: ALaw -> S16

-- | An <a>Iso</a> between <a>ALaw</a> and <a>S16</a> using
--   <a>encodeALawSample</a> and <a>decodeALawSample</a>.
alawSample :: Iso' ALaw S16

-- | An <a>Iso</a> for <a>ALaw</a> sample values.
alawValue :: Iso' ALaw Word8
instance Data.Default.Class.Default Data.MediaBus.Media.Audio.Raw.Alaw.ALaw
instance Control.DeepSeq.NFData Data.MediaBus.Media.Audio.Raw.Alaw.ALaw
instance GHC.Generics.Generic Data.MediaBus.Media.Audio.Raw.Alaw.ALaw
instance Test.QuickCheck.Arbitrary.Arbitrary Data.MediaBus.Media.Audio.Raw.Alaw.ALaw
instance Data.Bits.Bits Data.MediaBus.Media.Audio.Raw.Alaw.ALaw
instance GHC.Classes.Eq Data.MediaBus.Media.Audio.Raw.Alaw.ALaw
instance GHC.Num.Num Data.MediaBus.Media.Audio.Raw.Alaw.ALaw
instance Foreign.Storable.Storable Data.MediaBus.Media.Audio.Raw.Alaw.ALaw
instance GHC.Show.Show Data.MediaBus.Media.Audio.Raw.Alaw.ALaw
instance Data.MediaBus.Media.Blank.CanBeBlank Data.MediaBus.Media.Audio.Raw.Alaw.ALaw
instance Data.MediaBus.Media.Audio.Raw.IsPcmValue Data.MediaBus.Media.Audio.Raw.Alaw.ALaw


-- | Stereo PCM audio
module Data.MediaBus.Media.Audio.Raw.Stereo

-- | The channel layout indicator type for **stereo** audio
data Stereo
instance GHC.Generics.Generic (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Stereo.Stereo t)
instance GHC.Classes.Ord t => GHC.Classes.Ord (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Stereo.Stereo t)
instance GHC.Classes.Eq t => GHC.Classes.Eq (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Stereo.Stereo t)
instance Data.MediaBus.Media.Channels.KnownChannelLayout * Data.MediaBus.Media.Audio.Raw.Stereo.Stereo
instance Control.DeepSeq.NFData t => Control.DeepSeq.NFData (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Stereo.Stereo t)
instance Test.QuickCheck.Arbitrary.Arbitrary t => Test.QuickCheck.Arbitrary.Arbitrary (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Stereo.Stereo t)
instance Data.MediaBus.Media.Channels.EachChannel (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Stereo.Stereo a) (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Stereo.Stereo b)
instance GHC.Show.Show a => GHC.Show.Show (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Stereo.Stereo a)
instance Data.MediaBus.Media.Audio.Raw.IsPcmValue a => Data.MediaBus.Media.Audio.Raw.IsPcmValue (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Stereo.Stereo a)
instance Data.MediaBus.Media.Blank.CanBeBlank a => Data.MediaBus.Media.Blank.CanBeBlank (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Stereo.Stereo a)
instance Data.Default.Class.Default a => Data.Default.Class.Default (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Stereo.Stereo a)
instance Foreign.Storable.Storable s => Foreign.Storable.Storable (Data.MediaBus.Media.Audio.Raw.Pcm Data.MediaBus.Media.Audio.Raw.Stereo.Stereo s)


-- | A media <a>Stream</a> is often represented by a <a>Series</a> of
--   related <a>Frame</a>s with a <a>FrameCtx</a> created when the
--   <a>Stream</a> <a>Start</a>s. This module contains the basic
--   definitions of the building blocks of media content that is create,
--   processed, and presented by a possibly infinite <a>Series</a> of
--   chunks called <a>Frame</a>s.
module Data.MediaBus.Media.Stream

-- | Meta information about a media stream.
data FrameCtx i s t p
MkFrameCtx :: !i -> !t -> !s -> !p -> FrameCtx i s t p
frameCtxSourceId :: forall i_aT61 s_aT62 t_aT63 p_aT64 i_aTfG. Lens (FrameCtx i_aT61 s_aT62 t_aT63 p_aT64) (FrameCtx i_aTfG s_aT62 t_aT63 p_aT64) i_aT61 i_aTfG
frameCtxSeqNumRef :: forall i_aT61 s_aT62 t_aT63 p_aT64 s_aTfF. Lens (FrameCtx i_aT61 s_aT62 t_aT63 p_aT64) (FrameCtx i_aT61 s_aTfF t_aT63 p_aT64) s_aT62 s_aTfF
frameCtxTimestampRef :: forall i_aT61 s_aT62 t_aT63 p_aT64 t_aTfH. Lens (FrameCtx i_aT61 s_aT62 t_aT63 p_aT64) (FrameCtx i_aT61 s_aT62 t_aTfH p_aT64) t_aT63 t_aTfH
frameCtxInit :: forall i_aT61 s_aT62 t_aT63 p_aT64 p_aTfE. Lens (FrameCtx i_aT61 s_aT62 t_aT63 p_aT64) (FrameCtx i_aT61 s_aT62 t_aT63 p_aTfE) p_aT64 p_aTfE

-- | Class for types that have a <a>Traversal</a> for
--   <a>$sel:_frameCtxInit:MkFrameCtx</a>
class EachFrameCtxInit s t where type FrameCtxInitFrom s type FrameCtxInitTo t where {
    type family FrameCtxInitFrom s;
    type family FrameCtxInitTo t;
}

-- | A traversal for the <a>FrameCtx</a> initial content, skipping over any
--   <a>Frame</a>
eachFrameCtxInit :: EachFrameCtxInit s t => Traversal s t (FrameCtxInitFrom s) (FrameCtxInitTo t)

-- | A <a>Frame</a> can be anything that has a start time and is exactly
--   one time unit long, it can respresent anything ranging from an audio
--   buffer with 20ms of audio to a single pulse coded audio sample, of
--   course it could also be a video frame or a chat message.
data Frame s t c
MkFrame :: !t -> !s -> !c -> Frame s t c

-- | Class for types that have a <a>Traversal</a> for
--   <a>$sel:_framePayload:MkFrame</a>
class EachFrameContent s t where type FrameContentFrom s type FrameContentTo t where {
    type family FrameContentFrom s;
    type family FrameContentTo t;
}

-- | A traversal for the frame content of all <a>Frame</a>s, skipping over
--   any <a>FrameCtx</a>
eachFrameContent :: EachFrameContent s t => Traversal s t (FrameContentFrom s) (FrameContentTo t)
frameSeqNum :: forall s_aTgj t_aTgk c_aTgl s_aTwX. Lens (Frame s_aTgj t_aTgk c_aTgl) (Frame s_aTwX t_aTgk c_aTgl) s_aTgj s_aTwX
frameTimestamp :: forall s_aTgj t_aTgk c_aTgl t_aTwY. Lens (Frame s_aTgj t_aTgk c_aTgl) (Frame s_aTgj t_aTwY c_aTgl) t_aTgk t_aTwY
framePayload :: forall s_aTgj t_aTgk c_aTgl c_aTwW. Lens (Frame s_aTgj t_aTgk c_aTgl) (Frame s_aTgj t_aTgk c_aTwW) c_aTgl c_aTwW

-- | A type for values that belong to a <a>Series</a> of <a>Frame</a>s
--   started by a <a>FrameCtx</a>. This combines the sum type <a>Series</a>
--   which has either <a>Start</a> or <a>Next</a> with <a>FrameCtx</a> and
--   <a>Frame</a>.
newtype Stream i s t p c
MkStream :: Streamish i s t p c -> Stream i s t p c

-- | This is the type alias that <a>Stream</a> is a newtype wrapper of, see
--   the description of <a>Stream</a>.
type Streamish i s t p c = Series (FrameCtx i s t p) (Frame s t c)
stream :: forall i_aTxu s_aTxv t_aTxw p_aTxx c_aTxy i_aTWU s_aTWV t_aTWW p_aTWX c_aTWY. Iso (Stream i_aTxu s_aTxv t_aTxw p_aTxx c_aTxy) (Stream i_aTWU s_aTWV t_aTWW p_aTWX c_aTWY) (Streamish i_aTxu s_aTxv t_aTxw p_aTxx c_aTxy) (Streamish i_aTWU s_aTWV t_aTWW p_aTWX c_aTWY)
instance Data.MediaBus.Media.Channels.EachChannel (Data.MediaBus.Media.Stream.Frame s t c) (Data.MediaBus.Media.Stream.Frame s t c') => Data.MediaBus.Media.Channels.EachChannel (Data.MediaBus.Media.Stream.Stream i s t p c) (Data.MediaBus.Media.Stream.Stream i s t p c')
instance Data.MediaBus.Basics.Ticks.HasDuration c => Data.MediaBus.Basics.Ticks.HasDuration (Data.MediaBus.Media.Stream.Stream i s t p c)
instance Data.MediaBus.Basics.Sequence.HasSeqNum (Data.MediaBus.Media.Stream.Stream i s t p c)
instance Data.MediaBus.Basics.Ticks.HasTimestamp (Data.MediaBus.Media.Stream.Stream i s t p c)
instance Data.MediaBus.Media.Stream.EachFrameContent (Data.MediaBus.Media.Stream.Stream i s t p c) (Data.MediaBus.Media.Stream.Stream i s t p c')
instance (Data.Default.Class.Default c, Data.Default.Class.Default s, Data.Default.Class.Default t) => Data.Default.Class.Default (Data.MediaBus.Media.Stream.Stream i s t p c)
instance (GHC.Show.Show i, GHC.Show.Show s, GHC.Show.Show t, GHC.Show.Show c, GHC.Show.Show p) => GHC.Show.Show (Data.MediaBus.Media.Stream.Stream i s t p c)
instance GHC.Generics.Generic (Data.MediaBus.Media.Stream.Stream i s t p c)
instance (Test.QuickCheck.Arbitrary.Arbitrary c, Test.QuickCheck.Arbitrary.Arbitrary p, Test.QuickCheck.Arbitrary.Arbitrary t, Test.QuickCheck.Arbitrary.Arbitrary s, Test.QuickCheck.Arbitrary.Arbitrary i) => Test.QuickCheck.Arbitrary.Arbitrary (Data.MediaBus.Media.Stream.Stream i s t p c)
instance (GHC.Classes.Eq c, GHC.Classes.Eq i, GHC.Classes.Eq t, GHC.Classes.Eq s, GHC.Classes.Eq p) => GHC.Classes.Eq (Data.MediaBus.Media.Stream.Stream i s t p c)
instance (GHC.Classes.Ord c, GHC.Classes.Ord i, GHC.Classes.Ord t, GHC.Classes.Ord s, GHC.Classes.Ord p) => GHC.Classes.Ord (Data.MediaBus.Media.Stream.Stream i s t p c)
instance Data.MediaBus.Media.Stream.EachFrameContent (Data.MediaBus.Media.Stream.Frame s t c) (Data.MediaBus.Media.Stream.Frame s t c')
instance Data.MediaBus.Media.Channels.EachChannel c c' => Data.MediaBus.Media.Channels.EachChannel (Data.MediaBus.Media.Stream.Frame s t c) (Data.MediaBus.Media.Stream.Frame s t c')
instance Data.MediaBus.Media.Media.HasMedia c c' => Data.MediaBus.Media.Media.HasMedia (Data.MediaBus.Media.Stream.Frame s t c) (Data.MediaBus.Media.Stream.Frame s t c')
instance Data.MediaBus.Basics.Ticks.HasTimestamp (Data.MediaBus.Media.Stream.Frame s t c)
instance Data.MediaBus.Basics.Sequence.HasSeqNum (Data.MediaBus.Media.Stream.Frame s t c)
instance Data.MediaBus.Basics.Ticks.HasDuration c => Data.MediaBus.Basics.Ticks.HasDuration (Data.MediaBus.Media.Stream.Frame s t c)
instance (Test.QuickCheck.Arbitrary.Arbitrary c, Test.QuickCheck.Arbitrary.Arbitrary s, Test.QuickCheck.Arbitrary.Arbitrary t) => Test.QuickCheck.Arbitrary.Arbitrary (Data.MediaBus.Media.Stream.Frame s t c)
instance (Data.Default.Class.Default s, Data.Default.Class.Default t, Data.Default.Class.Default c) => Data.Default.Class.Default (Data.MediaBus.Media.Stream.Frame s t c)
instance (GHC.Show.Show s, GHC.Show.Show t, GHC.Show.Show v) => GHC.Show.Show (Data.MediaBus.Media.Stream.Frame s t v)
instance (Control.DeepSeq.NFData i, Control.DeepSeq.NFData s, Control.DeepSeq.NFData t, Control.DeepSeq.NFData c, Control.DeepSeq.NFData p) => Control.DeepSeq.NFData (Data.MediaBus.Media.Stream.Stream i s t p c)
instance GHC.Generics.Generic (Data.MediaBus.Media.Stream.Frame s t c)
instance (GHC.Classes.Ord c, GHC.Classes.Ord s, GHC.Classes.Ord t) => GHC.Classes.Ord (Data.MediaBus.Media.Stream.Frame s t c)
instance (GHC.Classes.Eq c, GHC.Classes.Eq s, GHC.Classes.Eq t) => GHC.Classes.Eq (Data.MediaBus.Media.Stream.Frame s t c)
instance GHC.Base.Functor (Data.MediaBus.Media.Stream.Frame s t)
instance Data.MediaBus.Basics.Ticks.HasTimestamp (Data.MediaBus.Media.Stream.FrameCtx i s t p)
instance Data.MediaBus.Basics.Ticks.HasDuration (Data.MediaBus.Media.Stream.FrameCtx i s t p)
instance Data.MediaBus.Basics.Sequence.HasSeqNum (Data.MediaBus.Media.Stream.FrameCtx i s t p)
instance (Test.QuickCheck.Arbitrary.Arbitrary i, Test.QuickCheck.Arbitrary.Arbitrary s, Test.QuickCheck.Arbitrary.Arbitrary t, Test.QuickCheck.Arbitrary.Arbitrary p) => Test.QuickCheck.Arbitrary.Arbitrary (Data.MediaBus.Media.Stream.FrameCtx i s t p)
instance (Data.Default.Class.Default i, Data.Default.Class.Default s, Data.Default.Class.Default t, Data.Default.Class.Default p) => Data.Default.Class.Default (Data.MediaBus.Media.Stream.FrameCtx i s t p)
instance (GHC.Show.Show i, GHC.Show.Show s, GHC.Show.Show t, GHC.Show.Show p) => GHC.Show.Show (Data.MediaBus.Media.Stream.FrameCtx i s t p)
instance (Control.DeepSeq.NFData c, Control.DeepSeq.NFData s, Control.DeepSeq.NFData t) => Control.DeepSeq.NFData (Data.MediaBus.Media.Stream.Frame s t c)
instance GHC.Generics.Generic (Data.MediaBus.Media.Stream.FrameCtx i s t p)
instance (GHC.Classes.Ord p, GHC.Classes.Ord s, GHC.Classes.Ord t, GHC.Classes.Ord i) => GHC.Classes.Ord (Data.MediaBus.Media.Stream.FrameCtx i s t p)
instance (GHC.Classes.Eq p, GHC.Classes.Eq s, GHC.Classes.Eq t, GHC.Classes.Eq i) => GHC.Classes.Eq (Data.MediaBus.Media.Stream.FrameCtx i s t p)
instance (Control.DeepSeq.NFData i, Control.DeepSeq.NFData s, Control.DeepSeq.NFData t, Control.DeepSeq.NFData p) => Control.DeepSeq.NFData (Data.MediaBus.Media.Stream.FrameCtx i s t p)


-- | Reorder the <a>Frame</a>s in <a>Conduit</a> of a <a>Stream</a>.
module Data.MediaBus.Conduit.Reorder

-- | Reorder the <a>Frame</a>s in <a>Conduit</a> of a <a>Stream</a>
--   according to the <a>Ord</a> instance of the the sequence numbers of
--   <a>seqNum</a>. This function will buffer e certain number of frames
--   that are out of order, and drops frames if they are too late. Also,
--   when too many consecutive frames have all been dropped, a new
--   <a>Start</a> will be created, and the buffered elements are silently
--   dropped, too. When a <a>Start</a> is received that internal buffer is
--   flushed and all queued frames are transmitted.
reorderFramesBySeqNumC :: (Default s, Default i, Default t, Default p, Num s, Ord s, Monad m) => Int -> Conduit (Stream i s t p c) m (Stream i s t p c)

-- | Like <a>reorderFramesBySeqNumC</a> but more general. This function
--   allows to pass a <a>Lens</a> to the specific field of each
--   <a>Frame</a>, that shall be used for comparison, which governs the
--   order.
reorderFramesByC :: (Monad m, Ord rank, Default i, Default t, Default s, Default p, Default rank) => Lens' (Stream i s t p c) rank -> (rank -> rank) -> Int -> Conduit (Stream i s t p c) m (Stream i s t p c)


-- | Conduit combinators for <a>Stream</a>s
module Data.MediaBus.Conduit.Stream

-- | Yield a <a>Stream</a> from <a>Streamish</a>
yieldStreamish :: Monad m => Streamish i s t p c -> Conduit a m (Stream i s t p c)

-- | Strict version of <a>yieldStreamish</a>
yieldStreamish' :: (NFData i, NFData s, NFData t, NFData c, NFData p, Monad m) => Streamish i s t p c -> Conduit a m (Stream i s t p c)

-- | Yield the next <a>Frame</a> of a <a>Stream</a>
yieldNextFrame :: Monad m => Frame s t c -> Conduit a m (Stream i s t p c)

-- | Strict version of <a>yieldNextFrame</a>
yieldNextFrame' :: (NFData i, NFData s, NFData t, NFData c, NFData p, Monad m) => Frame s t c -> Conduit a m (Stream i s t p c)

-- | Yield the starting <a>FrameCtx</a> of a <a>Stream</a>
yieldStartFrameCtx :: Monad m => FrameCtx i s t p -> Conduit a m (Stream i s t p c)

-- | Strict version of <a>yieldStartFrameCtx</a>
yieldStartFrameCtx' :: (NFData i, NFData s, NFData t, NFData c, NFData p, NFData (FrameCtx i s t p), Monad m) => FrameCtx i s t p -> Conduit a m (Stream i s t p c)

-- | A conduit that receives <a>Stream</a>s and yields all <tt>Frames</tt>
toFramesC :: Monad m => Conduit (Stream i s t p c) m (Frame s t c)

-- | Create a <a>Stream</a> conduit from a <a>Streamish</a> conduit.
overStreamC :: Monad m => Conduit (Streamish i s t p c) m (Streamish i' s' t' p' c') -> Conduit (Stream i s t p c) m (Stream i' s' t' p' c')

-- | A conduit that applies the given function to every <a>Frame</a> of a
--   <a>Stream</a>.
mapFramesC :: Monad m => (Frame s t c -> m (Frame s t c')) -> Conduit (Stream i s t p c) m (Stream i s t p c')

-- | Strict version of <a>mapFramesC</a>
mapFramesC' :: (NFData i, NFData s, NFData t, NFData c', Monad m) => (Frame s t c -> Frame s t c') -> Conduit (Stream i s t p c) m (Stream i s t p c')

-- | A conduit that applies the given function to every sequence number of
--   a <a>Stream</a>, in <a>Frame</a>s as well as <a>FrameCtx</a>s.
mapSeqNumC :: Monad m => (s -> s') -> Conduit (Stream i s t p c) m (Stream i s' t p c)

-- | A conduit that applies the given function to every time stamp of a
--   <a>Stream</a>, in <a>Frame</a>s as well as <a>FrameCtx</a>s.
mapTicksC :: Monad m => (t -> t') -> Conduit (Stream i s t p c) m (Stream i s t' p c)

-- | A strict version of <a>mapTicksC</a>.
mapTicksC' :: (NFData t, Monad m) => (t -> t') -> Conduit (Stream i s t p c) m (Stream i s t' p c)

-- | A conduit that applies the given monadic function to
--   <a>eachFrameContent</a> of a <a>Stream</a>.
mapFrameContentMC :: Monad m => (c -> m c') -> Conduit (Stream i s t p c) m (Stream i s t p c')

-- | A strict variant of <a>mapFrameContentMC</a>
mapFrameContentMC' :: (NFData (Stream i s t p c'), Monad m) => (c -> m c') -> Conduit (Stream i s t p c) m (Stream i s t p c')

-- | A conduit that applies the given pure function to
--   <a>eachFrameContent</a> of a <a>Stream</a>.
mapFrameContentC' :: (NFData c', Monad m) => (c -> c') -> Conduit (Stream i s t p c) m (Stream i s t p c')

-- | Like <a>foldMap</a> this uses the given function to extract a monoidal
--   value and <a>mappend</a>s all results into a single value, which is
--   returned when the <a>Conduit</a> terminates.
foldStream :: (Monoid o, Monad m) => (Stream i s t p c -> o) -> Sink (Stream i s t p c) m o

-- | Monadic variant of <a>foldStream</a>
foldStreamM :: (Monoid o, Monad m) => (Stream i s t p c -> m o) -> Sink (Stream i s t p c) m o

-- | Under the constraint that the stream content is a monoid, fold over
--   the stream appending all frame contents, i.e. <a>foldStream</a> of
--   <a>eachFrameContent</a>. When the conduit finishes the monoidal value
--   is returned.
concatStreamContents :: (Monoid c, Monad m) => Sink (Stream i s t p c) m c


-- | Conduits for converting <a>ALaw</a> <a>Stream</a>s to <a>S16</a>
--   streams and vice versa.
module Data.MediaBus.Conduit.Audio.Raw.Alaw

-- | Convert from <a>ALaw</a> to <a>S16</a>
alawToS16 :: (NFData cIn, NFData cOut, Monad m, EachChannelL cIn cOut ALaw S16) => Conduit (Stream i s t p cIn) m (Stream i s t p cOut)

-- | Convert from <a>S16</a> to <a>ALaw</a>
s16ToAlaw :: (NFData cIn, NFData cOut, Monad m, EachChannelL cIn cOut S16 ALaw) => Conduit (Stream i s t p cIn) m (Stream i s t p cOut)


-- | A small utility module that sends an audio stream via <i>stdout</i> to
--   a <tt>sox</tt> system command that plays the audio.
module Data.MediaBus.Conduit.Audio.Raw.DebugSink

-- | A <a>Sink</a> that launches a shell command that starts <tt>sox</tt>
--   such that it reads raw audio data from <tt>STDIN</tt> and plays it via
--   the systems sound card.
debugAudioPlaybackSink :: forall m i s t p c r ch pcm. (Default i, MonadIO m, KnownRate r, KnownChannelLayout ch, IsPcmValue (Pcm ch pcm), HasMediaL' c (Audio r ch (Raw pcm)), HasMediaBuffer' (Audio r ch (Raw pcm))) => Sink (Stream i s t p c) m ()


-- | Simple, preliminary (raw-)audio resampling
module Data.MediaBus.Conduit.Audio.Raw.Resample

-- | Resample <tt>RawAudio</tt> <tt>IsMedia</tt> from an 8kHz sample rate
--   to 16 kHz, using a simple (and fast) linear interpolation between each
--   sample.
resample8to16kHz' :: forall m i s t p cIn cOut ch sa. (Monad m, NFData i, NFData s, NFData t, NFData p, NFData cIn, NFData cOut, HasRate cIn, GetRate cIn ~ Hz 8000, cOut ~ SetRate cIn (Hz 16000), HasRate cOut, GetRate cOut ~ Hz 16000, EachSampleL cIn cOut (Pcm ch sa) (Pcm ch sa), IsPcmValue (Pcm ch sa), HasMediaBufferL cIn cOut (MediaBuffer (SamplesFrom cIn)) (MediaBuffer (SamplesTo cOut))) => Pcm ch sa -> Conduit (Stream i s t p cIn) m (Stream i s t p cOut)


-- | A conduit that conceals <a>Missing</a> frames.
module Data.MediaBus.Conduit.Discontinous

-- | Replace <a>Missing</a> parts with the given concealment value.
concealMissing :: (NFData c, Monad m) => c -> Conduit (Stream i s t p (Discontinous c)) m (Stream i s t p c)


-- | Make a <a>Stream</a> of media a segmented stream by using that has
--   content which is an instance of <a>CanSegment</a>. TODO move or merge
--   - after deciding howto proceed with the package structure in general
module Data.MediaBus.Conduit.Segment

-- | The packetizer recombines incoming packets into <a>Segment</a>s of the
--   given size. The sequence numbers will be offsetted by the number extra
--   frames generated.
segmentC :: (Num s, Monad m, CanSegment c, Monoid c, Default i, CanBeTicks r t, HasDuration c, HasStaticDuration d) => Conduit (Stream i s (Ticks r t) p c) m (Stream i s (Ticks r t) p (Segment d c))
segmentC' :: (Num s, Monad m, CanSegment c, Monoid c, Default i, CanBeTicks r t, HasDuration c, HasStaticDuration d) => proxy d -> Conduit (Stream i s (Ticks r t) p c) m (Stream i s (Ticks r t) p (Segment d c))
forgetSegmentationC :: (NFData c, Monad m) => Conduit (Stream i s t p (Segment d c)) m (Stream i s t p c)


-- | Conduits to create and convert the time stamps in <a>Stream</a>s
module Data.MediaBus.Conduit.Timing

-- | Recalculate all timestamps in a <a>Stream</a>
convertTicksC' :: forall proxy0 proxy1 m r t r' t' i s c p. (NFData t, NFData t', CanBeTicks r t, CanBeTicks r' t', Monad m, NFData t') => proxy0 '(r, t) -> proxy1 '(r', t') -> Conduit (Stream i s (Ticks r t) p c) m (Stream i s (Ticks r' t') p c)

-- | Overwrite the timestamp of a stream of things that have a time stamp
--   field (i.e. <a>HasTimestamp</a> instances) and also a duration, such
--   that the timestamps increment by the duration starting from 0.
deriveFrameTimestamp :: forall m r t a. (Monad m, CanBeTicks r t, HasDuration a, HasTimestamp a) => Ticks r t -> Conduit a m (SetTimestamp a (Ticks r t))


-- | This module contains functions and types for reframing the sequence
--   number and timestamps of <a>Frame</a>s.
--   
--   This means that this module will allow you to record a set of incoming
--   frames using <a>pushFrame</a>. Whenever you want to extract the timing
--   and sequence number information of the next frame with a given
--   duration, use <a>generateFrame</a>.
module Data.MediaBus.Media.Reframe

-- | Create an empty initial state.
initialReframerState :: (Num d, Num s) => ReframerSt s d

-- | Run state <a>ReframerSt</a> state transformer.
runReframer :: Monad m => ReframerT m s d a -> ReframerSt s d -> m (a, ReframerSt s d)

-- | Reset the current timing and sequence number, and start with the given
--   start time.
pushStartFrame :: (Num d, Monad m) => d -> ReframerT m s d ()

-- | Increase the available duration by the duration in the frame, iff the
--   timestamp of the given frame matches exactly the timestamp after the
--   end of the available period, otherwise do nothing with the state and
--   return <a>True</a>.
pushFrame :: (Num d, Monad m, Eq d, Ord d) => Frame s d d -> ReframerT m s d (Maybe PushFrameError)

-- | Specifies in what way <a>pushFrame</a> failed
data PushFrameError

-- | The input frame ends before <a>$sel:_endTs:MkTimeFrame</a>
InputFrameIsLate :: PushFrameError

-- | The input frame starts before, and ends after
--   <a>$sel:_endTs:MkTimeFrame</a>
InputFrameOverlaps :: PushFrameError

-- | The input frame begins after <a>$sel:_endTs:MkTimeFrame</a>
InputFrameIsEarly :: PushFrameError

-- | Return the duration of the frames recorded with <a>pushFrame</a>.
nextFrameAvailableDuration :: (Num d, Monad m) => ReframerT m s d d

-- | Return the timestamp of the frame being build. .
nextFrameTimestamp :: (Num d, Monad m) => ReframerT m s d d

-- | Try to create a frame with the given duration, and update the state
--   accordingly, the actual duration, that was available is put into the
--   payload field of the frame returned. The start time stamp of the next
--   frame is always incremented by the <tt>wantedDureation</tt> regardless
--   of wether it was available.
generateFrame :: (Num s, Num d, Monad m, Eq d, Ord d, Show d) => d -> ReframerT m s d (Frame s d d)

-- | The <a>ReframerSt</a> <a>StateT</a> transformer
type ReframerT m s d a = StateT (ReframerSt s d) m a

-- | Reframer state.
data ReframerSt s d

-- | The exception type for <tt>encodeLinearToAacC</tt>
data ReframeError s d
MkReframeError :: String -> Maybe d -> ReframerSt s d -> ReframeError s d

-- | Utility function to generate a <a>ReframeError</a> with the current
--   state.
mkReFrameError :: Monad m => String -> Maybe d -> ReframerT m s d (ReframeError s d)
instance GHC.Enum.Enum Data.MediaBus.Media.Reframe.PushFrameError
instance GHC.Show.Show Data.MediaBus.Media.Reframe.PushFrameError
instance GHC.Classes.Ord Data.MediaBus.Media.Reframe.PushFrameError
instance GHC.Classes.Eq Data.MediaBus.Media.Reframe.PushFrameError
instance (GHC.Show.Show s, GHC.Show.Show d) => GHC.Show.Show (Data.MediaBus.Media.Reframe.ReframerSt s d)
instance (GHC.Show.Show s, GHC.Show.Show d) => GHC.Show.Show (Data.MediaBus.Media.Reframe.ReframeError s d)
instance (GHC.Show.Show s, Data.Typeable.Internal.Typeable * s, GHC.Show.Show d, Data.Typeable.Internal.Typeable * d) => GHC.Exception.Exception (Data.MediaBus.Media.Reframe.ReframeError s d)


-- | Utilities for logging.
module Data.MediaBus.Basics.LoggingExtra

-- | Prefix every log message done from inside the given monad action with
--   the given prefix. This runs a <a>LoggingT</a> action inside a
--   <a>MonadLoggerIO</a> base monad with a log function that wraps around
--   the log function returned by <a>askLoggerIO</a> and prefixes each
--   message with the given prefix.
withLogMessagePrefix :: (ToLogStr prefix, MonadLoggerIO m) => prefix -> LoggingT m a -> m a


-- | An interface for <i>clocks</i>. Since there are many ways to calculate
--   different ideas of <i>time</i>, e.g. system time, wall clock time or
--   stream time, a type class <tt>Clock</tt> is provided with the basic
--   interface for getting the current time and comparing time stamps.
module Data.MediaBus.Basics.Clock

-- | Clocks can generate reference times, and they can convert these to
--   tickss. Tickss are mere integrals
class (Default (ClockTimeDiff c), Ord (ClockTimeDiff c), Eq (ClockTimeDiff c), Num (ClockTimeDiff c), Show (ClockTime c), Eq (ClockTime c), Show (ClockTimeDiff c), LocalOrd (ClockTimeDiff c)) => IsClock c where data ClockTime c data ClockTimeDiff c type MonadClock c (m :: Type -> Type) :: Constraint where {
    data family ClockTime c;
    data family ClockTimeDiff c;
    type family MonadClock c (m :: Type -> Type) :: Constraint;
}

-- | Return the current absolute time as a <a>ClockTime</a>
now :: (IsClock c, MonadClock c m) => m (ClockTime c)

-- | Convert a <a>ClockTime</a> to a <a>ClockTimeDiff</a> by
--   <a>diffTime</a>ing the time with the beginning of time.
timeAsTimeDiff :: IsClock c => ClockTime c -> ClockTimeDiff c

-- | The time difference (a <a>ClockTimeDiff</a>) between two
--   <a>ClockTime</a>s
diffTime :: IsClock c => ClockTime c -> ClockTime c -> ClockTimeDiff c

-- | Add the relative time to an absolute time to obtain a new absolute
--   time.
timeAddTimeDiff :: IsClock c => ClockTime c -> ClockTimeDiff c -> ClockTime c

-- | Return the time elapsed between since the given absolute time.
timeSince :: (IsClock c, MonadClock c m, Monad m) => ClockTime c -> m (ClockTimeDiff c)

-- | A UTC System Time Clock
data UtcClock
MkUtcClock :: UtcClock

-- | A <a>Proxy</a> for <a>UtcClock</a>
useUtcClock :: Proxy UtcClock

-- | An <a>Iso</a> for converting a <a>UtcClock</a> <a>ClockTimeDiff</a>
--   from/to a <a>NominalDiffTime</a>.
utcClockTimeDiff :: Iso' (ClockTimeDiff UtcClock) NominalDiffTime
instance GHC.Generics.Generic Data.MediaBus.Basics.Clock.UtcClock
instance GHC.Generics.Generic (Data.MediaBus.Basics.Clock.ClockTimeDiff * Data.MediaBus.Basics.Clock.UtcClock)
instance GHC.Num.Num (Data.MediaBus.Basics.Clock.ClockTimeDiff * Data.MediaBus.Basics.Clock.UtcClock)
instance GHC.Classes.Eq (Data.MediaBus.Basics.Clock.ClockTimeDiff * Data.MediaBus.Basics.Clock.UtcClock)
instance GHC.Classes.Ord (Data.MediaBus.Basics.Clock.ClockTimeDiff * Data.MediaBus.Basics.Clock.UtcClock)
instance GHC.Generics.Generic (Data.MediaBus.Basics.Clock.ClockTime * Data.MediaBus.Basics.Clock.UtcClock)
instance GHC.Classes.Eq (Data.MediaBus.Basics.Clock.ClockTime * Data.MediaBus.Basics.Clock.UtcClock)
instance Control.DeepSeq.NFData Data.MediaBus.Basics.Clock.UtcClock
instance Data.MediaBus.Basics.Clock.IsClock * Data.MediaBus.Basics.Clock.UtcClock
instance Control.DeepSeq.NFData (Data.MediaBus.Basics.Clock.ClockTime * Data.MediaBus.Basics.Clock.UtcClock)
instance GHC.Show.Show (Data.MediaBus.Basics.Clock.ClockTime * Data.MediaBus.Basics.Clock.UtcClock)
instance GHC.Show.Show (Data.MediaBus.Basics.Clock.ClockTimeDiff * Data.MediaBus.Basics.Clock.UtcClock)
instance Control.DeepSeq.NFData (Data.MediaBus.Basics.Clock.ClockTimeDiff * Data.MediaBus.Basics.Clock.UtcClock)
instance Data.Default.Class.Default (Data.MediaBus.Basics.Clock.ClockTimeDiff * Data.MediaBus.Basics.Clock.UtcClock)
instance Test.QuickCheck.Arbitrary.Arbitrary (Data.MediaBus.Basics.Clock.ClockTime * Data.MediaBus.Basics.Clock.UtcClock)
instance Test.QuickCheck.Arbitrary.Arbitrary (Data.MediaBus.Basics.Clock.ClockTimeDiff * Data.MediaBus.Basics.Clock.UtcClock)
instance Data.MediaBus.Basics.Monotone.LocalOrd (Data.MediaBus.Basics.Clock.ClockTimeDiff * Data.MediaBus.Basics.Clock.UtcClock)


-- | Asynchronous execution of conduits. This module contains a set of
--   functions to concurrently execute <a>Stream</a> processing conduits
--   and couple them using <a>TBQueue</a>s.
module Data.MediaBus.Conduit.Async

-- | Asynchronously run a <a>Source</a> connected to a <a>FrameContentQ</a>
--   and create a new source that consumes the queue by polling
--   periodically from that queue, generating a <a>Discontinous</a> output.
withAsyncPolledSource :: (MonadResource m, MonadLogger m, MonadBaseControl IO m, KnownRate r, Integral t, Integral s, Default p, HasStaticDuration c, HasDuration c, NFData c, NFData p, NFData s, NFData t, Random i, Random t, Random s, Show c) => Int -> Source m (Stream i s (Ticks r t) p c) -> ((Async (), Source m (Stream i s (Ticks r t) p (Discontinous c))) -> m o) -> m o

-- | A queue for <tt>frameContent</tt> to decouple concurrent conduits
--   carrying <a>Stream</a>s. Under the hood a <a>TBQueue</a> is used. A
--   queue also knows it's default segment duration and preferred polling
--   interval.
data FrameContentQ a

-- | Create a new <a>FrameContentQ</a> with an upper bound on the queue
--   length.
mkFrameContentQ :: forall m a. (HasStaticDuration a, MonadBaseControl IO m) => Int -> m (FrameContentQ a)

-- | Consume the <tt>frameContent</tt>s of a <a>Stream</a> and write them
--   into a <a>FrameContentQ</a>. When the queue is full, **drop the oldest
--   element** and push in the new element, anyway.
frameContentQSink :: (NFData a, MonadBaseControl IO m, Show a, MonadLogger m) => FrameContentQ a -> Sink (Stream i s t p a) m ()

-- | Periodically poll a <a>FrameContentQ</a> and yield the content as
--   frames with newly generated timestamp and sequence number values.
frameContentQSource :: (Random i, NFData c, NFData p, Default p, HasStaticDuration c, HasDuration c, MonadBaseControl IO m, MonadLogger m, KnownRate r, Integral t, Integral s, NFData t, NFData s) => FrameContentQ c -> Source m (Stream i s (Ticks r t) p (Discontinous c))

module Data.MediaBus.Transport.Udp

-- | A UDP source that uses <tt>MonandResource</tt> to make sure the socket
--   is closed.
udpDatagramSource :: (IsClock c, MonadClock c m, MonadResource m, Num s, Default p) => proxy c -> Int -> HostPreference -> Source m (Stream (SourceId (Maybe SockAddr)) (SeqNum s) (ClockTimeDiff c) p ByteString)


-- | Multi media processing library. This module only reexports all other
--   modules in this package.
module Data.MediaBus