Membrane Core v0.1.1 API Reference

Modules

Structure representing a single chunk of data that flows between elements

Specifies API for metrics that analyze data in terms of a given unit

Implementation of Membrane.Buffer.Metric for the :bytes unit

Implementation of Membrane.Buffer.Metric for the :buffers unit

Describes capabilities of some pad

Module that allows to specify valid caps and verify that they match specification

Module containing functions spawning, shutting down, inspecting and controlling playback of elements. These functions are usually called by Membrane.Pipeline, and can be called from elsewhere only if there is a really good reason for doing so

This module contains type specifications of actions that can be returned from element callbacks

Modules in this namespace contain behaviours, default callback implementations and other stuff useful when creating elements

Module defining behaviour for filters - elements processing data

Module defining behaviour common to all elements

Module defining behaviour for sink and filter elements

Module defining behaviour for source and filter elements

Module defining behaviour for sinks - elements consuming data

Module defining behaviour for sources - elements producing data

Structure representing a context that is passed to the element when receiving information about new caps for given pad

Structure representing a context that is passed to the element when processing incoming demand

Structure representing a context that is passed to the element when handling event

Structure representing a context that is passed to the element when when new pad added is created

Structure representing a context that is passed to the element when when new pad added is created

Structure representing a context that is passed to the element when new buffer arrives

Structure representing a context that is passed to the element when new buffer arrives to the sink

Implementation of some functionalities common for all Membrane.Element.Managers

Pads are units defined by each element, allowing it to be linked with another elements. This module consists of pads typespecs and utils

Structure representing a single event that flows between elements

Structure representing a payload for the Discontinuity event

Module containing various helper functions that improve code readability

Module containing helper functions for manipulating bitstrings

Module containing helper functions for generating documentation

Module containing helper functions for manipulating enums

Functions useful for constructing return values for GenServer based modules

A set of functions for easier manipulation on maps

A set of functions for easier manipulation on modules

Helper for handling scenarios when some actions should be repeated until it succeeds

A set of functions for easier manipulation on structs

Useful helpers for sending messages at the specified time

Contains helper macro generating typespec from list

Module containing functions spawning, shutting down, and handling messages sent to logger

This is a base module used by all logger implementations

Defines a router that dispatches logs to instances of Membrane.Log.Logger.Base

Module responsible for supervising router_level loggers. It is also responsible for receiving and routing log messages to appropriate loggers

Structure representing a single message that is emitted by the element

Behaviour for module that delegates its job to the other module via callbacks. It also delivers the default implementation of logic that handles the results of callbacks

Mixin for logging using simple functions such as info/1, debug/1 in other modules

Behaviour for modules that have playback state, i.e. elements and pipelines

Protocol that has to be adopted by modules that use Membrane.Mixins.Playback

The default implementation for Membrane.Mixins.Playbackable. Assumes that playbackable is a map and stores playback and controlling_pid inside it

Module containing functions for constructing and supervising pipelines

Structure representing topology of a pipeline. It can be returned from Membrane.Pipeline.handle_init/1 callback upon pipeline’s initialization. It will define a topology of children and links that build the pipeline

Buffer that is attached to the :sink pad when working in a :pull mode

Module containing functions needed to perform handling of time