What’s new in Membrane Framework - Q4 2019

Here’s our December update on what’s up in Membrane Development Team this quarter. The biggest news is that Membrane Core is becoming even more modular and easier to use for building your own multimedia processing and/or broadcasting system. Bins introduced in our newest release do exactly that. They speed up development and modification process, they make your code more bulletproof and thus lower the development costs significantly. Your system can now be fully operational earlier and with less bug-related problems.

Smaller Patches

End of September and mid October we released patches v0.4.1 and v0.4.2 respectively. These correct issues found in v0.4.0 and introduced amendments in the documentation.

v0.4.1 changes

v0.4.2 changes

Membrane Core v0.5 – introducing Bins!

This November, v0.5 of Membrane Core was released.

This version introduces bins – a means of grouping single elements into larger containers. They enable you to create reusable groups of elements, making the development of more complex systems both faster and more reliable.


Internally, a bin acts like a pipeline within an element, i.e. a group of elements with their own pads and links between them. From the outside, it acts as every other element with input and output pads.

Bins can be nested within one another allowing or building more complex processing systems. Also, there is a possibility to control bin children e.g. by dynamically spawning or replacing them as the stream changes.

Bin pads

Bin’s pads are defined similarly to element’s pads and can be linked in similar way. However, their role is limited to proxy the stream to elements and bins inside (inputs) or outside (outputs). To achieve that, each input pad of a bin needs to be linked to both an output pad from the outside of a bin and an input pad of its child inside. Accordingly, each bin’s output should be linked to output inside and input outside of the bin. In practice, the use of bin’s pads is nearly identical to that of a single element. This prevents unnecessary complexity and requires no extensive learning or going through documentation. Also, makes it much more efficient to apply the use of bins within existing Membrane projects.

Bins and the stream

Bins are just responsible for managing their children. They do not take part in processing the data stream itself. It just passes the stream through its pads to and from its children. It might, however, receive necessary information about the stream in a form of notifications from its children.

More info about bins can be found in our Guide.

Breaking Changes

  • Membrane.Pipeline.Spec is now Membrane.ParentSpec

  • Dynamic pads are now referenced by Membrane.Pad.ref(name, id) macro instead of {:dynamic, name, id} tuple

  • Links are now specified in a new way, described in docs for Membrane.ParentSpec

  • pipeline_clock field has become parent_clock in all the callback contexts

Release details are available on our Github site.

New Packages

Since our last update, the following packages have been published:

  • SDP Protocol – Parser for Session Description Protocol. Based on RFC4566

  • RTP bin – provides Membrane bins for dealing with RTP streams.

Note: For full list of packages (sorted by release date), please check https://hex.pm/packages?search=membrane&sort=inserted_at.

Coming soon are some patches to issues found in v0.5.0, but these should be really minor. Thank you for using Membrane Framework!

Happy 2020 everyone!