Employing Gstreamer in Node.js – LogRocket Web site


Web Development


GStreamer is a framework for building streaming media apps. With the GStreamer framework, it is possible to design and establish lower-latency purposes that can deal with any form of streaming information stream, including both of those audio and video capabilities.

GStreamer core provides a framework for plugins, facts circulation, and media variety dealing with. It also supplies an API to compose applications applying the various plugins.

The plugin-based framework offers different codec and other functionalities that can be linked and organized in a pipeline, which defines the move of the details. However, as of the time of composing, there is no formal Node.js port/binding for GStreamer applications.

In this submit, we’ll communicate about GStreamer’s functionalities and location it up with Node as a result of the subsequent sections:

Features and use situations

1 of the major use cases of GStreamer is for constructing media players. As a developer, you can use an intensive set of effective applications to build media pipelines with no producing a one line of code.

By default, GStreamer contains parts for setting up a media participant with assist for a quite huge selection of formats, such as MP3, Ogg/Vorbis, MPEG-1/2, AVI, QuickTime, mod, and so on.

GStreamer, even so, gives a great deal more than other media gamers. Its main pros are that the pluggable components can be combined into arbitrary pipelines so that it’s feasible to compose a video clip or audio editing application. Specifically, GStreamer gives:

  • An API for multimedia applications
  • A plugin architecture
  • A pipeline architecture
  • A system for media style handling/negotiation

GStreamer plugin architecture

By means of plugins, GStreamer can bridge to other multimedia frameworks to reuse current factors (e.g. codecs) and other platform enter/output mechanisms.

The main of GStreamer is fundamentally media-agnostic. It only is aware about bytes and blocks, and only is made up of simple features. All of the media-handling performance is offered by plugins external to the main. These inform the main how to handle precise sorts of media.

GStreamer plugins can be labeled into the following groups:

  • Protocols dealing with
  • Resources: for audio and video clip (entails protocol plugins)
  • Formats: parsers, formaters, muxers, demuxers, metadata, subtitles
  • Codecs: coders and decoders
  • Filters: converters, mixers, results
  • Sinks: for audio and online video (entails protocol plugins)

GStreamer Installation

To put in GStreamer, the documentation offers many approaches to opt for from based on your decision of working method.

For macOS X, we require to install OSX Snow Leopard (10.6) or later on and XCode 3.2.6 or afterwards. Having said that, the recommended procedure edition is macOS Sierra with XCode 8. We can install both the runtime and the improvement installers from the GStreamer download website page, which we can find below.

For other running techniques/environments, which includes Home windows, iOS, Android, and Linux, we can have a appear at the downloads webpage in the documentation, which is composed of a list of all supported ecosystems and approaches of developing GStreamer SDKs for developmental functions.

We can navigate to the /Library/Frameworks/GStreamer.framework/Instructions on our method route to have a look at obtainable commands to play all-around with GStreamer. Some of the well-known instructions consist of gst-launch-1., gst-inspect-1., gst-participate in-1..

Placing up GStreamer with Node.js

Following the installation, we can go in advance to make use of the Node.js runtime to take in a GStreamer pipeline and output the result to a net browser.

Let’s generate a folder of our preference and put in Express.js using npm or Yarn and stick to the guidance to setup a essential job with a package.json file:

npm install specific or yarn add convey

Then go forward to make an index.js file to keep the JavaScript code for our streaming illustration with GStreamer. See the index.js file below:

Much more terrific articles or blog posts from LogRocket:

const convey = demand('express')
const http = demand('http')
const internet = call for('net')
const kid = have to have('child_process')

const app = convey()
application.use(express.static(__dirname + "https://weblog.logrocket.com/"))

const httpServer = http.createServer(application)
const port = 3000  

//send the html web site which holds the video tag
app.get("https://blog.logrocket.com/", function (req, res) 

//quit the connection
application.article('/stop', functionality (req, res) 
    console.log('Connection shut employing /prevent endpoint.')
    if (gstMuxer != undefined) 
        gstMuxer.get rid of()    //kill the GStreamer Pipeline
    gstMuxer = undefined

//send out the video clip stream
app.get("https://web site.logrocket.com/stream", perform (req, res) 
        'Content-Type': 'video/webm',

    const tcpServer = web.createServer(functionality (socket) 
        socket.on('data', operate (facts) 
        socket.on('close', function () 
            console.log('Socket closed.')

    tcpServer.maxConnections = 1

    tcpServer.listen(operate () 
        console.log("Link started out.")
        if (gstMuxer == undefined) 
            console.log("inside gstMuxer == undefined")
            const cmd = 'gst-launch-1.0'
            const args = getGstPipelineArguments(this)
            const gstMuxer = little one.spawn(cmd, args)
            gstMuxer.stderr.on('data', onSpawnError)
            gstMuxer.on('exit', onSpawnExit)
            console.log("New GST pipeline rejected simply because gstMuxer != undefined.")

console.log(`Camera Streaming Application listening at http://localhost:$port`)

process.on('uncaughtException', operate (err) 

perform onSpawnError(data) 

function onSpawnExit(code) 
    if (code != null) 
        console.log('GStreamer mistake, exit code ' + code)

functionality getGstPipelineArguments(tcpServer) 
    const args =
        ['/Users/alexandernnakwue/Downloads/samplevideo.mp4', 'pattern=ball',
            '!', 'video/x-raw,width=320,height=240,framerate=100/1',
            '!', 'vpuenc_h264', 'bitrate=2000',
            '!', 'mp4mux', 'fragment-duration=10',
            '!', 'tcpclientsink', 'host=localhost',
            'port=" + tcpServer.address().port]
    return args

As we can see in the file over, we have three endpoints:

  1. An endpoint to deliver the HTML web page, which holds the video tag
  2. An endpoint to ship the video stream
  3. An endpoint to end the relationship

Following, produce the HTML web page (index.html), which retains the video tag as revealed down below.

    GStreamer with NodeJS Demo


As I stated in the introduction, there are at this time no formal ports or bindings for Node.js. The code previously mentioned is tailored from this Stack Overflow submit.

We can progress to use the gst-start-1. command to commence the streaming application and the arguments, which incorporate the movie or audio supply for streaming, the TCP port and tackle, configurations, and so on. As the web page masses, we are enjoying the online video stream as shortly as attainable with the enjoy() approach.

Notice: This only functions in Chromium-centered browsers. I’ll clarify extra beneath.l

Some Gstreamer constraints

Today’s current implementation of GStreamer for Node.js is non-standardized and still lacking. For occasion, the present implementation is not totally browser appropriate and only will work in Chromium-based kinds, because some of the HTTP headers wanted in Chrome to load assets are not available. Additionally, it is however a challenging endeavor to construct GStreamer on some technique architecture mainly because it however consists of a lot of bugs.

GStreamer does not but guidance ports for multiple different programming languages directly. This usually means that builders who intend to make use of GStreamer in Node.js purposes need to use the node-addon-api to connect with C code from Node straight. This process, nevertheless, involves lots of perform and can be in particular mistake-inclined when setting up with node-gyp.


As we might have found, there are minimal GStreamer bindings for Node.js currently.

There are other bindings obtainable, these types of as the node-gstreamer-superficial, but in accordance to the documentation, it does not attempt to be a complete JS binding for GStreamer, and will hopefully one particular day be changed by (or implemented with) node-gir.

Other obtainable bindings or hacks just do not do the job as predicted, are not standardized, or are bug-vulnerable. This is in fact a enormous problem and in the in close proximity to upcoming, a standardized and sector-broad port of the Node.js binding desires to be developed.

200’s only Keep track of unsuccessful and gradual network requests in generation

Deploying a Node-based web app or web page is the effortless portion. Creating guaranteed your Node instance carries on to serve methods to your application is exactly where items get tougher. If you’re interested in making certain requests to the backend or 3rd party solutions are productive, check out LogRocket. LogRocket Network Request Monitoringhttps://logrocket.com/signup/

LogRocket is like a DVR for net and mobile apps, recording virtually almost everything that happens when a user interacts with your app. As a substitute of guessing why issues come about, you can combination and report on problematic community requests to speedily have an understanding of the root induce.

LogRocket instruments your application to history baseline efficiency timings these types of as web site load time, time to 1st byte, gradual community requests, and also logs Redux, NgRx, and Vuex actions/state. Get started monitoring for free.

Leave a Reply

Your email address will not be published.