►
From YouTube: Sebastian Dröge - GStreamer & Rust
Description
Fast, safe and productive multimedia software
GStreamer is a highly versatile, cross-platform, plugin-based multimedia framework that caters to the whole range of multimedia needs. It can be used basically everywhere, from embedded devices like phones, TVs or drones to desktop applications or on huge server farms.
This talk will focus on how and why Rust looks like the perfect programming language for evolving GStreamer and provide a safer but still performant and even more productive development environment than C. Both GStreamer application development in Rust, and GStreamer plugin development will be covered. What is possible today already, for which applications can Rust be perfectly used already and which parts are still missing? How does it feel like to write an application in Rust compared to doing it in C? And how and why would one write GStreamer plugins in Rust to extend the framework and all applications with support for new codecs, filters or anything else?
Afterwards there will be a short outlook into the future of Rust in the GStreamer project itself and for GStreamer application and plugin development.
Sebastian Dröge (slomo) is a Free Software developer and one of the GStreamer maintainers and core developers. He has been involved with the project since more than 10 years now. He also contributes to various other Free Software projects, like Debian, Rust, GNOME and WebKit. While finishing his master's degree in computer sciences at the University of Paderborn in Germany, he started working as a contractor for GStreamer and related technologies. Sebastian is one of the founders of Centricular, a company providing consultancy services, where he's working from his new home in Greece on improving GStreamer and the Free Software ecosystem in general.
Apart from multimedia related topics, Sebastian has an interest in digital signal processing, programming languages, machine learning, network protocols and distributed systems.
Rust devroom @ FOSDEM 2018
https://fosdem.org/2018/schedule/event/rust_gstreamer/
These talks have been recorded at FOSDEM (https://fosdem.org/)
This work is licensed under the Creative Commons Attribution 2.0 Belgium Licence.
To view a copy of this licence, visit http://creativecommons.org/licenses/by/2.0/be/deed.en
B
Thank
you
good
morning,
and
so
today,
I'm
going
to
talk
about
well,
as
I
said,
keys
to
mind
rust,
but
first
of
all
when
when
who
I
first
of
all,
I
will
tell
you
who
I
am
so
I'm
just
my
developer
since
about
2006
long
long
time
now
and
yeah
I
can
try
so
I'm
a
just
my
developer
since
2006,
which
is
quite
a
long
time
now.
I
probably
touched
every
piece
of
code.
B
Well,
I
will
explain
a
bit
what
you
can
do
nowadays.
What
that,
what
kind
of
projects
using
GCM
are?
You
can
write
in
rust
and
give
some
kind
of
outlook
into
the
mirror
and
Farah
future
and,
in
the
very
end,
something
personal
a
bit
my
experience
with
rust
for
doing
all
of
this,
and
maybe
this
also
gives
others
some
idea
how
how
it
is
to
work
with
rust
for
this
kind
of
projects.
So
what
is
to
streamer
I
will
only
give
a
very,
very
high-level
short
introduction.
B
If
you
want
to
see
details,
go
to
the
website,
there's
lots
of
documentation
that
you
can
read,
probably
more
than
you
want
to
read,
but
from
a
very,
very
high
level.
What
you
steam
is
is
it's
a
pipeline
based
cross-platform
multimedia
framework,
it's
completely
open
source,
free
software.
It's
a
GPL
license
and
there's
no
big
company
behind
it.
There
are
lots
of,
but
lots
of
bigger
and
smaller
companies
that
arrive
driving
it,
but
most
most
of
the
development
is
really
something
that
is
community
driven.
It's
quite
widely
used
nowadays
also
commercially.
B
You
can
find
many
applications
using
it.
Tvs
drones
cameras
all
kinds
of
things
in
the
cloud
and
it's
running
on
Linux
Android,
iOS,
Mac,
OS,
Windows,
basically
everywhere,
where
you
have
some
kind
of
C
compiler
and
a
standard
c
library,
and
it's
not
at
this
point
used
only
for
multimedia
related
things.
B
There
are
also
people
using
it
for
other
stuff,
for
example
the
legal
project
that
was
detecting
the
gravitational
waves.
They
are
using
GStreamer
for
their
data
processing
and
that
that
doesn't
have
anything
to
do
with
multimedia
at
all
anymore.
At
that
point,
so
on
I
said:
do
Simha
is
pipeline
based.
What
does
that
mean?
B
So
in
G
stream
are
the
basic
components
that
you
have
are
so-called
elements,
there's
something
that
that
are
processing,
media
data
or
data
in
general,
and
you
connect
them
to
other
so-called
elements,
and
each
of
these
elements
in
the
end
is
doing
one
little
task.
So,
for
example,
what
we
have
here
is
a
very
small
pipeline,
that
is,
they
could
be
used
for
playing
a
video
file.
So
you
have
one
element
that
is
just
reading
from
a
file
in
this
case.
B
Another
element
that
is
splitting
the
file
into
the
audio
and
video
parts,
then
you
have
decoders
for
the
audio
and
video
and
in
the
end
it
goes
to
the
speaker
or
the
screen
and
well.
This
is
a
playback
example,
but
you
could
also
imagine
that
in
the
beginning,
you
have
an
element
that
is
outputting.
The
video
from
your
camera
and
the
audio
from
your
microphone
while
you
are
on
could
happen,
input
that
somehow
reads
over
the
network.
B
You
could
send
data
out
over
the
network
in
the
end
each
of
these
elements
they
could
do
anything
they
would
like
to
do
with
the
data
and
you're.
Taking
all
these
little
components
put
them
together,
build
bigger
components
out
of
them
and
in
the
end
you
have
something
like
Lego
and
you
can
build
anything
you
would
like
to
out
of
this
out
of
small
little
components,
and
but
in
this
picture
it
all
looks
quite
static.
B
If
you
want
to
or
if
you
need,
and
the
general
philosophy
of
G
streamers,
that
we
provide
some
kind
of
tool
box
for
higher
level
and
multimedia
processing,
it's
not
a
finished
solution
for
anything,
but
it's
something
that
allows
you
to
build
solutions
for
anything
you
would
like
to
do
and
the
the
basis
is
that
we
have
some
kind
of
flexible,
extensible
design
that
is
based
on
simple
ideas
like
what
we
saw
before
with
the
pipelines.
It's
a
very
generic
API.
The
Koji's
from
api
does
not
know
anything
about
multimedia.
B
It
doesn't
know
anything
about
video
or
audio,
that's
something
that
is
added
in
other
components
and
the
main
focus
is
on
making
it
very
easy
to
embed
gstreamer
into
other
things
in
both
directions,
to
make
it
easy
to
embed
gstreamer
in
applications.
In
other
frameworks
like
cute
or
WebKit,
they
are,
for
example,
able
to
use
free
streamer
for
their
multimedia
needs,
but
also
on
the
other
side,
to
make
it
easy
to
embed
existing
multimedia
solutions.
B
Introducing
Malaika,
ffmpeg
OpenCV
we're
not
redeveloping
the
world
we
try
to
make
use
of
whatever
is
out
there
already,
and
the
target
systems
are
everything
from
embedded
systems
of
words
and
a
search.
This
might
serve,
doesn't
know
anything
about
audio
and
video.
Everything
is
added
via
plugins
and
we
will
have
some
kind
of
batteries
included,
philosophy
here,
and
there
are
more
than
250
plugins
provided
by
gstreamer.
If
you
just
get
the
source
code
and
build
it
and
they're
also
plugins,
that
are
reusing.
B
The
other
thing
yes
system
itself
is
completely
written
in
C
at
this
point,
but
nobody
wants
to
write
C
and
so
on.
We
provide
bindings
for
many
other
languages
like
Python,
c-sharp,
c++,
java,
gaudi
and
also
rust-
I
wouldn't
be
here
otherwise
and
yeah.
So
what
is
my
snot?
It's
not
a
media
player
or
playback
library,
it's
not
a
codec
or
protocol
library
or
not
a
transcoding
tool
or
not
a
streaming
server.
Many
people
seem
to
think
that
that's
not
what
it
is,
but
it's
something
that
can
be
used
for
building
all
these
things.
B
It's
something
more
generic
well
and
I,
say
it's
not
a
playback
library,
but
nowadays
we
also
include
a
little
playback
library
to
make
your
life
a
bit
easier
if
you
want
to
just
implement
a
playback
application,
but
it's
not
the
main
focus.
So
now,
let's
talk
a
bit
about
rust
and
why
gstreamer?
Why
for
GStreamer
rust
is
something
like
the
perfect
fit
well.
B
So
if
I
say
here
memory
safety
in
the
past
in
gstreamer,
what
we
had
is
a
couple
of
CDEs
many
bugs
related
to
memory
safety,
which
might
not
be
really
a
security
related
often
they
are,
but
it
might
not
also
be
just
something
that
is
annoying.
If
you
watch
a
movie,
for
example,
you
don't
want
it
to
stop
in
the
middle
just
because
something
is
crashing,
and
most
of
these
bugs
would
be
something
that
would
never
have
happened
with
rust,
sure
there
would
be
other
bugs,
but
at
least
not
those.
B
The
other
thing
is:
do
smells
heavily
multi-threaded
as
an
application
developer.
You
don't
really
see
that,
but
internally
everything
is
running
in
different
threads
in
a
normal
playback
application.
You
easily
have
tens
of
threads,
and
it's
very
annoying
to
do
this
kind
of
development
and
see
and
rust
can
help
here.
B
The
last
part,
well
I,
said
everything
is
written
in
C.
Nobody
wants
to
write
C
even
worse
in
the
case
of
GStreamer.
It's
using
the
object,
lots
of
macros,
very
hard
and
difficult
to
learn
and
using
rust
could
make
everything
much
more
convenient
to
use,
and
ideally
it
would
also
allow
us
to
find
new
developers
interested
in
using
or
developing
for
GStreamer,
because
new
developers
they
wanted
to
a
fancy
tools.
They
don't
want
to
learn
this.
We
are
C
and
G
objects
stuff.
They
want
something
modern
and.
B
Similarly,
rust
is
perfect
for
in
the
context
of
restreamer,
because
it
does
not
have
any
runtime.
It
does
not
have
any
garbage
collection
and
the
keywords:
zero
cost
abstractions,
because
our
goal
is
to
run
on
everything
from
low-power
embedded
systems
where
you
can't
really
afford
a
big
runtime
or
garbage
collection
up
to
anything
that
is
huge
and
in
general,
whenever
you
do
something
of
multimedia,
you
want
to
be
able,
for
example,
to
have
control
over
where
things
are
allocated.
When
are
they
located?
When
are
they
released
again
and
yeah
in
the
case
of
rust?
B
What
also
is
quite
useful
on
Isis
that
everything
in
the
end
is
compiling
down
to
very
optimized
code?
You
don't
have
something
like
yeah
like
something
like
an
interpreted
language
behind
that
it's
all
very
fast
and
low-level,
and
the
last
part
that
I
personally
like
very
much
is
that
the
ownership
model
for
things
like
video
frames
or
in
general
media
data
and
all
kinds
of
other
processing
related
things
inside
restreamer,
the
ownership
model
of
that
that's
perfectly
to
the
ownership
model
of
rust
and
so
far
from
all
the
languages
that
we
support.
B
Russ
is
the
only
language
where
this
mapping
is
really
one
to
one
and
in
the
end,
if
you
know
a
bit
the
arc
type
in
rust,
it
has
something
that
allows
you
to
do
at
runtime
copy-on-write.
So
you
can
check
with
this
reference
comment
at
container
thing.
If
you
are
the
only
owner,
if
you're
the
only
owner,
you
can
write
to
the
thing
if
you're,
if
not,
you
might
have
to
take
a
copy,
and
this
is
exactly
how
the
basic
types
and
GStreamer
are
working.
B
If
you're
the
only
owner,
you're
allowed
to
do
whatever
you
want
with
it.
Otherwise
you
might
have
to
take
a
copy
instead,
and
the
nice
thing
here
along
with
rust,
is
that
well
we
have
that
all
in
scene
and
see
you
have
to
call
all
kinds
of
functions
manually
in
the
case
of
rust,
the
compiler
is
making
sure
that
you
don't
forget
to
do
these
things
and
to
some
degree
it's
also
all
happening
automatically.
B
B
It's
all
based
on
the
infrastructure
that
GK
RSS,
providing
it's
also
using
the
same
code
generator
to
generate
most
of
the
bindings
code
from
the
API
metadata.
That
Giustra
is
providing
and
well
you
can
find
the
code
here.
It's
in
the
end
providing
some
kind
of
safe
and
more
or
less
idiomatic
bindings
to
the
gstreamer
api.
B
If
you
know
gstreamer,
you
can
probably
easily
learn
the
bindings,
because
in
the
end,
all
the
functions
are
called
the
same.
All
the
objects
are
all
the
same.
It's
just
a
different
language,
but
different
to
see
you
actually
have
something
that
is
safer
or
in
this
case
actually
memory
safe
to
use
personally.
I
use
the
bindings
now
for
everything.
B
That's
just
like,
if
you
are
it's
as
if
you
had
written
the
test
case
and
see,
there's
no
no
heavy,
runtime
or
anything
in
between
and
this
stuff
is
all
stable
and
ready
to
be
used.
You
can
also
find
it
on
credit.
I
oh
it
works
at
least
on
Linux,
Mac,
OS
and
Windows
I
didn't
try
it
anywhere
else.
I
would
assume
that
it
also
works
as
well.
B
The
other
part
that
is
very
important
for
us
to
mess
that
all
the
functionality
is
provided
via
plugins
and
with
the
code
that
you
can't
find
here,
you
can
find
some
kind
of
infrastructure
that
allows
you
to
write
plug-ins
for
gstreamer
in
rust,
completely
plain
rust.
They
are
for
writing
the
plugins.
You
don't
have
to
use
any
macros,
any
weird
language
constructs
or
anything
you
just
have
to
implement.
A
few
trades
then
implement
the
functions
of
the
trades,
and
that's
it.
B
Of
course,
not
everything
is
perfect,
as
I
said,
GCMs
based
on
the
object,
so
there's
some
kind
of
object-oriented
paradigm
behind
that,
so
we
induce
Tamala
there's
lots
of
inheritance
happening
well,
it's
kind
of
emulated
in
this
infrastructure
with
trades,
it's
not
perfect,
but
it
works,
and
it's
not
as
ugly
as
I
would
have
expected
from
before.
I
started
this
so
on.
B
What
is
currently
available
in
as
plugins
written
in
rust
is
if
a
vida
Maxo,
which
is
the
container
format
that
was
used
by
flash
in
the
past,
there's
an
HTTP
sauce
that
is
using
high
power.
There's
some
audio
and
video
filters
available,
there's
Amazon,
s3
source
and
sync
available
in
other
repositories.
There's
start
of
animated
gif
decoder,
VA,
API,
sync
and
all
kinds
of
things
that
are
probably
don't
know
about.
It's
not
complete.
B
Yet
it's
in
the
very
early
stages,
but
nonetheless
it's
useful
already
and
you
can
use
it
to
write-
do
summer,
plugins
to
extend
juice
tomorrow
with
new
functionality
and
all
these
plugins.
While
they
are
written
in
rust,
they
will
work
in
any
gstreamer
application,
no
matter
what
language
this
application
is
written
in.
B
B
There
are
various
codec
libraries
already
available
in
rust,
this
a
flux
decoder
for
the
flacc
audio
format,
there's
a
Vorbis
decoder,
that's
the
start
of
an
AV
one,
video
encoder
available
some
subtitle
decoders,
and
it
would
be
nice
to
wrap
all
these
existing
rust
libraries
and
add
restreamer
plugin,
because
then
every
user
of
GStreamer
would
have
something
safe
available,
something
that
is
not
wrapped
around
decades
old
syllabus
that
nobody
is
maintaining
anymore.
So
that
would
be
very,
very
nice
and
the
other
thing
would
be
to
write
more
applications
more
useful
applications
in
rust.
B
Currently,
they
are
not
that
many
out
there
people
are
just
starting
to
use
the
bindings,
and
all
of
this
is
something
where
you
can
also
get
involved
if
you're
interested
in
this
kind
of
stuff.
Just
look
at
the
existing
code.
Look
at
the
existing
examples
if
you've
any
questions,
ask
me
all
this
is
something
that
I
really
care
about
and
if
you
need
help
with
that,
just
ask
for
help.
B
What
we
are
not
going
to
do
at
this
point
is
to
rewrite
this
demand
rust.
It's
a
lot
of
code.
Nobody
is
going
to
have
the
time
for
rewriting
all
that,
but
in
the
long
run,
if
we
continue
continue
to
see
that
rust
is
really
the
perfect
fit
quad
gstreamer
components
could
be
rewritten
and
rust,
but
that's
all
in
long
run.
First
of
all,
applications
and
plugins,
which
is
already
a
huge
part
and
also
now,
would
be
the
perfect
time
for
you
to
start
writing
do
some
applications
in
pluck
and
plugins
in
rust.
B
B
So
my
rust
experience
so
far
I
said
before
I'm,
using
it
for
my
own
projects
wherever
possible,
we
are
at
simple
and
it's
in
pretty
low.
We
are
also
using
it
for
various
client
projects.
By
now,
it's
mostly
little
applications
or
our
plugins,
and
for
myself
everything
is
much
much
more
enjoyable
to
write
in
rust
than
in
C,
and
also
more
and
roil,
or
also
on
from
water
source
of
our
rust
is
much
better
or
much
better
suited
for
this
kind
of
applications
than
any
of
the
other
languages
are
tried
before
some
things.
B
B
It's
just
not
written
on
on
it,
so
if
you
really
have
to
use
unsafe
code,
don't
be
afraid
to
do
that,
just
do
it
but
wrap
it
in
safe
abstractions
and
before
you
do
something
very
complicated
and
never
get
your
code
finished
it's
better
to
do
something
unsafe,
especially
if
it's
impossible
to
do
otherwise
like
for
FFI
or
for
optimizations
or
in
some
cases.
If
you
implement
your
own
data
structures
and
have
situations
where
you
can't
possibly
convince
the
compiler
that
what
you
are
doing
there
is
safe.
These
guys
exist
and
well
use
unsafe
code.
B
If
you
have
to
another
thing,
I
noticed
is
that
people
are
looking
at
rust
projects
and
also,
for
example,
the
G
Summa
bindings,
and
they
have
a
million
dependencies,
and
people
coming
from
C
are
usually
very
afraid
of
that,
because
dependencies
there's
something
they
difficult.
You
somehow
have
to
compile
all
that
and
it's
other
people's
code.
It
might
not
work
properly.
You
might
not
have
a
way
to
fix
it
so
far.
My
experience
with
rust
in
this
regard
is
quite
the
opposite.
It's
very
easy
to
depend
on
something
new.
It's
very
easy
to
create.
B
Your
own
fork
of
that,
if
you
have
to
fix
something
in
the
maintain,
that's
not
available,
but
what
I
noticed
so
far
is
that
all
the
projects
that
I'm,
depending
on
remain
the
maintenance,
are
very
active,
very
friendly
and
helpful.
Even
if
I
don't
want
to
fix
anything
in
there.
Usually
they
are
interested
in
fixing
it
and
otherwise,
usually
the
code
is
kind
of
clean.
B
You
don't
have
the
situation
that
you
haven't
see
that
you
might
use
the
library
that
was
written
20
years
ago
in
a
code
style
that
nobody
would
use
nowadays
anymore
and
it's
just
impossible
to
read.
But
I
guess
that's
just
because
the
language
is
kind
of
new
and
the
other
part
is
people
shouldn't
be
really
afraid
of
performance
penalties
for
using
high-level
abstractions,
especially
things
like
iterators.
They
look
like
complete
magic,
but
in
the
end
they
compile
compile
down
to
very
fast
and
optimized
code.
B
B
B
Well,
so
the
question
was
that
he
was
talking
to
someone
before
who's
writing
this
summer
code
and
why
they
don't
use
trust,
and
the
answer
was-
and
currently
it's
impossible
to
submit
rust
through
Summa
plugins
to
the
existing
system
of
source
code
modules,
which
is
true
unfortunately.
But
for
that
the
at
least
my
plan
in
the
near
future
is
that
we
will
have
a
new
plug-in
module
called
I.
B
B
Is
that
where
you
have
to
convince
people
that
this
new
language
is
something
that
it's
not
going
to
make
their
life
more
difficult
to
have
inside
the
main
source
code
modules
and
also
on
currently,
the
build
system
is
all
Auto
tools
or
Mazzone
based
and
building
blast
code
from
there.
It's
not
trivial.
So
something
else
that
is
separate
and
completely
cago
based
would
be
much
much
nicer.
But
the
goal
is
to
have
something
like
an
official
rust
plug-in
module
where
all
the
things
are
collected.
B
So
the
question
was:
if
I
see
existing
system
are
plugins,
replaced
by
rust
versions
of
them
and
yes,
I
think
so.
There's
one
that
is
the
FLV
democracy
that
I
mentioned
earlier.
That's
almost
feature
equivalent
with
existing
one
that
is
written
in
C
and
that
could
very
well
replace
it.
But
in
the
end
we
don't
really
have
to
replace
it
it.
It
is
enough
if
it
exists
as
an
additional
atom
AXA.
B
We
could
give
it
a
higher
priority
so
that
whenever
it
is
installed,
it
will
be
used,
and
otherwise
people
who
don't
want
to
worry
about
how
to
compile
this.
We
addressed
code.
They
could
just
continue
using
the
C
version,
but
yeah
same
thing
with
the
HTTP
sauce
that
I
mentioned
before
the
goal
is
to
make
it
feature
equivalent
with
the
existing
one
written
in
C,
and
then
it
would
also
be
a
replacement.