| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Data.ByteString.IsoBaseFileFormat.Box
Contents
Description
Definition of the most basic element in an ISOBMFF file: a box. See Chapter 4 in the standard document. A box is a container with a type, a size, some data and some nested boxes. The standard defines - among other characteristics - available box types and their semantics, the fields they contain and how they are nested into each other. This library tries to capture some of these characteristics using modern Haskell type system features, in order to provide compile time checks for (partial) standard compliance.
Synopsis
- class (KnownSymbol (BoxTypeSymbol t), IsBoxContent (BoxContent t)) => IsBox (t :: Type) where
- type BoxContent t
- toBoxType :: proxy t -> BoxType
- type family BoxTypeSymbol (t :: k) :: Symbol
- class IsBoxContent a where
- boxSize :: a -> BoxSize
- boxBuilder :: a -> Builder
- data Box b where
- Box :: !(BoxContent b) -> Box b
- data ContainerBox b (bs :: [Type]) where
- ContainerBox :: IsBox b => !(BoxContent b) -> !(Boxes bs) -> ContainerBox b bs
- data Boxes (boxTypes :: [Type]) where
- ($:) :: IsBox l => (Boxes '[Box l] -> r) -> Box l -> r
- singletonBox :: IsBox l => Box l -> Boxes '[Box l]
- typeListLength :: forall a proxy (ts :: [k]). (KnownNat (Length ts), Num a) => proxy ts -> a
- containerBox :: IsBox t => BoxContent t -> Boxes ts -> Box (ContainerBox t ts)
- data BoxSize
- fromBoxSize :: Num a => a -> BoxSize -> a
- newtype BoxSizeExtension = BoxSizeExtension BoxSize
- data BoxType
- = StdType !FourCc
- | CustomBoxType !String
- parseBoxType :: KnownSymbol t => proxy t -> BoxType
- newtype FourCc = FourCc (Char, Char, Char, Char)
- newtype BoxTypeExtension = BoxTypeExtension BoxType
- data a :+ b = !a :+ !b
- newtype ListContent sizeType contentType = ListContent [contentType]
- type OM b bs = ContainerBox b bs
- type OO b bs = OnceOptionalX (ContainerBox b bs)
- type SM b bs = SomeMandatoryX (ContainerBox b bs)
- type SO b bs = SomeOptionalX (ContainerBox b bs)
- type OM_ b = Box b
- type OO_ b = OnceOptionalX (Box b)
- type SM_ b = SomeMandatoryX (Box b)
- type SO_ b = SomeOptionalX (Box b)
- type family IsContainerBox t :: Bool where ...
- type family ChildBoxes c where ...
Box Type Classes
class (KnownSymbol (BoxTypeSymbol t), IsBoxContent (BoxContent t)) => IsBox (t :: Type) where Source #
Base class for all (abstractphantomnormal-) types that represent boxes
Minimal complete definition
Nothing
Associated Types
type BoxContent t Source #
Instances
type family BoxTypeSymbol (t :: k) :: Symbol Source #
A type family used by the type-level consistency checks. It is required
that an instance of this type family exists for every IsBox instance.
This family could not be associative since it is used by type families that
cannot have type class constraints.
Instances
class IsBoxContent a where Source #
Types that go into a box. A box content is a piece of data that can be
reused in different instances of IsBox. It has no BoxType and hence
defines no box.
Instances
Box Contents
A type that wraps the contents of a box and the box type.
Constructors
| Box :: !(BoxContent b) -> Box b |
Instances
data ContainerBox b (bs :: [Type]) where Source #
Compose BoxContent and Boxes under the Constraint that they are
composable.
Constructors
| ContainerBox :: IsBox b => !(BoxContent b) -> !(Boxes bs) -> ContainerBox b bs |
Instances
| IsBoxContent (ContainerBox b bs) Source # | |
Defined in Data.ByteString.IsoBaseFileFormat.Box Methods boxSize :: ContainerBox b bs -> BoxSize Source # boxBuilder :: ContainerBox b bs -> Builder Source # | |
| IsBox b => IsBox (ContainerBox b bs) Source # | |
Defined in Data.ByteString.IsoBaseFileFormat.Box Associated Types type BoxContent (ContainerBox b bs) :: Type Source # Methods toBoxType :: proxy (ContainerBox b bs) -> BoxType Source # | |
| type IsRuleConform (Box b :: Type) (ContainerBox b' rules :: Type) Source # | |
Defined in Data.ByteString.IsoBaseFileFormat.Box type IsRuleConform (Box b :: Type) (ContainerBox b' rules :: Type) = IsContainerBox b && (IsRuleConform (Box b) (Box b') && IsRuleConform (ChildBoxes b) (Boxes rules)) | |
| type BoxTypeSymbol (ContainerBox b bs :: Type) Source # | |
Defined in Data.ByteString.IsoBaseFileFormat.Box | |
| type BoxContent (ContainerBox b bs) Source # | |
Defined in Data.ByteString.IsoBaseFileFormat.Box | |
data Boxes (boxTypes :: [Type]) where Source #
A heterogenous collection of boxes.
Constructors
| NoBoxes :: Boxes '[] | |
| (:.) :: IsBox l => !(Box l) -> !(Boxes r) -> Boxes (Box l ': r) infixr 2 | |
| (:<>) :: !(Boxes l) -> !(Boxes r) -> Boxes (l ++ r) infixr 1 | |
| (:|) :: (IsBox l, IsBox r) => !(Box l) -> !(Box r) -> Boxes '[Box l, Box r] infixr 2 |
Instances
| IsBoxContent (Boxes bs) Source # | |
| type IsRuleConform (Boxes bs :: Type) (Boxes rs :: Type) Source # | |
Defined in Data.ByteString.IsoBaseFileFormat.Box | |
typeListLength :: forall a proxy (ts :: [k]). (KnownNat (Length ts), Num a) => proxy ts -> a Source #
Get the elements in a type level array
containerBox :: IsBox t => BoxContent t -> Boxes ts -> Box (ContainerBox t ts) Source #
A box that contains no fields, but nested boxes.
Box Size and Type
The size of the box. If the size is limited to a (fixed) value, it can be
provided as a Word64 which will be represented as either a 32bit compact
size or as 64 bit largesize. If UnlimitedSize is used, the box extends to
the end of the file.
Constructors
| UnlimitedSize | |
| BoxSize !Word64 |
fromBoxSize :: Num a => a -> BoxSize -> a Source #
newtype BoxSizeExtension Source #
The BoxSize can be > 2^32 in which case an BoxSizeExtension must be
added after the type field.
Constructors
| BoxSizeExtension BoxSize |
Instances
| IsBoxContent BoxSizeExtension Source # | |
Defined in Data.ByteString.IsoBaseFileFormat.Box Methods boxSize :: BoxSizeExtension -> BoxSize Source # boxBuilder :: BoxSizeExtension -> Builder Source # | |
A box has a type, this is the value level representation for the box type.
Constructors
| StdType !FourCc |
|
| CustomBoxType !String | CustomBoxType defines custom |
parseBoxType :: KnownSymbol t => proxy t -> BoxType Source #
Create a box type from a Symbol. Parse the symbol value, if it's a four
charachter code, then return that as StdType otherwise parse a UUID (TODO)
and return a CustomBoxType.
A type containin a printable four letter character code. TODO replace impl with U32Text
newtype BoxTypeExtension Source #
When using custom types extra data must be written after the extra size information. Since the box type and the optional custom box type are not guaranteed to be consequtive, this type handles the second part seperately.
Constructors
| BoxTypeExtension BoxType |
Instances
| IsBoxContent BoxTypeExtension Source # | |
Defined in Data.ByteString.IsoBaseFileFormat.Box Methods boxSize :: BoxTypeExtension -> BoxSize Source # boxBuilder :: BoxTypeExtension -> Builder Source # | |
IsBoxContent instances
Box concatenation
Box content composition
Constructors
| !a :+ !b infixr 3 |
Instances
| (Default a, Default b) => Default (a :+ b) Source # | |
Defined in Data.ByteString.IsoBaseFileFormat.Box | |
| (IsBoxContent p, IsBoxContent c) => IsBoxContent (p :+ c) Source # | |
Tagged boxes
List Box Content
newtype ListContent sizeType contentType Source #
A list of things that renders to a size field with the number of elements and the sequence of elements. This type is index with the size field type.
Constructors
| ListContent [contentType] |
Instances
| Default (ListContent sizeTupe contentType) Source # | |
Defined in Data.ByteString.IsoBaseFileFormat.Box Methods def :: ListContent sizeTupe contentType # | |
| (Num sizeType, IsBoxContent sizeType, IsBoxContent contentType) => IsBoxContent (ListContent sizeType contentType) Source # | |
Defined in Data.ByteString.IsoBaseFileFormat.Box Methods boxSize :: ListContent sizeType contentType -> BoxSize Source # boxBuilder :: ListContent sizeType contentType -> Builder Source # | |
Words and Integer
Boxes of Bits
Type Layout Rule Matchers
type OM b bs = ContainerBox b bs Source #
Mandatory, container box, exactly one
type OO b bs = OnceOptionalX (ContainerBox b bs) Source #
Optional, container box, zero or one
type SM b bs = SomeMandatoryX (ContainerBox b bs) Source #
Mandatory, container box, one or more
type SO b bs = SomeOptionalX (ContainerBox b bs) Source #
Optional, container box, zero or more
type OO_ b = OnceOptionalX (Box b) Source #
Optional, zero or one, no children
type SM_ b = SomeMandatoryX (Box b) Source #
Mandatory, one or more, no children
type SO_ b = SomeOptionalX (Box b) Source #
Optional, zero or more, no children
type family IsContainerBox t :: Bool where ... Source #
Equations
| IsContainerBox (ContainerBox a as) = True | |
| IsContainerBox b = False |
type family ChildBoxes c where ... Source #
Equations
| ChildBoxes (ContainerBox a as) = Boxes as |