Current section

Files

Jump to
membrane_core lib membrane core element state.ex
Raw

lib/membrane/core/element/state.ex

defmodule Membrane.Core.Element.State do
@moduledoc false
# Structure representing state of an Core.Element. It is a part of the private API.
# It does not represent state of elements you construct, it's a state used
# internally in Membrane.
use Membrane.Log, tags: :core
alias Membrane.{Core, Element}
alias Core.{Playback, Playbackable}
alias Core.Element.{PadModel, PadSpecHandler, PlaybackBuffer}
alias Element.Pad
alias Bunch.Type
alias __MODULE__, as: ThisModule
require Pad
use Bunch.Access
@type stateful_t(value) :: Type.stateful_t(value, t)
@type stateful_try_t :: Type.stateful_try_t(t)
@type stateful_try_t(value) :: Type.stateful_try_t(value, t)
@type t :: %__MODULE__{
module: module,
type: Element.type_t(),
name: Element.name_t(),
internal_state: Element.state_t() | nil,
pads: PadModel.pads_t() | nil,
watcher: pid | nil,
controlling_pid: pid | nil,
parent_monitor: reference() | nil,
playback: Playback.t(),
playback_buffer: PlaybackBuffer.t(),
delayed_demands: %{{Pad.ref_t(), :supply | :redemand} => :sync | :async}
}
defstruct [
:module,
:type,
:name,
:internal_state,
:pads,
:watcher,
:controlling_pid,
:parent_monitor,
:playback,
:playback_buffer,
:delayed_demands
]
defimpl Playbackable, for: __MODULE__ do
use Playbackable.Default
def get_controlling_pid(%ThisModule{controlling_pid: pid}), do: pid
end
@doc """
Initializes new state.
"""
@spec new(module, Element.name_t(), reference() | nil) :: t
def new(module, name, parent_monitor \\ nil) do
%__MODULE__{
module: module,
type: apply(module, :membrane_element_type, []),
name: name,
internal_state: nil,
pads: nil,
watcher: nil,
controlling_pid: nil,
parent_monitor: parent_monitor,
playback: %Playback{},
playback_buffer: PlaybackBuffer.new(),
delayed_demands: %{}
}
|> PadSpecHandler.init_pads()
end
end