Membrane.Pad (Membrane Core v0.7.0) View Source

Pads are units defined by elements and bins, allowing them to be linked with their siblings. This module consists of pads typespecs and utils.

Each pad is described by its name, direction, availability, mode and possible caps. For pads to be linkable, these properties have to be compatible. For more information on each of them, check appropriate type in this module.

Each link can only consist of exactly two pads.

Link to this section Summary

Types

Type describing availability mode of a created pad

Values used when defining pad availability

For bins there are exactly the same options for both directions. Demand unit is derived from the first element inside the bin linked to the given input.

Pad options used in spec_t/0

Type describing a pad. Contains data parsed from spec_t/0

Defines possible pad directions

Possible id of dynamic pad

Describes how an input pad should be declared inside an element.

Describes how an element sends and receives data. Modes are strictly related to pad directions

Defines the name of pad or group of dynamic pads

Describes how an output pad should be declared inside an element.

Defines the term by which the pad instance is identified.

Describes how a pad should be declared in element or bin.

Link to this section Types

Specs

availability_mode_t() :: :static | :dynamic

Type describing availability mode of a created pad:

  • :static - there always exist exactly one instance of such pad.
  • :dynamic - multiple instances of such pad may be created and removed (which entails executing handle_pad_added and handle_pad_removed callbacks, respectively).

Specs

availability_t() :: :on_request | :always

Values used when defining pad availability:

  • :always - a static pad, which can remain unlinked in stopped state only.
  • :on_request - a dynamic pad, instance of which is created every time it is linked to another pad. Thus linking the pad with k other pads, creates k instances of the pad, and links each with another pad.

Specs

bin_spec_t() :: input_spec_t()

For bins there are exactly the same options for both directions. Demand unit is derived from the first element inside the bin linked to the given input.

Link to this type

common_spec_options_t()

View Source

Specs

common_spec_options_t() ::
  {:availability, availability_t()}
  | {:mode, mode_t()}
  | {:caps, Membrane.Caps.Matcher.caps_specs_t()}
  | {:options, Keyword.t()}

Pad options used in spec_t/0

Specs

description_t() :: %{
  :availability => availability_t(),
  :mode => mode_t(),
  :name => name_t(),
  :caps => Membrane.Caps.Matcher.caps_specs_t(),
  optional(:demand_unit) => Membrane.Buffer.Metric.unit_t(),
  :direction => direction_t(),
  :options => nil | Keyword.t()
}

Type describing a pad. Contains data parsed from spec_t/0

Specs

direction_t() :: :output | :input

Defines possible pad directions:

  • :output - data can only be sent through such pad,
  • :input - data can only be received through such pad.

One cannot link two pads with the same direction.

Specs

dynamic_id_t() :: any()

Possible id of dynamic pad

Specs

input_spec_t() ::
  {name_t(),
   [common_spec_options_t() | {:demand_unit, Membrane.Buffer.Metric.unit_t()}]}

Describes how an input pad should be declared inside an element.

Specs

mode_t() :: :push | :pull

Describes how an element sends and receives data. Modes are strictly related to pad directions:

  • :push output pad - element can send data through such pad whenever it wants.
  • :push input pad - element has to deal with data whenever it comes through such pad, and do it fast enough not to let data accumulate on such pad, what may lead to overflow of element process erlang queue, which is highly unwanted.
  • :pull output pad - element can send data through such pad only if it have already received demand on the pad. Sending small, limited amount of undemanded data is supported and handled by Membrane.Core.InputBuffer.
  • :pull input pad - element receives through such pad only data that it has previously demanded, so that no undemanded data can arrive.

Linking pads with different modes is possible, but only in case of output pad working in push mode, and input in pull mode. Moreover, toilet mode of Membrane.Core.InputBuffer has to be enabled then.

For more information on transfering data and demands, see Membrane.Source, Membrane.Filter, Membrane.Sink.

Specs

name_t() :: atom() | {:private, atom()}

Defines the name of pad or group of dynamic pads

Specs

output_spec_t() :: {name_t(), [common_spec_options_t()]}

Describes how an output pad should be declared inside an element.

Specs

ref_t() :: name_t() | {Membrane.Pad, name_t(), dynamic_id_t()}

Defines the term by which the pad instance is identified.

Specs

spec_t() :: output_spec_t() | input_spec_t() | bin_spec_t()

Describes how a pad should be declared in element or bin.

Link to this section Functions

Link to this function

assert_public_name!(name)

View Source

Specs

assert_public_name!(name_t()) :: :ok

Specs

availability_mode(availability_t()) :: availability_mode_t()

Returns pad availability mode for given availability.

Link to this function

create_private_name(name)

View Source

Specs

create_private_name(atom()) :: name_t()
Link to this function

get_corresponding_bin_pad(name)

View Source

Specs

get_corresponding_bin_pad(ref_t()) :: ref_t()
Link to this macro

is_availability(term)

View Source (macro)
Link to this macro

is_availability_dynamic(availability)

View Source (macro)
Link to this macro

is_availability_static(availability)

View Source (macro)
Link to this macro

is_pad_name(term)

View Source (macro)
Link to this macro

is_pad_ref(term)

View Source (macro)
Link to this macro

is_public_name(term)

View Source (macro)

Specs

name_by_ref(ref_t()) :: name_t()

Returns the name for the given pad reference

Link to this function

opposite_direction(atom)

View Source

Specs

opposite_direction(direction_t()) :: direction_t()

Creates a static pad reference.

Creates a dynamic pad reference.