Download as PDF book

Kurento Documentation
Release 5.0.5
kurento.org
February 05, 2015
Contents
I
II
What’s Kurento?
Introducing Kurento
3
7
1
WebRTC media servers
9
2
Kurento Media Server
11
3
Kurento API, Clients, and Protocol
13
4
Creating applications with Kurento
17
III
Kurento Media Server Installation
19
IV
Kurento Tutorials
23
5
Tutorial 1 - Hello world
5.1 Java Tutorial 1 - Hello world . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2 JavaScript Tutorial 1 - Hello world . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3 Node.js Tutorial 1 - Hello world . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
27
27
34
39
6
Tutorial 2 - WebRTC magic mirror
6.1 Java Tutorial 2 - WebRTC magic mirror . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.2 JavaScript Tutorial 2 - Magic Mirror . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.3 Node.js Tutorial 2 - WebRTC magic mirror . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
47
47
54
58
7
Tutorial 3 - WebRTC one-to-many broadcast
7.1 Tutorial 3 - One to many video call . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.2 Tutorial 3 - One to many video call . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
65
65
74
8
Tutorial 4 - WebRTC one-to-one video call
8.1 Tutorial 4 - One to one video call . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.2 Tutorial 4 - One to one video call . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
83
83
94
9
Tutorial 5 - WebRTC one-to-one video call with recording and filtering
105
9.1 Tutorial 5 - Advanced One to one video call . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
i
V
Mastering Kurento
121
10 Kurento Architecture
123
10.1 Kurento Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
11 Kurento API Reference
131
11.1 Kurento API Reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
12 Kurento Protocol
137
12.1 Kurento Protocol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
13 Advanced Installation Guide
145
13.1 Kurento Media Server Advanced Installation guide . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
14 Working with Nightly Builds
149
14.1 Working with nightly builds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
15 Kurento Modules
153
15.1 Kurento Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
16 Kurento Java Client JavaDoc
209
17 Kurento JavaScript Client JsDoc
211
18 Kurento JavaScript Utils JsDoc
213
VI
Kurento FAQ
215
19 How do I...
219
20 Why do I get the error...
223
VII
Index
ii
Glossary
225
233
Kurento Documentation, Release 5.0.5
Contents
1
Kurento Documentation, Release 5.0.5
2
Contents
Part I
What’s Kurento?
3
Kurento Documentation, Release 5.0.5
Kurento is a WebRTC media server and a set of client APIs making simple the development of advanced video
applications for WWW and smartphone platforms. Kurento features include group communications, transcoding,
recording, mixing, broadcasting and routing of audiovisual flows.
Kurento also provides advanced media processing capabilities involving computer vision, video indexing, augmented
reality and speech analysis. Kurento modular architecture makes simple the integration of third party media processing
algorithms (i.e. speech recognition, sentiment analysis, face recognition, etc.), which can be transparently used by
application developers as the rest of Kurento built-in features.
Kurento’s core element is Kurento Media Server, responsible for media transmission, processing, loading and recording. It is implemented in low level technologies based on GStreamer to optimize the resource consumption. It provides
the following features:
• Networked streaming protocols, including HTTP (working as client and server), RTP and WebRTC.
• Group communications (MCUs and SFUs functionality) supporting both media mixing and media routing/dispatching.
• Generic support for computational vision and augmented reality filters.
• Media storage supporting writing operations for WebM and MP4 and playing in all formats supported by
GStreamer.
• Automatic media transcodification between any of the codecs supported by GStreamer including VP8, H.264,
H.263, AMR, OPUS, Speex, G.711, etc.
There are available Kurento Client libraries in Java and Javascript to control Kurento Media Server from applications.
If you prefer another programming language, you can use the Kurento Protocol, based on WebSocket and JSON-RPC.
Kurento is open source, released under the terms of LGPL version 2.1 license. Its source code is hosted on GitHub.
If you want to put your hands on quickly, the best way is installing the Kurento Media Server and take a look to
our tutorials in form of working demo applications. You can choose your favorite technology to build multimedia
applications: Java, Browser JavaScript or Node.js.
If you want to make the most of Kurento, please take a look to the advanced documentation.
5
Kurento Documentation, Release 5.0.5
6
Part II
Introducing Kurento
7
CHAPTER 1
WebRTC media servers
WebRTC is an open source technology that enables web browsers with Real-Time Communications (RTC) capabilities
via JavaScript APIs. It has been conceived as a peer-to-peer technology where browsers can directly communicate
without the mediation of any kind of infrastructure. This model is enough for creating basic applications but features
such as group communications, media stream recording, media broadcasting or media transcoding are difficult to
implement on top of it. For this reason, many applications require using a media server.
Figure 1.1: Peer-to-peer WebRTC approach vs. WebRTC through a media server
Conceptually, a WebRTC media server is just a kind of “multimedia middleware” (it is in the middle of the communicating peers) where media traffic pass through when moving from source to destinations. Media servers are capable
of processing media streams and offering different types including groups communications (distributing the media
stream one peer generates among several receivers, i.e. acting as Multi-Conference Unit, MCU), mixing (transforming several incoming stream into one single composite stream), transcoding (adapting codecs and formats between
incompatible clients), recording (storing in a persistent way the media exchanged among peers), etc.
9
Kurento Documentation, Release 5.0.5
Figure 1.2: Typical WebRTC Media Server capabilities
10
Chapter 1. WebRTC media servers
CHAPTER 2
Kurento Media Server
At the heart of the Kurento architecture there is a media server called the Kurento Media Server (KMS). Kurento
Media Server is based on pluggable media processing capabilities meaning that any of its provided features is a
pluggable module that can be activated or deactivated. Moreover, developers can seamlessly create additional modules
extending Kurento Media Server with new functionalities which can be plugged dynamically.
Kurento Media Server provides, out of the box, group communications, mixing, transcoding, recording and playing.
In addition, it also provides advanced modules for media processing including computer vision, augmented reality,
alpha blending and much more.
Figure 2.1: Kurento Media Server capabilities
11
Kurento Documentation, Release 5.0.5
12
Chapter 2. Kurento Media Server
CHAPTER 3
Kurento API, Clients, and Protocol
Kurento Media Server capabilities are exposed by the Kurento API to application developers. This API is implemented by means of libraries called Kurento Clients. Kurento offers two clients out of the box for Java and
JavaScript. If you have another favorite language, you can still use Kurento using directly the Kurento Protocol.
This protocol allows to control Kurento Media Server and it is based on Internet standards such as WebSocket and
JSON-RPC. The picture below shows how to use Kurento Clients in three scenarios:
• Using the Kurento JavaScript Client directly in a compliant WebRTC browser
• Using the Kurento Java Client in a Java EE Application Server
• Using the Kurento JavaScript Client in a Node.js server
Complete examples for these three technologies is described in the tutorials section.
Kurento Client’s API is based on the concept of Media Element. A Media Element holds a specific media capability.
For example, the media element called WebRtcEndpoint holds the capability of sending and receiving WebRTC media
streams, the media element called RecorderEndpoint has the capability of recording into the file system any media
streams it receives, the FaceOverlayFilter detects faces on the exchanged video streams and adds a specific overlaid
image on top of them, etc. Kurento exposes a rich toolbox of media elements as part of its APIs.
To better understand theses concepts it is recommended to take a look to Kurento API and Kurento Protocol sections.
You can also take a loot to the JavaDoc and JsDoc:
• kurento-client-java : JavaDoc of Kurento Java Client.
• kurento-client-js : JsDoc of Kurento JavaScript Client.
• kurento-utils-js : JsDoc of an utility JavaScript library aimed to simplify the development of WebRTC applications.
13
Kurento Documentation, Release 5.0.5
Figure 3.1: Connection of Kurento Clients (Java and JavaScript) to Kuento Media Server
14
Chapter 3. Kurento API, Clients, and Protocol
Kurento Documentation, Release 5.0.5
Figure 3.2: Some Media Elements provided out of the box by Kurento
15
Kurento Documentation, Release 5.0.5
16
Chapter 3. Kurento API, Clients, and Protocol
CHAPTER 4
Creating applications with Kurento
From the application developer perspective, Media Elements are like Lego pieces: you just need to take the elements
needed for an application and connect them following the desired topology. In Kurento jargon, a graph of connected
media elements is called a Media Pipeline. Hence, when creating a pipeline, developers need to determine the capabilities they want to use (the media elements) and the topology determining which media elements provide media to
which other media elements (the connectivity). The connectivity is controlled through the connect primitive, exposed
on all Kurento Client APIs. This primitive is always invoked in the element acting as source and takes as argument the
sink element following this scheme:
sourceMediaElement.connect(sinkMediaElement)
For example, if you want to create an application recording WebRTC streams into the file system, you’ll need two
media elements: WebRtcEndpoint and RecorderEndpoint. When a client connects to the application, you will need to
instantiate these media elements making the stream received by the WebRtcEndpoint (which is capable of receiving
WebRTC streams) to be feed to the RecorderEndpoint (which is capable of recording media streams into the file
system). Finally you will need to connect them so that the stream received by the former is fed into the later:
WebRtcEndpoint.connect(RecorderEndpoint)
To simplify the handling of WebRTC streams in the client-side, Kurento provides an utility called WebRtcPeer. Nevertheless, the standard WebRTC API (getUserMedia, RTCPeerConnection, and so on) can also be used to connect to
WebRtcEndpoints. For further information please visit the tutorials section.
Figure 4.1: Simple Example of a Media Pipeline
17
Kurento Documentation, Release 5.0.5
18
Chapter 4. Creating applications with Kurento
Part III
Kurento Media Server Installation
19
Kurento Documentation, Release 5.0.5
Kurento Media Server has to be installed on Ubuntu 14.04 LTS (32 or 64 bits).
In order to install the latest stable Kurento Media Server version you have to type the following commands, one at a
time and in the same order as listed here. When asked for any kind of confirmation, reply affirmatively:
sudo add-apt-repository ppa:kurento/kurento
sudo apt-get update
sudo apt-get install kurento-media-server
Take into account that if your are installing Kurento Media Server in Ubuntu Server 14.04, the tool add-apt-repository
is not installed by default. To install it, run this command:
sudo apt-get install software-properties-common
Now, Kurento Media Server has been installed and started. Use the following commands to start and stop it respectively:
sudo service kurento-media-server start
sudo service kurento-media-server stop
Kurento Media Server has a log file located at /var/log/kurento-media-server/media-server.log.
21
Kurento Documentation, Release 5.0.5
22
Part IV
Kurento Tutorials
23
Kurento Documentation, Release 5.0.5
This section contains tutorials showing how to use Kurento framework to build different types of WebRTC and multimedia applications. Turorials come in three flavors:
• Java: These show applications where clients interact with an application server based on Java EE technology.
The application server hold the logic orchestrating the communication among the clients and controlling Kurento
Server capabilities for them.
• Browser JavaScript: These show applications executing at the browser and communicating directly with the
Kurento Media Server. In these tutorial, all the application logic is hold by the browser. Hence, no application
server is necessary. For these reasons, these applications need to be simple.
• Node.js: These show applications where clients interact with an application server based on Node.js technology. The application server holds the logic orchestrating the communication among the clients and controlling
Kurento Media Server capabilities for them.
Note: These tutorials have been created with learning objectives. They are not intended to be used in production
environments where different unmanaged error conditions may emerge.
25
Kurento Documentation, Release 5.0.5
26
CHAPTER 5
Tutorial 1 - Hello world
This is one of the simplest WebRTC application you can create with Kurento. It implements a WebRTC loopback (a
WebRTC media stream going from client to Kurento and back to the client)
5.1 Java Tutorial 1 - Hello world
This web application has been designed to introduce the principles of programming with Kurento for Java developers.
It consists on a WebRTC video communication in mirror (loopback). This tutorial assumes you have basic knowledge
on JavaScript, HTML and WebRTC. We also recommend reading the Introducing Kurento section before starting this
tutorial.
5.1.1 For the impatient: running this example
You need to have installed the Kurento Media Server before running this example. Read the installation guide for
further information.
To launch the application you need to clone the GitHub project where this demo is hosted and then run the main class,
as follows:
git clone https://github.com/Kurento/kurento-tutorial-java.git
cd kurento-tutorial-java/kurento-hello-world
mvn compile exec:java
Access the application connecting to the URL http://localhost:8080/ through a WebRTC capable browser (Chrome,
Firefox).
5.1.2 Understanding this example
Kurento provides developers a Kurento Java Client to control Kurento Media Server. This client library can be
used in any kind of Java application: Server Side Web, Desktop, Android, etc. It is compatible with any framework
like Java EE, Spring, Play, Vert.x, Swing and JavaFX.
This hello world demo is one of the simplest web application you can create with Kurento. The following picture
shows an screenshot of this demo running:
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one showing the local
stream (as captured by the device webcam) and the other showing the remote stream sent by the media server back to
the client.
27
Kurento Documentation, Release 5.0.5
Figure 5.1: Kurento Hello World Screenshot: WebRTC in loopback
28
Chapter 5. Tutorial 1 - Hello world
Kurento Documentation, Release 5.0.5
The logic of the application is quite simple: the local stream is sent to the Kurento Media Server, which returns it back
to the client without modifications. To implement this behavior we need to create a Media Pipeline composed by a
single Media Element, i.e. a WebRtcEndpoint, which holds the capability of exchanging full-duplex (bidirectional)
WebRTC media flows. This media element is connected to itself so that the media it receives (from browser) is send
back (to browser). This media pipeline is illustrated in the following picture:
Figure 5.2: Kurento Hello World Media Pipeline in context
This is a web application, and therefore it follows a client-server architecture. At the client-side, the logic is implemented in JavaScript. At the server-side we use a Java application server consuming the Kurento Java Client API
to control Kurento Media Server capabilities. All in all, the high level architecture of this demo is three-tier. To
communicate these entities the following technologies are used:
• REST: Communication between JavaScript client-side and Java application server-side.
• WebSocket: Communication between the Kurento Java Client and the Kurento Media Server. This communication is implemented by the Kurento Protocol. For further information, please see this page of the documentation.
The diagram below shows an complete sequence diagram from the interactions with the application interface to: i)
JavaScript logic; ii) Application server logic (which uses the Kurento Java Client); iii) Kurento Media Server.
Note: The communication between client and server-side does not need to be REST. For simplicity, in this tutorial
REST has been used. In later examples a more complex signaling between client and server has been implement, using
WebSockets. Please see later tutorials for further information.
The following sections analyze in deep the server (Java) and client-side (JavaScript) code of this application. The
complete source code can be found in GitHub.
5.1.3 Application Server Logic
This demo has been developed using Java in the server-side with Spring Boot framework. This technology can be
used to embed the Tomcat web server in the application and thus simplify the development process.
5.1. Java Tutorial 1 - Hello world
29
Kurento Documentation, Release 5.0.5
Figure 5.3: Complete sequence diagram of Kurento Hello World (WebRTC in loopbak) demo
30
Chapter 5. Tutorial 1 - Hello world
Kurento Documentation, Release 5.0.5
Note: You can use whatever Java server side technology you prefer to build web applications with Kurento. For
example, a pure Java EE application, SIP Servlets, Play, Vert.x, etc. Here we chose Spring Boot for convenience.
In the following figure you can see a class diagram of the server side code:
Figure 5.4: Server-side class diagram of the HelloWorld app
HelloWorldApp
HelloWorldController
KurentoClient
The main class of this demo is HelloWorldApp. As you can see, the KurentoClient is instantiated in this class as a
Spring Bean. This bean is used to create Kurento Media Pipelines, which are used to add media capabilities to the
application. In this instantiation we see that we need to specify to the client library the location of the Kurento Media
Server. In this example, we assume it’s located at localhost listening in port 8888. If you reproduce this example
you’ll need to insert the specific location of your Kurento Media Server instance there.
Once the Kurento Client has been instantiated, you are ready for communicating with Kurento Media Server and
controlling its multimedia capabilities.
@ComponentScan
@EnableAutoConfiguration
public class HelloWorldApp {
@Bean
public KurentoClient kurentoClient() {
return KurentoClient.create("ws://localhost:8888/kurento");
}
public static void main(String[] args) throws Exception {
new SpringApplication(HelloWorldApp.class).run(args);
}
}
As introduced before, we use REST to communicate the client with the Java application server. Specifically, we use
the Spring annotation @RestController to implement REST services in the server-side. Take a look to the HelloWorldController class:
@RestController
public class HelloWorldController {
@Autowired
private KurentoClient kurento;
5.1. Java Tutorial 1 - Hello world
31
Kurento Documentation, Release 5.0.5
@RequestMapping(value = "/helloworld", method = RequestMethod.POST)
private String processRequest(@RequestBody String sdpOffer)
throws IOException {
// Media Logic
MediaPipeline pipeline = kurento.createMediaPipeline();
WebRtcEndpoint webRtcEndpoint = new WebRtcEndpoint.Builder(pipeline)
.build();
webRtcEndpoint.connect(webRtcEndpoint);
// SDP negotiation (offer and answer)
String responseSdp = webRtcEndpoint.processOffer(sdpOffer);
return responseSdp;
}
}
The application logic is implemented in the method processRequest. POST Requests to path /helloworld will fire this
method, whose execution has two main parts:
• Configure media processing logic: This is the part in which the application configures how Kurento has to
process the media. In other words, the media pipeline is created here. To that aim, the object KurentoClient
is used to create a MediaPipeline object. Using it, the media elements we need are created and connected. In
this case, we only instantiate one WebRtcEndpoint for receiving the WebRTC stream and sending it back to the
client.
• WebRTC SDP negotiation: In WebRTC, an SDP (Session Description protocol) is used for negotiating media
exchanges between apps. Such negotiation happens based on the SDP offer and answer exchange mechanism.
In this example we assume the SDP offer and answer contain all WebRTC ICE candidates. This negotiation is
implemented in the second part of the method processRequest, using the SDP offer obtained from the browser
client and returning a SDP answer generated by WebRtcEndpoint.
5.1.4 Client-Side Logic
Let’s move now to the client-side of the application, which follows Single Page Application architecture (SPA). To call
the previously created REST service, we use the JavaScript library jQuery. In addition, we use a Kurento JavaScript
utilities library called kurento-utils.js to simplify the WebRTC management in the browser. This library depends
on adapter.js, which is a JavaScript WebRTC utility maintained by Google that abstracts away browser differences.
Finally jquery.js is also needed in this application.
These libraries are linked in the index.html web page, and are used in the index.js. In the start function we can see
how jQuery is used to send a POST request to the path /helloworld, where the application server REST service is
listening. The function WebRtcPeer.startSendRecv abstracts the WebRTC internal details (i.e. PeerConnection and
getUserStream) and makes possible to start a full-duplex WebRTC communication, using the HTML video tag with id
videoInput to show the video camera (local stream) and the video tag videoOutput to show the remote stream provided
by the Kurento Media Server.
var webRtcPeer;
function start() {
console.log("Starting video call ...");
showSpinner(videoInput, videoOutput);
webRtcPeer =
kurentoUtils.WebRtcPeer.startSendRecv(videoInput, videoOutput, onOffer, onError);
}
32
Chapter 5. Tutorial 1 - Hello world
Kurento Documentation, Release 5.0.5
function onOffer(sdpOffer) {
console.info('Invoking SDP offer callback function ' + location.host);
$.ajax({
url : location.protocol + '/helloworld',
type : 'POST',
dataType : 'text',
contentType : 'application/sdp',
data : sdpOffer,
success : function(sdpAnswer) {
console.log("Received sdpAnswer from server. Processing ...");
webRtcPeer.processSdpAnswer(sdpAnswer);
},
error : function(jqXHR, textStatus, error) {
onError(error);
}
});
}
function onError(error) {
console.error(error);
}
5.1.5 Dependencies
This Java Spring application is implemented using Maven. The relevant part of the pom.xml is where Kurento dependencies are declared. As the following snippet shows, we need two dependencies: the Kurento Client Java dependency
(kurento-client) and the JavaScript Kurento utility library (kurento-utils) for the client-side:
<dependencies>
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-client</artifactId>
<version>[5.0.0,6.0.0)</version>
</dependency>
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-utils-js</artifactId>
<version>[5.0.0,6.0.0)</version>
</dependency>
</dependencies>
Kurento framework uses Semantic Versioning for releases. Notice that range [5.0.0,6.0.0) downloads the latest
version of Kurento artefacts from Maven Central in version 5 (i.e. 5.x.x). Major versions are released when incompatible changes are made.
Note: We are in active development. You can find the latest version of Kurento Java Client at Maven Central.
Kurento Java Client has a minimum requirement of Java 7. Hence, you need to include the following in the properties
section:
<maven.compiler.target>1.7</maven.compiler.target>
<maven.compiler.source>1.7</maven.compiler.source>
5.1. Java Tutorial 1 - Hello world
33
Kurento Documentation, Release 5.0.5
5.2 JavaScript Tutorial 1 - Hello world
This web application has been designed to introduce the principles of programming with Kurento for JavaScript
developers. It consists on a WebRTC video communication in mirror (loopback). This tutorial assumes you have basic
knowledge on JavaScript, HTML and WebRTC. We also recommend reading the Introducing Kurento section before
starting this tutorial.
5.2.1 For the impatient: running this example
You need to have installed the Kurento Media Server before running this example read the installation guide for further
information.
Be sure to have installed Node.js and Bower in your system. In an Ubuntu machine, you can install both as follows:
curl -sL https://deb.nodesource.com/setup | sudo bash sudo apt-get install -y nodejs
sudo npm install -g bower
Due to Same-origin policy, this demo has to be served by a HTTP server. A very simple way of doing this is by means
of a HTTP Node.js server which can be installed using npm :
sudo npm install http-server -g
You also need the source code of this demo. You can clone it from GitHub. Then start the HTTP server:
git clone https://github.com/Kurento/kurento-tutorial-js.git
cd kurento-tutorial-js/kurento-hello-world
bower install
http-server
Finally access the application connecting to the URL http://localhost:8080/ through a WebRTC capable browser
(Chrome, Firefox).
5.2.2 Understanding this example
Kurento provides developers a Kurento JavaScript Client to control Kurento Media Server. This client library can
be used in any kind of JavaScript application including desktop and mobile browsers.
This hello world demo is one of the simplest web application you can create with Kurento. The following picture
shows an screenshot of this demo running:
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one showing the local
stream (as captured by the device webcam) and the other showing the remote stream sent by the media server back to
the client.
The logic of the application is quite simple: the local stream is sent to the Kurento Media Server, which returns it back
to the client without modifications. To implement this behavior we need to create a Media Pipeline composed by a
single Media Element, i.e. a WebRtcEndpoint, which holds the capability of exchanging full-duplex (bidirectional)
WebRTC media flows. This media element is connected to itself so that the media it receives (from browser) is send
back (to browser). This media pipeline is illustrated in the following picture:
This is a web application, and therefore it follows a client-server architecture. Nevertheless, due to the fact that we
are using the Kurento JavaScript client, there is not need to use an application server since all the application logic is
held by the browser. The Kurento JavaScript Client is used directly to control Kurento Media Server by means of a
WebSocket bidirectional connection:
34
Chapter 5. Tutorial 1 - Hello world
Kurento Documentation, Release 5.0.5
Figure 5.5: Kurento Hello World Screenshot: WebRTC in loopback
5.2. JavaScript Tutorial 1 - Hello world
35
Kurento Documentation, Release 5.0.5
Figure 5.6: Kurento Hello World Media Pipeline in context
The following sections analyze in deep the client-side (JavaScript) code of this application, the dependencies, and how
to run the demo. The complete source code can be found in GitHub.
5.2.3 JavaScript Logic
The Kurento hello-world demo follows a Single Page Application architecture (SPA). The interface is the following
HTML page: index.html. This web page links two Kurento JavaScript libraries:
• kurento-client.js : Implementation of the Kurento JavaScript Client.
• kurento-utils.js : Kurento utility library aimed to simplify the WebRTC management in the browser.
In addition, these two JavaScript libraries are also required:
• jquery.js : Cross-platform JavaScript library designed to simplify the client-side scripting of HTML.
• adapter.js : WebRTC JavaScript utility library maintained by Google that abstracts away browser differences.
The specific logic of the Hello World JavaScript demo is coded in the following JavaScript file: index.js. In this file,
there is a start function which is called when the green button labeled as Start in the GUI is clicked.
function start() {
[...]
webRtcPeer =
kurentoUtils.WebRtcPeer.startSendRecv(videoInput, videoOutput, onOffer, onError);
}
The function WebRtcPeer.startSendRecv abstracts the WebRTC internal details (i.e. PeerConnection and getUserStream) and makes possible to start a full-duplex WebRTC communication, using the HTML video tag with id videoInput to show the video camera (local stream) and the video tag videoOutput to show the remote stream provided by the
Kurento Media Server. Two callback functions are used for managing application logic:
• onOffer : Callback executed if the local SDP offer is generated succesfully.
36
Chapter 5. Tutorial 1 - Hello world
Kurento Documentation, Release 5.0.5
Figure 5.7: Complete sequence diagram of Kurento Hello World (WebRTC in loopbak) demo
5.2. JavaScript Tutorial 1 - Hello world
37
Kurento Documentation, Release 5.0.5
• onError : Callback executed if something wrong happens when obtaining the SDP offer.
In the onOffer callback we create an instance of the KurentoClient class that will manage communications with the
Kurento Media Server. So, we need to provide the URI of its WebSocket endpoint. In this example, we assume it’s
listening in port 8888 at the same host than the HTTP serving the application.
const ws_uri = 'ws://' + location.hostname + ':8888/kurento';
kurentoClient(ws_uri, function(error, kurentoClient) {
...
};
Once we have an instance of kurentoClient, we need to create a Media Pipeline, as follows:
kurentoClient.create("MediaPipeline", function(error, pipeline) {
...
});
If everything works correctly, we will have an instance of a media pipeline (variable pipeline in this example).
With it, we are able to create Media Elements. In this example we just need a single WebRtcEndpoint.
In WebRTC, an SDP (Session Description protocol) is used for negotiating media exchanges between apps. Such
negotiation happens based on the SDP offer and answer exchange mechanism. In this example we assume the SDP
offer and answer contain all WebRTC ICE candidates. This negotiation is implemented in the second part of the
method * processSdpAnswer*, using the SDP offer obtained from the browser client and returning a SDP answer
generated by WebRtcEndpoint.
pipeline.create("WebRtcEndpoint", function(error, webRtc){
if(error) return onError(error);
webRtc.processOffer(sdpOffer, function(error, sdpAnswer){
if(error) return onError(error);
webRtcPeer.processSdpAnswer(sdpAnswer);
});
...
});
Finally, the WebRtcEndpoint is connected to itself (i.e., in loopback):
webRtc.connect(webRtc, function(error){
if(error) return onError(error);
console.log("Loopback established");
});
5.2.4 Dependencies
All dependencies of this demo can to be obtained using Bower. The list of these dependencies are defined in the
bower.json file, as follows:
"dependencies": {
"kurento-client": "^5.0.0",
"kurento-utils": "^5.0.0"
}
To get these dependencies, just run the following shell command:
38
Chapter 5. Tutorial 1 - Hello world
Kurento Documentation, Release 5.0.5
bower install
Kurento framework uses Semantic Versioning for releases. Notice that range ^5.0.0 downloads the latest version of
Kurento artefacts from Bower in version 5 (i.e. 5.x.x). Major versions are released when incompatible changes are
made.
Note: We are in active development. You can find the latest version of Kurento JavaScript Client at Bower.
5.3 Node.js Tutorial 1 - Hello world
This web application has been designed to introduce the principles of programming with Kurento for Node.js developers. It consists on a WebRTC video communication in mirror (loopback). This tutorial assumes you have basic
knowledge on JavaScript, Node.js, HTML and WebRTC. We also recommend reading the Introducing Kurento section
before starting this tutorial.
5.3.1 For the impatient: running this example
You need to have installed the Kurento Media Server before running this example. Read the installation guide for
further information.
Be sure to have installed Node.js and Bower in your system. In an Ubuntu machine, you can install both as follows:
curl -sL https://deb.nodesource.com/setup | sudo bash sudo apt-get install -y nodejs
sudo npm install -g bower
To launch the application you need to clone the GitHub project where this demo is hosted and then install and run it,
as follows:
git clone https://github.com/Kurento/kurento-tutorial-node.git
cd kurento-tutorial-node/kurento-hello-world
npm install
node app.js
Access the application connecting to the URL http://localhost:8080/ through a WebRTC capable browser (Chrome,
Firefox).
5.3.2 Understanding this example
Kurento provides developers a Kurento JavaScript Client to control Kurento Media Server. This client library can
be used from compatible JavaScript engines including browsers and Node.js.
This hello world demo is one of the simplest web application you can create with Kurento. The following picture
shows an screenshot of this demo running:
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one showing the local
stream (as captured by the device webcam) and the other showing the remote stream sent by the media server back to
the client.
The logic of the application is quite simple: the local stream is sent to the Kurento Media Server, which returns it back
to the client without modifications. To implement this behavior we need to create a Media Pipeline composed by a
single Media Element, i.e. a WebRtcEndpoint, which holds the capability of exchanging full-duplex (bidirectional)
5.3. Node.js Tutorial 1 - Hello world
39
Kurento Documentation, Release 5.0.5
Figure 5.8: Kurento Hello World Screenshot: WebRTC in loopback
40
Chapter 5. Tutorial 1 - Hello world
Kurento Documentation, Release 5.0.5
Figure 5.9: Kurento Hello World Media Pipeline in context
WebRTC media flows. This media element is connected to itself so that the media it receives (from browser) is send
back (to browser). This media pipeline is illustrated in the following picture:
This is a web application, and therefore it follows a client-server architecture. At the client-side, the logic is implemented in JavaScript. At the server-side we use a Node.js application server consuming the Kurento JavaScript
Client API to control Kurento Media Server capabilities. All in all, the high level architecture of this demo is
three-tier. To communicate these entities the following technologies are used:
• REST: Communication between JavaScript client-side and Node.js application server-side.
• WebSocket: Communication between the Kurento JavaScript Client and the Kurento Media Server. This communication is implemented by the Kurento Protocol. For further information, please see this page of the
documentation.
The diagram below shows an complete sequence diagram from the interactions with the application interface to: i)
JavaScript logic; ii) Application server logic (which uses the Kurento JavaScript Client); iii) Kurento Media Server.
Note: The communication between client and server-side does not need to be REST. For simplicity, in this tutorial
REST has been used. In later examples a more complex signaling between client and server has been implement, using
WebSockets. Please see later tutorials for further information.
The following sections analyze in deep the server and client-side code of this application. The complete source code
can be found in GitHub.
5.3.3 Application Server Logic
This demo has been developed using the express framework for Node.js, but express is not a requirement for Kurento.
The main script of this demo is app.js. As you can see, the KurentoClient is instantiated in this class. In this instantiation we see that we need to specify to the client library the location of the Kurento Media Server. In this example, we
assume it’s located at localhost listening in port 8888. If you reproduce this example you’ll need to insert the specific
location of your Kurento Media Server instance there.
5.3. Node.js Tutorial 1 - Hello world
41
Kurento Documentation, Release 5.0.5
Figure 5.10: Complete sequence diagram of Kurento Hello World (WebRTC in loopbak) demo
42
Chapter 5. Tutorial 1 - Hello world
Kurento Documentation, Release 5.0.5
Once the Kurento Client has been instantiated, you are ready for communicating with Kurento Media Server and
controlling its multimedia capabilities. Our first operation is to create a Media Pipeline.
var kurento = require('kurento-client');
//...
const ws_uri = "ws://localhost:8888/kurento";
//...
kurento(ws_uri, function(error, kurentoClient) {
if (error) {
return callback(error);
}
kurentoClient.create('MediaPipeline', function(error, _pipeline) {
if (error) {
return callback(error);
}
pipeline = _pipeline;
return callback(null, pipeline);
});
});
As introduced before, we use REST to communicate the client with the Node.js application server:
app.post('/helloworld', function(req, res) {
var sdpOffer = req.body;
getPipeline(function(error, pipeline) {
pipeline.create('WebRtcEndpoint', function(error, webRtcEndpoint) {
webRtcEndpoint.processOffer(sdpOffer, function(error, sdpAnswer) {
webRtcEndpoint.connect(webRtcEndpoint, function(error) {
res.type('application/sdp');
res.send(sdpAnswer);
});
});
});
});
});
As it can be observed, when a POST requests arrives to path /helloworld, we execute a logic comprising two steps:
• Configure media processing logic: This is the part in which the application configures how Kurento has to
process the media. In other words, the media pipeline is recovered and, using it, the media elements we need are
created and connected. In this case, we only instantiate one WebRtcEndpoint for receiving the WebRTC stream
and sending it back to the client.
• WebRTC SDP negotiation: In WebRTC, an SDP (Session Description protocol) is used for negotiating media
exchanges between apps. Such negotiation happens based on the SDP offer and answer exchange mechanism.
In this example we assume the SDP offer and answer contain all WebRTC ICE candidates. This negotiation
takes place when invoking processOffer, using the SDP offer obtained from the browser client and returning a
SDP answer generated by WebRtcEndpoint.
5.3.4 Client-Side Logic
Let’s move now to the client-side of the application, which follows Single Page Application architecture (SPA). To call
the previously created REST service, we use the JavaScript library jQuery. In addition, we use a Kurento JavaScript
utilities library called kurento-utils.js to simplify the WebRTC management in the browser. This library depends
5.3. Node.js Tutorial 1 - Hello world
43
Kurento Documentation, Release 5.0.5
on adapter.js, which is a JavaScript WebRTC utility maintained by Google that abstracts away browser differences.
Finally jquery.js is also needed in this application.
These libraries are linked in the index.html web page, and are used in the index.js. In the start function we can see
how jQuery is used to send a POST request to the path /helloworld, where the application server REST service is
listening. The function WebRtcPeer.startSendRecv abstracts the WebRTC internal details (i.e. PeerConnection and
getUserStream) and makes possible to start a full-duplex WebRTC communication, using the HTML video tag with id
videoInput to show the video camera (local stream) and the video tag videoOutput to show the remote stream provided
by the Kurento Media Server.
var webRtcPeer;
function start() {
console.log("Starting video call ...");
showSpinner(videoInput, videoOutput);
webRtcPeer =
kurentoUtils.WebRtcPeer.startSendRecv(videoInput, videoOutput, onOffer, onError);
}
function onOffer(sdpOffer) {
console.info('Invoking SDP offer callback function ' + location.host);
$.ajax({
url : location.protocol + '/helloworld',
type : 'POST',
dataType : 'text',
contentType : 'application/sdp',
data : sdpOffer,
success : function(sdpAnswer) {
console.log("Received sdpAnswer from server. Processing ...");
webRtcPeer.processSdpAnswer(sdpAnswer);
},
error : function(jqXHR, textStatus, error) {
onError(error);
}
});
}
function onError(error) {
console.error(error);
}
5.3.5 Dependencies
Dependencies of this demo are managed using npm. Our main dependency is the Kurento Client JavaScript (kurentoclient). The relevant part of the package.json file for managing this dependency is:
"dependencies": {
...
"kurento-client" : "^5.0.0"
}
At the client side, dependencies are managed using Bower. Take a look to the bower.json file and pay attention to the
following section:
"dependencies": {
"kurento-utils" : "^5.0.0"
}
44
Chapter 5. Tutorial 1 - Hello world
Kurento Documentation, Release 5.0.5
Kurento framework uses Semantic Versioning for releases. Notice that range ^5.0.0 downloads the latest version of
Kurento artefacts from Bower in version 5 (i.e. 5.x.x). Major versions are released when incompatible changes are
made.
Note: We are in active development. You can find the latest version of Kurento JavaScript Client at NPM and Bower.
5.3. Node.js Tutorial 1 - Hello world
45
Kurento Documentation, Release 5.0.5
46
Chapter 5. Tutorial 1 - Hello world
CHAPTER 6
Tutorial 2 - WebRTC magic mirror
This web application consists on a WebRTC video communication in mirror adding a funny hat over your face. This
is an example of computer vision and augmented reality using a filter.
6.1 Java Tutorial 2 - WebRTC magic mirror
This web application extends Tutorial 1 adding media processing to the basic WebRTC loopback.
6.1.1 For the impatient: running this example
First of all, you should install Kurento Media Server to run this demo. Please visit the installation guide for further
information.
To launch the application you need to clone the GitHub project where this demo is hosted and then run the main class,
as follows:
git clone https://github.com/Kurento/kurento-tutorial-java.git
cd kurento-tutorial-java/kurento-magic-mirror
mvn compile exec:java
The web application starts on port 8080 in the localhost by default. Therefore, open the URL http://localhost:8080/ in
a WebRTC compliant browser (Chrome, Firefox).
6.1.2 Understanding this example
This application uses computer vision and augmented reality techniques to add a funny hat on top of faces. The
following picture shows a screenshot of the demo running in a web browser:
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one for the video
camera stream (the local client-side stream) and other for the mirror (the remote stream). The video camera stream is
sent to Kurento Media Server, which processes and sends it back to the client as a remote stream. To implement this,
we need to create a Media Pipeline composed by the following Media Element s:
• WebRtcEndpoint: Provides full-duplex (bidirectional) WebRTC capabilities.
• FaceOverlay filter: Computer vision filter that detects faces in the video stream and puts an image on top of
them. In this demo the filter is configured to put a Super Mario hat).
This is a web application, and therefore it follows a client-server architecture. At the client-side, the logic is implemented in JavaScript. At the server-side we use a Java EE application server consuming the Kurento Java Client
47
Kurento Documentation, Release 5.0.5
Figure 6.1: Kurento Magic Mirror Screenshot: WebRTC with filter in loopback
Figure 6.2: WebRTC with filter in loopback Media Pipeline
48
Chapter 6. Tutorial 2 - WebRTC magic mirror
Kurento Documentation, Release 5.0.5
API to control Kurento Media Server capabilities. All in all, the high level architecture of this demo is three-tier. To
communicate these entities, two WebSockets are used. First, a WebSocket is created between client and application
server to implement a custom signaling protocol. Second, another WebSocket is used to perform the communication
between the Kurento Java Client and the Kurento Media Server. This communication takes place using the Kurento
Protocol. For further information on it, please see this page of the documentation.
To communicate the client with the Java EE application server we have designed a simple signaling protocol based on
JSON messages over WebSocket ‘s. The normal sequence between client and server is as follows: i) Client starts the
Magic Mirror. ii) Client stops the Magic Mirror.
If any exception happens, server sends an error message to the client. The detailed message sequence between client
and application server is depicted in the following picture:
Figure 6.3: One to one video call signaling protocol
As you can see in the diagram, an SDP needs to be exchanged between client and server to establish the WebRTC
session between the browser and Kurento. Specifically, the SDP negotiation connects the WebRtcPeer at the browser
with the WebRtcEndpoint at the server. The complete source code of this demo can be found in GitHub.
6.1. Java Tutorial 2 - WebRTC magic mirror
49
Kurento Documentation, Release 5.0.5
6.1.3 Application Server Side
This demo has been developed using a Java EE application server based on the Spring Boot framework. This technology can be used to embed the Tomcat web server in the application and thus simplify the development process.
Note: You can use whatever Java server side technology you prefer to build web applications with Kurento. For
example, a pure Java EE application, SIP Servlets, Play, Vert.x, etc. Here we chose Spring Boot for convenience.
In the following figure you can see a class diagram of the server side code:
Figure 6.4: Server-side class diagram of the MagicMirror app
MagicMirrorApp
MagicMirrorHandler
KurentoClient
The main class of this demo is named MagicMirrorApp. As you can see, the KurentoClient is instantiated in this class
as a Spring Bean. This bean is used to create Kurento Media Pipelines, which are used to add media capabilities to
your applications. In this instantiation we see that we need to specify to the client library the location of the Kurento
Media Server. In this example, we assume it’s located at localhost listening in port 8888. If you reproduce this tutorial
you’ll need to insert the specific location of your Kurento Media Server instance there.
@Configuration
@EnableWebSocket
@EnableAutoConfiguration
public class MagicMirrorApp implements WebSocketConfigurer {
@Bean
public MagicMirrorHandler handler() {
return new MagicMirrorHandler();
}
@Bean
public KurentoClient kurentoClient() {
return KurentoClient.create("ws://localhost:8888/kurento");
}
public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
registry.addHandler(handler(), "/magicmirror");
}
public static void main(String[] args) throws Exception {
new SpringApplication(MagicMirrorApp.class).run(args);
50
Chapter 6. Tutorial 2 - WebRTC magic mirror
Kurento Documentation, Release 5.0.5
}
}
This web application follows Single Page Application architecture (SPA) and uses a WebSocket to communicate client
with application server by means of requests and responses. Specifically, the main app class implements the interface WebSocketConfigurer to register a WebSocketHanlder to process WebSocket requests in the path
/magicmirror.
MagicMirrorHandler class implements TextWebSocketHandler to handle text WebSocket requests. The central
piece of this class is the method handleTextMessage. This method implements the actions for requests, returning
responses through the WebSocket. In other words, it implements the server part of the signaling protocol depicted in
the previous sequence diagram.
In the designed protocol there are three different kinds of incoming messages to the Server : start and stop. These
messages are treated in the switch clause, taking the proper steps in each case.
public class MagicMirrorHandler extends TextWebSocketHandler {
private final Logger log = LoggerFactory
.getLogger(MagicMirrorHandler.class);
private static final Gson gson = new GsonBuilder().create();
private ConcurrentHashMap<String, MediaPipeline> pipelines =
new ConcurrentHashMap<String, MediaPipeline>();
@Autowired
private KurentoClient kurento;
@Override
public void handleTextMessage(WebSocketSession session, TextMessage message)
throws Exception {
JsonObject jsonMessage = gson.fromJson(message.getPayload(),
JsonObject.class);
log.debug("Incoming message: {}", jsonMessage);
switch (jsonMessage.get("id").getAsString()) {
case "start":
start(session, jsonMessage);
break;
case "stop":
String sessionId = session.getId();
if (pipelines.containsKey(sessionId)) {
pipelines.get(sessionId).release();
pipelines.remove(sessionId);
}
break;
default:
sendError(session,
"Invalid message with id "
+ jsonMessage.get("id").getAsString());
break;
}
}
private void start(WebSocketSession session, JsonObject jsonMessage) {
...
6.1. Java Tutorial 2 - WebRTC magic mirror
51
Kurento Documentation, Release 5.0.5
}
private void sendError(WebSocketSession session, String message) {
...
}
}
In the following snippet, we can see the start method. It creates a Media Pipeline, creates the Media Elements
(WebRtcEndpoint and FaceOverlayFilter) and make the connections among them. A startResponse
message is sent back to the client with the SDP answer.
private void start(WebSocketSession session, JsonObject jsonMessage) {
try {
// Media Logic (Media Pipeline and Elements)
MediaPipeline pipeline = kurento.createMediaPipeline();
pipelines.put(session.getId(), pipeline);
WebRtcEndpoint webRtcEndpoint = new WebRtcEndpoint.Builder(pipeline)
.build();
FaceOverlayFilter faceOverlayFilter = new FaceOverlayFilter.Builder(
pipeline).build();
faceOverlayFilter.setOverlayedImage(
"http://files.kurento.org/imgs/mario-wings.png", -0.35F,
-1.2F, 1.6F, 1.6F);
webRtcEndpoint.connect(faceOverlayFilter);
faceOverlayFilter.connect(webRtcEndpoint);
// SDP negotiation (offer and answer)
String sdpOffer = jsonMessage.get("sdpOffer").getAsString();
String sdpAnswer = webRtcEndpoint.processOffer(sdpOffer);
// Sending response back to client
JsonObject response = new JsonObject();
response.addProperty("id", "startResponse");
response.addProperty("sdpAnswer", sdpAnswer);
session.sendMessage(new TextMessage(response.toString()));
} catch (Throwable t) {
sendError(session, t.getMessage());
}
}
The sendError method is quite simple: it sends an error message to the client when an exception is caught in the
server-side.
private void sendError(WebSocketSession session, String message) {
try {
JsonObject response = new JsonObject();
response.addProperty("id", "error");
response.addProperty("message", message);
session.sendMessage(new TextMessage(response.toString()));
} catch (IOException e) {
log.error("Exception sending message", e);
}
}
52
Chapter 6. Tutorial 2 - WebRTC magic mirror
Kurento Documentation, Release 5.0.5
6.1.4 Client-Side
Let’s move now to the client-side of the application. To call the previously created WebSocket service in the serverside, we use the JavaScript class WebSocket. We use an specific Kurento JavaScript library called kurento-utils.js
to simplify the WebRTC interaction with the server. This library depends on adapter.js, which is a JavaScript WebRTC utility maintained by Google that abstracts away browser differences. Finally jquery.js is also needed in this
application.
These libraries are linked in the index.html web page, and are used in the index.js. In the following snippet we can
see the creation of the WebSocket (variable ws) in the path /magicmirror. Then, the onmessage listener of the
WebSocket is used to implement the JSON signaling protocol in the client-side. Notice that there are four incoming
messages to client: startResponse and error. Convenient actions are taken to implement each step in the
communication. For example, in functions start the function WebRtcPeer.startSendRecv of kurento-utils.js
is used to start a WebRTC communication.
var ws = new WebSocket('ws://' + location.host + '/magicmirror');
ws.onmessage = function(message) {
var parsedMessage = JSON.parse(message.data);
console.info('Received message: ' + message.data);
switch (parsedMessage.id) {
case 'startResponse':
startResponse(parsedMessage);
break;
case 'error':
if (state == I_AM_STARTING) {
setState(I_CAN_START);
}
console.error("Error message from server: " + parsedMessage.message);
break;
default:
if (state == I_AM_STARTING) {
setState(I_CAN_START);
}
console.error('Unrecognized message', parsedMessage);
}
}
function start() {
console.log("Starting video call ...")
// Disable start button
setState(I_AM_STARTING);
showSpinner(videoInput, videoOutput);
console.log("Creating WebRtcPeer and generating local sdp offer ...");
webRtcPeer =
kurentoUtils.WebRtcPeer.startSendRecv(videoInput, videoOutput, onOffer, onError);
}
function onOffer(offerSdp) {
console.info('Invoking SDP offer callback function ' + location.host);
var message = {
id : 'start',
sdpOffer : offerSdp
}
sendMessage(message);
}
6.1. Java Tutorial 2 - WebRTC magic mirror
53
Kurento Documentation, Release 5.0.5
function onError(error) {
console.error(error);
}
6.1.5 Dependencies
This Java Spring application is implemented using Maven. The relevant part of the pom.xml is where Kurento dependencies are declared. As the following snippet shows, we need two dependencies: the Kurento Client Java dependency
(kurento-client) and the JavaScript Kurento utility library (kurento-utils) for the client-side:
<dependencies>
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-client</artifactId>
<version>[5.0.0,6.0.0)</version>
</dependency>
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-utils-js</artifactId>
<version>[5.0.0,6.0.0)</version>
</dependency>
</dependencies>
Kurento framework uses Semantic Versioning for releases. Notice that range [5.0.0,6.0.0) downloads the latest
version of Kurento artefacts from Maven Central in version 5 (i.e. 5.x.x). Major versions are released when incompatible changes are made.
Note: We are in active development. You can find the latest version of Kurento Java Client at Maven Central.
Kurento Java Client has a minimum requirement of Java 7. To configure the application to use Java 7, we have to
include the following properties in the properties section:
<maven.compiler.target>1.7</maven.compiler.target>
<maven.compiler.source>1.7</maven.compiler.source>
6.2 JavaScript Tutorial 2 - Magic Mirror
This web application extends Tutorial 1 adding media processing to the basic WebRTC loopback.
6.2.1 For the impatient: running this example
You need to have installed the Kurento Media Server before running this example read the installation guide for further
information.
Be sure to have installed Node.js and Bower in your system. In an Ubuntu machine, you can install both as follows:
curl -sL https://deb.nodesource.com/setup | sudo bash sudo apt-get install -y nodejs
sudo npm install -g bower
Due to Same-origin policy, this demo has to be served by an HTTP server. A very simple way of doing this is by
means of a HTTP Node.js server which can be installed using npm :
54
Chapter 6. Tutorial 2 - WebRTC magic mirror
Kurento Documentation, Release 5.0.5
sudo npm install http-server -g
You also need the source code of this demo. You can clone it from GitHub. Then start the HTTP server:
git clone https://github.com/Kurento/kurento-tutorial-js.git
cd kurento-tutorial-js/kurento-magic-mirror
bower install
http-server
Finally access the application connecting to the URL http://localhost:8080/ through a WebRTC capable browser
(Chrome, Firefox).
6.2.2 Understanding this example
This application uses computer vision and augmented reality techniques to add a funny hat on top of faces. The
following picture shows a screenshot of the demo running in a web browser:
Figure 6.5: Kurento Magic Mirror Screenshot: WebRTC with filter in loopback
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one for the video
camera stream (the local client-side stream) and other for the mirror (the remote stream). The video camera stream is
sent to the Kurento Media Server, processed and then is returned to the client as a remote stream.
6.2. JavaScript Tutorial 2 - Magic Mirror
55
Kurento Documentation, Release 5.0.5
To implement this, we need to create a Media Pipeline composed by the following Media Element s:
• WebRtcEndpoint: Provides full-duplex (bidirectional) WebRTC capabilities.
• FaceOverlay filter: Computer vision filter that detects faces in the video stream and puts an image on top of
them. In this demo the filter is configured to put a Super Mario hat).
The media pipeline implemented is illustrated in the following picture:
Figure 6.6: WebRTC with filter in loopback Media Pipeline
The complete source code of this demo can be found in GitHub.
6.2.3 JavaScript Logic
This demo follows a Single Page Application architecture (SPA). The interface is the following HTML page: index.html. This web page links two Kurento JavaScript libraries:
• kurento-client.js : Implementation of the Kurento JavaScript Client.
• kurento-utils.js : Kurento utility library aimed to simplify the WebRTC management in the browser.
In addition, these two JavaScript libraries are also required:
• jquery.js : Cross-platform JavaScript library designed to simplify the client-side scripting of HTML.
• adapter.js : WebRTC JavaScript utility library maintained by Google that abstracts away browser differences.
The specific logic of this demo is coded in the following JavaScript page: index.js. In this file, there is an start
function which is called when the green button labeled as Start in the GUI is clicked.
function start() {
showSpinner(videoInput, videoOutput);
webRtcPeer =
kurentoUtils.WebRtcPeer.startSendRecv(videoInput, videoOutput, onOffer, onError);
}
As you can see, the function WebRtcPeer.startSendRecv of kurento-utils is used to start a WebRTC communication,
using the HTML video tag with id videoInput to show the video camera (local stream) and the video tag videoOutput
to show the video processed by Kurento Media Server (remote stream). Then, two callback functions are used:
• onOffer : Callback executed if the SDP negotiation is carried out correctly.
• onError : Callback executed if something wrong happens.
In onOffer we can found the most interesting code from a Kurento JavaScript Client point of view. First, we have
create an instance of the KurentoClient class that will manage the connection with the Kurento Media Server. So, we
need to provide the URI of its WebSocket endpoint:
56
Chapter 6. Tutorial 2 - WebRTC magic mirror
Kurento Documentation, Release 5.0.5
const ws_uri = 'ws://' + location.hostname + ':8888/kurento';
kurentoClient(ws_uri, function(error, client) {
...
};
Once we have an instance of kurentoClient, the following step is to create a Media Pipeline, as follows:
client.create("MediaPipeline", function(error, pipeline) {
...
});
If everything works correctly, we have an instance of a media pipeline (variable pipeline in this example). With
this instance, we are able to create Media Elements. In this example we just need a WebRtcEndpoint and a FaceOverlayFilter. Then, these media elements are interconnected:
pipeline.create('WebRtcEndpoint', function(error, webRtc) {
if (error) return onError(error);
pipeline.create('FaceOverlayFilter', function(error, filter) {
if (error) return onError(error);
console.log("Got FaceOverlayFilter");
var
var
var
var
offsetXPercent = -0.4;
offsetYPercent = -1;
widthPercent = 1.5;
heightPercent = 1.5;
console.log("Setting overlay image");
filter.setOverlayedImage(hat_uri, offsetXPercent,
offsetYPercent, widthPercent,
heightPercent, function(error) {
if (error) return onError(error);
console.log("Set overlay image");
});
console.log("Connecting ...");
webRtc.connect(filter, function(error) {
if (error) return onError(error);
console.log("WebRtcEndpoint --> filter");
filter.connect(webRtc, function(error) {
if (error) return onError(error);
console.log("Filter --> WebRtcEndpoint");
});
});
...
});
});
6.2. JavaScript Tutorial 2 - Magic Mirror
57
Kurento Documentation, Release 5.0.5
In WebRTC, SDP (Session Description protocol) is used for negotiating media interchange between apps. Such
negotiation happens based on the SDP offer and answer exchange mechanism. This negotiation is implemented
in the second part of the method processSdpAnswer, using the SDP offer obtained from the browser client (using
kurentoUtils.WebRtcPeer), and returning a SDP answer returned by WebRtcEndpoint.
webRtc.processOffer(sdpOffer, function(error, sdpAnswer) {
if (error) return onError(error);
console.log("SDP answer obtained. Processing ...");
webRtcPeer.processSdpAnswer(sdpAnswer);
});
6.2.4 Dependencies
The dependencies of this demo has to be obtained using Bower. The definition of these dependencies are defined in
the bower.json file, as follows:
"dependencies": {
"kurento-client": "^5.0.0",
"kurento-utils": "^5.0.0"
}
Kurento framework uses Semantic Versioning for releases. Notice that range ^5.0.0 downloads the latest version of
Kurento artefacts from Bower in version 5 (i.e. 5.x.x). Major versions are released when incompatible changes are
made.
Note: We are in active development. You can find the latest version of Kurento JavaScript Client at Bower.
6.3 Node.js Tutorial 2 - WebRTC magic mirror
This web application extends Tutorial 1 adding media processing to the basic WebRTC loopback.
6.3.1 For the impatient: running this example
First of all, you should install Kurento Media Server to run this demo. Please visit the installation guide for further
information.
Be sure to have installed Node.js and Bower in your system. In an Ubuntu machine, you can install both as follows:
curl -sL https://deb.nodesource.com/setup | sudo bash sudo apt-get install -y nodejs
sudo npm install -g bower
To launch the application you need to clone the GitHub project where this demo is hosted and then install and run it,
as follows:
git clone https://github.com/Kurento/kurento-tutorial-node.git
cd kurento-tutorial-node/kurento-magic-mirror
npm install
node app.js
Access the application connecting to the URL http://localhost:8080/ through a WebRTC capable browser (Chrome,
Firefox).
58
Chapter 6. Tutorial 2 - WebRTC magic mirror
Kurento Documentation, Release 5.0.5
6.3.2 Understanding this example
This application uses computer vision and augmented reality techniques to add a funny hat on top of faces. The
following picture shows a screenshot of the demo running in a web browser:
Figure 6.7: Kurento Magic Mirror Screenshot: WebRTC with filter in loopback
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one for the video
camera stream (the local client-side stream) and other for the mirror (the remote stream). The video camera stream is
sent to Kurento Media Server, which processes and sends it back to the client as a remote stream. To implement this,
we need to create a Media Pipeline composed by the following Media Element s:
• WebRtcEndpoint: Provides full-duplex (bidirectional) WebRTC capabilities.
• FaceOverlay filter: Computer vision filter that detects faces in the video stream and puts an image on top of
them. In this demo the filter is configured to put a Super Mario hat).
This is a web application, and therefore it follows a client-server architecture. At the client-side, the logic is implemented in JavaScript. At the server-side we use a Node.js application server consuming the Kurento JavaScript
Client API to control Kurento Media Server capabilities. All in all, the high level architecture of this demo is
three-tier. To communicate these entities, two WebSockets are used. First, a WebSocket is created between client and
application server to implement a custom signaling protocol. Second, another WebSocket is used to perform the communication between the Kurento JavaScript Client and the Kurento Media Server. This communication takes place
using the Kurento Protocol. For further information on it, please see this page of the documentation.
6.3. Node.js Tutorial 2 - WebRTC magic mirror
59
Kurento Documentation, Release 5.0.5
Figure 6.8: WebRTC with filter in loopback Media Pipeline
To communicate the client with the Node.js application server we have designed a simple signaling protocol based on
JSON messages over WebSocket ‘s. The normal sequence between client and server is as follows: i) Client starts the
Magic Mirror. ii) Client stops the Magic Mirror.
If any exception happens, server sends an error message to the client. The detailed message sequence between client
and application server is depicted in the following picture:
As you can see in the diagram, an SDP needs to be exchanged between client and server to establish the WebRTC
session between the browser and Kurento. Specifically, the SDP negotiation connects the WebRtcPeer at the browser
with the WebRtcEndpoint at the server. The complete source code of this demo can be found in GitHub.
6.3.3 Application Server Side
This demo has been developed using the express framework for Node.js, but express is not a requirement for Kurento.
The main script of this demo is app.js.
Once the Kurento Client has been instantiated, you are ready for communicating with Kurento Media Server and
controlling its multimedia capabilities.
var kurento = require('kurento-client');
//...
const ws_uri = "ws://localhost:8888/kurento";
//...
kurento(ws_uri, function(error, _kurentoClient) {
if (error) {
console.log("Could not find media server at address " + ws_uri);
return callback("Could not find media server at address" + ws_uri
+ ". Exiting with error " + error);
}
kurentoClient = _kurentoClient;
callback(null, kurentoClient);
});
This web application follows Single Page Application architecture (SPA) and uses a WebSocket in the path
/magicmirror to communicate client with application server by means of requests and responses.
The following code snippet implements the server part of the signaling protocol depicted in the previous sequence
diagram.
60
Chapter 6. Tutorial 2 - WebRTC magic mirror
Kurento Documentation, Release 5.0.5
Figure 6.9: Magic mirror signaling protocol
6.3. Node.js Tutorial 2 - WebRTC magic mirror
61
Kurento Documentation, Release 5.0.5
ws.on('message', function(_message) {
var message = JSON.parse(_message); switch (message.id) {
case 'start':
start(sessionId, message.sdpOffer, function(error, sdpAnswer) {
if (error) {
return ws.send(JSON.stringify({
id : 'error', message : error
}));
}
ws.send(JSON.stringify({
id : 'startResponse', sdpAnswer : sdpAnswer
}));
});
break;
case 'stop':
stop(sessionId); break;
//...
});
In the designed protocol there are three different kinds of incoming messages to the Server : start and stop. These
messages are treated in the switch clause, taking the proper steps in each case.
In the following snippet, we can see the start method. It creates a Media Pipeline, then creates the Media Elements
(WebRtcEndpoint and FaceOverlayFilter) and make the connections among them. A startResponse
message is sent back to the client with the SDP answer.
function start(sessionId, sdpOffer, callback) {
getKurentoClient(function(error, kurentoClient) {
kurentoClient.create('MediaPipeline', function(error, pipeline) {
createMediaElements(pipeline, function(error, webRtcEndpoint, faceOverlayFilter) {
connectMediaElements(webRtcEndpoint, faceOverlayFilter, function(error) {
webRtcEndpoint.processOffer(sdpOffer, function(error, sdpAnswer) {
pipelines[sessionId] = pipeline; return callback(null, sdpAnswer);
});
});
});
});
});
}
function createMediaElements(pipeline, callback) {
pipeline.create('WebRtcEndpoint', function(error, webRtcEndpoint) {
pipeline.create('FaceOverlayFilter', function(error, faceOverlayFilter) {
faceOverlayFilter.setOverlayedImage(
"http://files.kurento.org/imgs/mario-wings.png",
-0.35, -1.2, 1.6, 1.6, function(error) {
return callback(null, webRtcEndpoint, faceOverlayFilter);
});
});
});
}
function connectMediaElements(webRtcEndpoint, faceOverlayFilter, callback) {
webRtcEndpoint.connect(faceOverlayFilter, function(error) {
faceOverlayFilter.connect(webRtcEndpoint, function(error) {
return callback(null);
62
Chapter 6. Tutorial 2 - WebRTC magic mirror
Kurento Documentation, Release 5.0.5
});
});
}
6.3.4 Client-Side
Let’s move now to the client-side of the application. To call the previously created WebSocket service in the serverside, we use the JavaScript class WebSocket. We use an specific Kurento JavaScript library called kurento-utils.js
to simplify the WebRTC interaction with the server. This library depends on adapter.js, which is a JavaScript WebRTC utility maintained by Google that abstracts away browser differences. Finally jquery.js is also needed in this
application.
These libraries are linked in the index.html web page, and are used in the index.js. In the following snippet we can
see the creation of the WebSocket (variable ws) in the path /magicmirror. Then, the onmessage listener of the
WebSocket is used to implement the JSON signaling protocol in the client-side. Notice that there are four incoming
messages to client: startResponse and error. Convenient actions are taken to implement each step in the
communication. For example, in functions start the function WebRtcPeer.startSendRecv of kurento-utils.js
is used to start a WebRTC communication.
var ws = new WebSocket('ws://' + location.host + '/magicmirror');
ws.onmessage = function(message) {
var parsedMessage = JSON.parse(message.data);
console.info('Received message: ' + message.data);
switch (parsedMessage.id) {
case 'startResponse':
startResponse(parsedMessage);
break;
case 'error':
if (state == I_AM_STARTING) {
setState(I_CAN_START);
}
console.error("Error message from server: " + parsedMessage.message);
break;
default:
if (state == I_AM_STARTING) {
setState(I_CAN_START);
}
console.error('Unrecognized message', parsedMessage);
}
}
function start() {
console.log("Starting video call ...")
// Disable start button
setState(I_AM_STARTING);
showSpinner(videoInput, videoOutput);
console.log("Creating WebRtcPeer and generating local sdp offer ...");
webRtcPeer =
kurentoUtils.WebRtcPeer.startSendRecv(videoInput, videoOutput, onOffer, onError);
}
function onOffer(offerSdp) {
console.info('Invoking SDP offer callback function ' + location.host);
6.3. Node.js Tutorial 2 - WebRTC magic mirror
63
Kurento Documentation, Release 5.0.5
var message = {
id : 'start',
sdpOffer : offerSdp
}
sendMessage(message);
}
function onError(error) {
console.error(error);
}
6.3.5 Dependencies
Dependencies of this demo are managed using npm. Our main dependency is the Kurento Client JavaScript (kurentoclient). The relevant part of the package.json file for managing this dependency is:
"dependencies": {
...
"kurento-client" : "^5.0.0"
}
At the client side, dependencies are managed using Bower. Take a look to the bower.json file and pay attention to the
following section:
"dependencies": {
"kurento-utils" : "^5.0.0"
}
Kurento framework uses Semantic Versioning for releases. Notice that range ^5.0.0 downloads the latest version of
Kurento artefacts from Bower in version 5 (i.e. 5.x.x). Major versions are released when incompatible changes are
made.
Note: We are in active development. You can find the latest version of Kurento JavaScript Client at NPM and Bower.
64
Chapter 6. Tutorial 2 - WebRTC magic mirror
CHAPTER 7
Tutorial 3 - WebRTC one-to-many broadcast
Video broadcasting for WebRTC. One peer transmits a video stream and N peers receives it.
7.1 Tutorial 3 - One to many video call
This web application consists on an one to one video call using WebRTC technology. In other words, it is an implementation of a video broadcasting web application.
7.1.1 For the impatient: running this example
First of all, you should install Kurento Media Server to run this demo. Please visit the installation guide for further
information.
To launch the application you need to clone the GitHub project where this demo is hosted and then run the main class,
as follows:
git clone https://github.com/Kurento/kurento-tutorial-java.git
cd kurento-tutorial-java/kurento-one2many-call
mvn compile exec:java
The web application starts on port 8080 in the localhost by default. Therefore, open the URL http://localhost:8080/ in
a WebRTC compliant browser (Chrome, Firefox).
7.1.2 Understanding this example
There will be two types of users in this application: 1 peer sending media (let’s call it Master) and N peers receiving
the media from the Master (let’s call them Viewers). Thus, the Media Pipeline is composed by 1+N interconnected
WebRtcEndpoints. The following picture shows an screenshot of the Master’s web GUI:
To implement this behavior we have to create a Media Pipeline composed by 1+N WebRtcEndpoints. The Master
peer sends its stream to the rest of the Viewers. Viewers are configured in receive-only mode. The implemented media
pipeline is illustrated in the following picture:
This is a web application, and therefore it follows a client-server architecture. At the client-side, the logic is implemented in JavaScript. At the server-side we use the Kurento Java Client in order to reach the Kurento Media
Server. All in all, the high level architecture of this demo is three-tier. To communicate these entities two WebSockets are used. First, a WebSocket is created between client and server-side to implement a custom signaling protocol.
Second, another WebSocket is used to perform the communication between the Kurento Java Client and the Kurento
65
Kurento Documentation, Release 5.0.5
Figure 7.1: One to many video call screenshot
Figure 7.2: One to many video call Media Pipeline
66
Chapter 7. Tutorial 3 - WebRTC one-to-many broadcast
Kurento Documentation, Release 5.0.5
Media Server. This communication is implemented by the Kurento Protocol. For further information, please see this
page.
Client and application server communicate using a signaling protocol based on JSON messages over WebSocket ‘s.
The normal sequence between client and server is as follows:
1. A Master enters in the system. There must be one and only one Master at any time. For that, if a Master has already
present, an error message is sent if another user tries to become Master.
2. N Viewers connect to the master. If no Master is present, then an error is sent to the corresponding Viewer.
3. Viewers can leave the communication at any time.
4. When the Master finishes the session each connected Viewer receives an stopCommunication message and also
terminates its session.
We can draw the following sequence diagram with detailed messages between clients and server:
Figure 7.3: One to many video call signaling protocol
7.1. Tutorial 3 - One to many video call
67
Kurento Documentation, Release 5.0.5
As you can see in the diagram, SDP needs to be exchanged between client and server to establish the WebRTC
connection between the browser and Kurento. Specifically, the SDP negotiation connects the WebRtcPeer in the
browser with the WebRtcEndpoint in the server. The complete source code of this demo can be found in GitHub.
7.1.3 Application Server Logic
This demo has been developed using Java in the server-side with Spring Boot framework. This technology can be
used to embed the Tomcat web server in the application and thus simplify the development process.
Note: You can use whatever Java server side technology you prefer to build web applications with Kurento. For
example, a pure Java EE application, SIP Servlets, Play, Vertex, etc. We chose Spring Boot for convenience.
In the following figure you can see a class diagram of the server side code:
Figure 7.4: Server-side class diagram of the MagicMirror app
One2ManyCallApp
CallHandler
KurentoClient
The main class of this demo is named One2ManyCallApp. As you can see, the KurentoClient is instantiated in this
class as a Spring Bean. This bean is used to create Kurento Media Pipelines, which are used to add media capabilities
to your applications. In this instantiation we see that a WebSocket is used to connect with Kurento Media Server, by
default in the localhost and listening in the port 8888.
@Configuration
@EnableWebSocket
@EnableAutoConfiguration
public class One2ManyCallApp implements WebSocketConfigurer {
@Bean
public CallHandler callHandler() {
return new CallHandler();
}
@Bean
public KurentoClient kurentoClient() {
return KurentoClient.create("ws://localhost:8888/kurento");
}
public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
registry.addHandler(callHandler(), "/call");
68
Chapter 7. Tutorial 3 - WebRTC one-to-many broadcast
Kurento Documentation, Release 5.0.5
}
public static void main(String[] args) throws Exception {
new SpringApplication(One2ManyCallApp.class).run(args);
}
}
This web application follows Single Page Application architecture (SPA) and uses a WebSocket to communicate
client with server by means of requests and responses. Specifically, the main app class implements the interface
WebSocketConfigurer to register a WebSocketHanlder to process WebSocket requests in the path /call.
CallHandler class implements TextWebSocketHandler to handle text WebSocket requests. The central piece
of this class is the method handleTextMessage. This method implements the actions for requests, returning
responses through the WebSocket. In other words, it implements the server part of the signaling protocol depicted in
the previous sequence diagram.
In the designed protocol there are three different kind of incoming messages to the Server : master, viewer, and
stop. These messages are treated in the switch clause, taking the proper steps in each case.
public class CallHandler extends TextWebSocketHandler {
private static final Logger log = LoggerFactory
.getLogger(CallHandler.class);
private static final Gson gson = new GsonBuilder().create();
private ConcurrentHashMap<String, UserSession> viewers =
new ConcurrentHashMap<String, UserSession>();
@Autowired
private KurentoClient kurento;
private MediaPipeline pipeline;
private UserSession masterUserSession;
@Override
public void handleTextMessage(WebSocketSession session, TextMessage message)
throws Exception {
JsonObject jsonMessage = gson.fromJson(message.getPayload(),
JsonObject.class);
log.debug("Incoming message from session '{}': {}", session.getId(),
jsonMessage);
switch (jsonMessage.get("id").getAsString()) {
case "master":
try {
master(session, jsonMessage);
} catch (Throwable t) {
stop(session);
log.error(t.getMessage(), t);
JsonObject response = new JsonObject();
response.addProperty("id", "masterResponse");
response.addProperty("response", "rejected");
response.addProperty("message", t.getMessage());
session.sendMessage(new TextMessage(response.toString()));
}
break;
case "viewer":
try {
7.1. Tutorial 3 - One to many video call
69
Kurento Documentation, Release 5.0.5
viewer(session, jsonMessage);
} catch (Throwable t) {
stop(session);
log.error(t.getMessage(), t);
JsonObject response = new JsonObject();
response.addProperty("id", "viewerResponse");
response.addProperty("response", "rejected");
response.addProperty("message", t.getMessage());
session.sendMessage(new TextMessage(response.toString()));
}
break;
case "stop":
stop(session);
break;
default:
break;
}
}
private synchronized void master(WebSocketSession session,
JsonObject jsonMessage) throws IOException {
...
}
private synchronized void viewer(WebSocketSession session,
JsonObject jsonMessage) throws IOException {
...
}
private synchronized void stop(WebSocketSession session) throws IOException {
...
}
@Override
public void afterConnectionClosed(WebSocketSession session,
CloseStatus status) throws Exception {
stop(session);
}
}
In the following snippet, we can see the master method. It creates a Media Pipeline and the WebRtcEndpoint
for master:
private synchronized void master(WebSocketSession session,
JsonObject jsonMessage) throws IOException {
if (masterUserSession == null) {
masterUserSession = new UserSession(session);
pipeline = kurento.createMediaPipeline();
masterUserSession.setWebRtcEndpoint(new WebRtcEndpoint.Builder(
pipeline).build());
WebRtcEndpoint masterWebRtc = masterUserSession.getWebRtcEndpoint();
String sdpOffer = jsonMessage.getAsJsonPrimitive("sdpOffer")
.getAsString();
String sdpAnswer = masterWebRtc.processOffer(sdpOffer);
70
Chapter 7. Tutorial 3 - WebRTC one-to-many broadcast
Kurento Documentation, Release 5.0.5
JsonObject response = new JsonObject();
response.addProperty("id", "masterResponse");
response.addProperty("response", "accepted");
response.addProperty("sdpAnswer", sdpAnswer);
masterUserSession.sendMessage(response);
} else {
JsonObject response = new JsonObject();
response.addProperty("id", "masterResponse");
response.addProperty("response", "rejected");
response.addProperty("message",
"Another user is currently acting as sender. Try again later ...");
session.sendMessage(new TextMessage(response.toString()));
}
}
The viewer method is similar, but not he Master WebRtcEndpoint is connected to each of the viewers WebRtcEndpoints, otherwise an error is sent back to the client.
private synchronized void viewer(WebSocketSession session,
JsonObject jsonMessage) throws IOException {
if (masterUserSession == null
|| masterUserSession.getWebRtcEndpoint() == null) {
JsonObject response = new JsonObject();
response.addProperty("id", "viewerResponse");
response.addProperty("response", "rejected");
response.addProperty("message",
"No active sender now. Become sender or . Try again later ...");
session.sendMessage(new TextMessage(response.toString()));
} else {
if(viewers.containsKey(session.getId())){
JsonObject response = new JsonObject();
response.addProperty("id", "viewerResponse");
response.addProperty("response", "rejected");
response.addProperty("message",
"You are already viewing in this session. " +
"Use a different browser to add additional viewers.");
session.sendMessage(new TextMessage(response.toString()));
return;
}
UserSession viewer = new UserSession(session);
viewers.put(session.getId(), viewer);
String sdpOffer = jsonMessage.getAsJsonPrimitive("sdpOffer")
.getAsString();
WebRtcEndpoint nextWebRtc = new WebRtcEndpoint.Builder(pipeline)
.build();
viewer.setWebRtcEndpoint(nextWebRtc);
masterUserSession.getWebRtcEndpoint().connect(nextWebRtc);
String sdpAnswer = nextWebRtc.processOffer(sdpOffer);
JsonObject response = new JsonObject();
response.addProperty("id", "viewerResponse");
response.addProperty("response", "accepted");
response.addProperty("sdpAnswer", sdpAnswer);
viewer.sendMessage(response);
}
7.1. Tutorial 3 - One to many video call
71
Kurento Documentation, Release 5.0.5
}
Finally, the stop message finishes the communication.
If this message is sent by the Master, a
stopCommunication message is sent to each connected Viewer:
private synchronized void stop(WebSocketSession session) throws IOException {
String sessionId = session.getId();
if (masterUserSession != null
&& masterUserSession.getSession().getId().equals(sessionId)) {
for (UserSession viewer : viewers.values()) {
JsonObject response = new JsonObject();
response.addProperty("id", "stopCommunication");
viewer.sendMessage(response);
}
log.info("Releasing media pipeline");
if (pipeline != null) {
pipeline.release();
}
pipeline = null;
masterUserSession = null;
} else if (viewers.containsKey(sessionId)) {
if (viewers.get(sessionId).getWebRtcEndpoint() != null) {
viewers.get(sessionId).getWebRtcEndpoint().release();
}
viewers.remove(sessionId);
}
}
7.1.4 Client-Side
Let’s move now to the client-side of the application. To call the previously created WebSocket service in the serverside, we use the JavaScript class WebSocket. We use an specific Kurento JavaScript library called kurento-utils.js
to simplify the WebRTC interaction with the server. This library depends on adapter.js, which is a JavaScript WebRTC utility maintained by Google that abstracts away browser differences. Finally jquery.js is also needed in this
application.
These libraries are linked in the index.html web page, and are used in the index.js. In the following snippet
we can see the creation of the WebSocket (variable ws) in the path /call. Then, the onmessage listener of
the WebSocket is used to implement the JSON signaling protocol in the client-side. Notice that there are four
incoming messages to client: masterResponse, viewerResponse, and stopCommunication. Convenient actions are taken to implement each step in the communication. For example, in the function master the
function WebRtcPeer.startSendRecv of kurento-utils.js is used to start a WebRTC communication. Then,
WebRtcPeer.startRecvOnly is used in the viewer function.
var ws = new WebSocket('ws://' + location.host + '/call');
ws.onmessage = function(message) {
var parsedMessage = JSON.parse(message.data);
console.info('Received message: ' + message.data);
switch (parsedMessage.id) {
case 'masterResponse':
masterResponse(parsedMessage);
break;
case 'viewerResponse':
viewerResponse(parsedMessage);
72
Chapter 7. Tutorial 3 - WebRTC one-to-many broadcast
Kurento Documentation, Release 5.0.5
break;
case 'stopCommunication':
dispose();
break;
default:
console.error('Unrecognized message', parsedMessage);
}
}
function master() {
if (!webRtcPeer) {
showSpinner(videoInput, videoOutput);
webRtcPeer = kurentoUtils.WebRtcPeer.startSendRecv(videoInput, videoOutput,
function(offerSdp) {
var message = {
id : 'master',
sdpOffer : offerSdp
};
sendMessage(message);
});
}
}
function viewer() {
if (!webRtcPeer) {
document.getElementById('videoSmall').style.display = 'none';
showSpinner(videoOutput);
webRtcPeer = kurentoUtils.WebRtcPeer.startRecvOnly(videoOutput, function(offerSdp) {
var message = {
id : 'viewer',
sdpOffer : offerSdp
};
sendMessage(message);
});
}
}
7.1.5 Dependencies
This Java Spring application is implemented using Maven. The relevant part of the pom.xml is where Kurento dependencies are declared. As the following snippet shows, we need two dependencies: the Kurento Client Java dependency
(kurento-client) and the JavaScript Kurento utility library (kurento-utils) for the client-side:
<dependencies>
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-client</artifactId>
<version>[5.0.0,6.0.0)</version>
</dependency>
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-utils-js</artifactId>
<version>[5.0.0,6.0.0)</version>
</dependency>
</dependencies>
7.1. Tutorial 3 - One to many video call
73
Kurento Documentation, Release 5.0.5
Kurento framework uses Semantic Versioning for releases. Notice that range [5.0.0,6.0.0) downloads the latest
version of Kurento artefacts from Maven Central in version 5 (i.e. 5.x.x). Major versions are released when incompatible changes are made.
Note: We are in active development. You can find the latest version of Kurento Java Client at Maven Central.
Kurento Java Client has a minimum requirement of Java 7. To configure the application to use Java 7, we have to
include the following properties in the properties section:
<maven.compiler.target>1.7</maven.compiler.target>
<maven.compiler.source>1.7</maven.compiler.source>
7.2 Tutorial 3 - One to many video call
This web application consists on an one to one video call using WebRTC technology. In other words, it is an implementation of a video broadcasting web application.
7.2.1 For the impatient: running this example
First of all, you should install Kurento Media Server to run this demo. Please visit the installation guide for further
information.
Be sure to have installed Node.js and Bower in your system. In an Ubuntu machine, you can install both as follows:
curl -sL https://deb.nodesource.com/setup | sudo bash sudo apt-get install -y nodejs
sudo npm install -g bower
To launch the application you need to clone the GitHub project where this demo is hosted and then install and run it,
as follows:
git clone https://github.com/Kurento/kurento-tutorial-node.git
cd kurento-tutorial-node/kurento-one2many-call
npm install
node app.js
Access the application connecting to the URL http://localhost:8080/ through a WebRTC capable browser (Chrome,
Firefox).
7.2.2 Understanding this example
There will be two types of users in this application: 1 peer sending media (let’s call it Master) and N peers receiving
the media from the Master (let’s call them Viewers). Thus, the Media Pipeline is composed by 1+N interconnected
WebRtcEndpoints. The following picture shows an screenshot of the Master’s web GUI:
To implement this behavior we have to create a Media Pipeline composed by 1+N WebRtcEndpoints. The Master
peer sends its stream to the rest of the Viewers. Viewers are configured in receive-only mode. The implemented media
pipeline is illustrated in the following picture:
This is a web application, and therefore it follows a client-server architecture. At the client-side, the logic is implemented in JavaScript. At the server-side we use the Kurento JavaScript Client in order to reach the Kurento Media
Server. All in all, the high level architecture of this demo is three-tier. To communicate these entities two WebSockets
74
Chapter 7. Tutorial 3 - WebRTC one-to-many broadcast
Kurento Documentation, Release 5.0.5
Figure 7.5: One to many video call screenshot
Figure 7.6: One to many video call Media Pipeline
7.2. Tutorial 3 - One to many video call
75
Kurento Documentation, Release 5.0.5
are used. The first is created between the client browser and a Node.js application server to transport signaling messages. The second is used to communicate the Kurento JavaScript Client executing at Node.js and the Kurento Media
Server. This communication is implemented by the Kurento Protocol. For further information, please see this page.
Client and application server communicate using a signaling protocol based on JSON messages over WebSocket ‘s.
The normal sequence between client and server is as follows:
1. A Master enters in the system. There must be one and only one Master at any time. For that, if a Master has already
present, an error message is sent if another user tries to become Master.
2. N Viewers connect to the master. If no Master is present, then an error is sent to the corresponding Viewer.
3. Viewers can leave the communication at any time.
4. When the Master finishes the session each connected Viewer receives an stopCommunication message and also
terminates its session.
We can draw the following sequence diagram with detailed messages between clients and server:
Figure 7.7: One to many video call signaling protocol
76
Chapter 7. Tutorial 3 - WebRTC one-to-many broadcast
Kurento Documentation, Release 5.0.5
As you can see in the diagram, SDP needs to be exchanged between client and server to establish the WebRTC
connection between the browser and Kurento. Specifically, the SDP negotiation connects the WebRtcPeer in the
browser with the WebRtcEndpoint in the server. The complete source code of this demo can be found in GitHub.
7.2.3 Application Server Logic
This demo has been developed using the express framework for Node.js, but express is not a requirement for Kurento.
The main script of this demo is app.js.
Once the Kurento Client has been instantiated, you are ready for communicating with Kurento Media Server and
controlling its multimedia capabilities.
var kurento = require('kurento-client');
//...
const ws_uri = "ws://localhost:8888/kurento";
//...
kurento(ws_uri, function(error, _kurentoClient) {
if (error) {
console.log("Could not find media server at address " + ws_uri);
return callback("Could not find media server at address" + ws_uri
+ ". Exiting with error " + error);
}
kurentoClient = _kurentoClient;
callback(null, kurentoClient);
});
This web application follows Single Page Application architecture (SPA) and uses a WebSocket in the path /call to
communicate client with applications server by beans of requests and responses.
The following code snippet implements the server part of the signaling protocol depicted in the previous sequence
diagram.
ws.on('message', function(_message) {
var message = JSON.parse(_message);
console.log('Connection ' + sessionId + ' received message ', message);
switch (message.id) {
case 'master':
startMaster(sessionId, message.sdpOffer, function(error, sdpAnswer) {
//...
ws.send(JSON.stringify({
id : 'masterResponse',
response : 'accepted',
sdpAnswer : sdpAnswer
}));
});
break;
case 'viewer':
startViewer(sessionId, message.sdpOffer, ws, function(error, sdpAnswer) {
//...
ws.send(JSON.stringify({
7.2. Tutorial 3 - One to many video call
77
Kurento Documentation, Release 5.0.5
id : 'viewerResponse',
response : 'accepted',
sdpAnswer : sdpAnswer
}));
});
break;
case 'stop':
stop(sessionId);
break;
//...
}
});
In the following snippet, we can see the master method. It creates a Media Pipeline and the WebRtcEndpoint
for master:
startMaster(sessionId, sdpOffer, callback){
//...
getKurentoClient(function(error, kurentoClient) {
//...
kurentoClient.create('MediaPipeline', function(error, pipeline) {
//...
pipeline.create('WebRtcEndpoint', function(error, webRtcEndpoint) {
master.webRtcEndpoint = webRtcEndpoint;
webRtcEndpoint.processOffer(sdp, function(error, sdpAnswer) {
callback(null, sdpAnswer);
});
});
});
});
}
The viewer method is similar, but not he Master WebRtcEndpoint is connected to each of the viewers WebRtcEndpoints, otherwise an error is sent back to the client.
function startViewer(id, sdp, ws, callback) {
if (master === null || master.webRtcEndpoint === null) {
return callback("No active sender now. Become sender or . Try again later ...");
}
//...
pipeline.create('WebRtcEndpoint', function(error, webRtcEndpoint) {
webRtcEndpoint.processOffer(sdp, function(error, sdpAnswer) {
master.webRtcEndpoint.connect(webRtcEndpoint, function(error) {
var viewer = {
id : id,
ws : ws,
webRtcEndpoint : webRtcEndpoint
};
viewers[viewer.id] = viewer;
return callback(null, sdpAnswer);
});
});
78
Chapter 7. Tutorial 3 - WebRTC one-to-many broadcast
Kurento Documentation, Release 5.0.5
});
}
Finally, the stop message finishes the communication.
If this message is sent by the Master, a
stopCommunication message is sent to each connected Viewer:
function stop(id, ws) {
if (master !== null && master.id == id) {
for ( var ix in viewers) {
var viewer = viewers[ix];
if (viewer.ws) {
viewer.ws.send(JSON.stringify({
id : 'stopCommunication'
}));
}
}
viewers = {};
pipeline.release();
pipeline = null;
master = null;
} else if (viewers[id]) {
var viewer = viewers[id];
if (viewer.webRtcEndpoint)
viewer.webRtcEndpoint.release();
delete viewers[id];
}
}
7.2.4 Client-Side
Let’s move now to the client-side of the application. To call the previously created WebSocket service in the serverside, we use the JavaScript class WebSocket. We use an specific Kurento JavaScript library called kurento-utils.js
to simplify the WebRTC interaction with the server. This library depends on adapter.js, which is a JavaScript WebRTC utility maintained by Google that abstracts away browser differences. Finally jquery.js is also needed in this
application.
These libraries are linked in the index.html web page, and are used in the index.js. In the following snippet
we can see the creation of the WebSocket (variable ws) in the path /call. Then, the onmessage listener of
the WebSocket is used to implement the JSON signaling protocol in the client-side. Notice that there are four
incoming messages to client: masterResponse, viewerResponse, and stopCommunication. Convenient actions are taken to implement each step in the communication. For example, in the function master the
function WebRtcPeer.startSendRecv of kurento-utils.js is used to start a WebRTC communication. Then,
WebRtcPeer.startRecvOnly is used in the viewer function.
var ws = new WebSocket('ws://' + location.host + '/call');
ws.onmessage = function(message) {
var parsedMessage = JSON.parse(message.data);
console.info('Received message: ' + message.data);
switch (parsedMessage.id) {
case 'masterResponse':
masterResponse(parsedMessage);
break;
case 'viewerResponse':
viewerResponse(parsedMessage);
break;
7.2. Tutorial 3 - One to many video call
79
Kurento Documentation, Release 5.0.5
case 'stopCommunication':
dispose();
break;
default:
console.error('Unrecognized message', parsedMessage);
}
}
function master() {
if (!webRtcPeer) {
showSpinner(videoInput, videoOutput);
webRtcPeer = kurentoUtils.WebRtcPeer.startSendRecv(videoInput, videoOutput,
function(offerSdp) {
var message = {
id : 'master',
sdpOffer : offerSdp
};
sendMessage(message);
});
}
}
function viewer() {
if (!webRtcPeer) {
document.getElementById('videoSmall').style.display = 'none';
showSpinner(videoOutput);
webRtcPeer = kurentoUtils.WebRtcPeer.startRecvOnly(videoOutput, function(offerSdp) {
var message = {
id : 'viewer',
sdpOffer : offerSdp
};
sendMessage(message);
});
}
}
7.2.5 Dependencies
Dependencies of this demo are managed using npm. Our main dependency is the Kurento Client JavaScript (kurentoclient). The relevant part of the package.json file for managing this dependency is:
"dependencies": {
...
"kurento-client" : "^5.0.0"
}
At the client side, dependencies are managed using Bower. Take a look to the bower.json file and pay attention to the
following section:
"dependencies": {
"kurento-utils" : "^5.0.0"
}
Kurento framework uses Semantic Versioning for releases. Notice that range ^5.0.0 downloads the latest version of
Kurento artefacts from Bower in version 5 (i.e. 5.x.x). Major versions are released when incompatible changes are
80
Chapter 7. Tutorial 3 - WebRTC one-to-many broadcast
Kurento Documentation, Release 5.0.5
made.
Note: We are in active development. You can find the latest version of Kurento JavaScript Client at NPM and Bower.
7.2. Tutorial 3 - One to many video call
81
Kurento Documentation, Release 5.0.5
82
Chapter 7. Tutorial 3 - WebRTC one-to-many broadcast
CHAPTER 8
Tutorial 4 - WebRTC one-to-one video call
This web application is a videophone (call one to one) based on WebRTC.
8.1 Tutorial 4 - One to one video call
This web application consists on a one-to-one video call using WebRTC technology. In other words, this application
provides a simple video softphone.
8.1.1 For the impatient: running this example
First of all, you should install Kurento Media Server to run this demo. Please visit the installation guide for further
information.
To launch the application you need to clone the GitHub project where this demo is hosted and then run the main class,
as follows:
git clone https://github.com/Kurento/kurento-tutorial-java.git
cd kurento-tutorial-java/kurento-one2one-call
mvn compile exec:java
The web application starts on port 8080 in the localhost by default. Therefore, open the URL http://localhost:8080/ in
a WebRTC compliant browser (Chrome, Firefox).
8.1.2 Understanding this example
The following picture shows an screenshot of this demo running in a web browser:
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one for the local
stream and other for the remote peer stream). If two users, A and B, are using the application, the media flows in the
following way: The video camera stream of user A is sent to the Kurento Media Server, which sends it to user B. In
the same way, B send to Kurento Media Server, which forwards it to A. This means that KMS is providing a B2B
(back-to-back) call service.
To implement this behavior create a Media Pipeline composed by two WebRtC endpoints connected in B2B. The
implemented media pipeline is illustrated in the following picture:
The client and the server communicate through a signaling protocol based on JSON messages over WebSocket ‘s. The
normal sequence between client and server would be as follows:
1. User A is registered in the server with his name
83
Kurento Documentation, Release 5.0.5
Figure 8.1: One to one video call screenshot
Figure 8.2: One to one video call Media Pipeline
84
Chapter 8. Tutorial 4 - WebRTC one-to-one video call
Kurento Documentation, Release 5.0.5
2. User B is registered in the server with her name
3. User A wants to call to User B
4. User B accepts the incoming call
5. The communication is established and media is flowing between User A and User B
6. One of the users finishes the video communication
The detailed message flow in a call are shown in the picture below:
Figure 8.3: One to many one call signaling protocol
As you can see in the diagram, SDP needs to be interchanged between client and server to establish the WebRTC
connection between the browser and Kurento. Specifically, the SDP negotiation connects the WebRtcPeer in the
browser with the WebRtcEndpoint in the server.
The following sections describe in detail the server-side, the client-side, and how to run the demo. The complete
source code of this demo can be found in GitHub.
8.1. Tutorial 4 - One to one video call
85
Kurento Documentation, Release 5.0.5
8.1.3 Application Server Logic
This demo has been developed using Java in the server-side with Spring Boot framework. This technology can be
used to embed the Tomcat web server in the application and thus simplify the development process.
Note: You can use whatever Java server side technology you prefer to build web applications with Kurento. For
example, a pure Java EE application, SIP Servlets, Play, Vertex, etc. We have choose Spring Boot for convenience.
In the following figure you can see a class diagram of the server side code:
Figure 8.4: Server-side class diagram of the one to one video call app
One2OneCallApp
Us erRegis try
CallHandler
KurentoClient
CallMediaPipeline
*
Us erS es s ion
The main class of this demo is named One2OneCallApp. As you can see, the KurentoClient is instantiated in this
class as a Spring Bean.
@Configuration
@EnableWebSocket
@EnableAutoConfiguration
public class One2OneCallApp implements WebSocketConfigurer {
@Bean
public CallHandler callHandler() {
return new CallHandler();
}
@Bean
public UserRegistry registry() {
return new UserRegistry();
}
@Bean
public KurentoClient kurentoClient() {
return KurentoClient.create("ws://localhost:8888/kurento");
86
Chapter 8. Tutorial 4 - WebRTC one-to-one video call
Kurento Documentation, Release 5.0.5
}
public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
registry.addHandler(callHandler(), "/call");
}
public static void main(String[] args) throws Exception {
new SpringApplication(One2OneCallApp.class).run(args);
}
}
This web application follows Single Page Application architecture (SPA) and uses a WebSocket to communicate
client with server by means of requests and responses. Specifically, the main app class implements the interface
WebSocketConfigurer to register a WebSocketHanlder to process WebSocket requests in the path /call.
CallHandler class implements TextWebSocketHandler to handle text WebSocket requests. The central piece
of this class is the method handleTextMessage. This method implements the actions for requests, returning
responses through the WebSocket. In other words, it implements the server part of the signaling protocol depicted in
the previous sequence diagram.
In the designed protocol there are three different kind of incoming messages to the application server: register,
call, incomingCallResponse and stop. These messages are treated in the switch clause, taking the proper
steps in each case.
public class CallHandler extends TextWebSocketHandler {
private static final Logger log = LoggerFactory
.getLogger(CallHandler.class);
private static final Gson gson = new GsonBuilder().create();
private ConcurrentHashMap<String, CallMediaPipeline> pipelines =
new ConcurrentHashMap<String, CallMediaPipeline>();
@Autowired
private KurentoClient kurento;
@Autowired
private UserRegistry registry;
@Override
public void handleTextMessage(WebSocketSession session, TextMessage message)
throws Exception {
JsonObject jsonMessage = gson.fromJson(message.getPayload(),
JsonObject.class);
UserSession user = registry.getBySession(session);
if (user != null) {
log.debug("Incoming message from user '{}': {}", user.getName(),
jsonMessage);
} else {
log.debug("Incoming message from new user: {}", jsonMessage);
}
switch (jsonMessage.get("id").getAsString()) {
case "register":
try {
register(session, jsonMessage);
} catch (Throwable t) {
8.1. Tutorial 4 - One to one video call
87
Kurento Documentation, Release 5.0.5
log.error(t.getMessage(), t);
JsonObject response = new JsonObject();
response.addProperty("id", "resgisterResponse");
response.addProperty("response", "rejected");
response.addProperty("message", t.getMessage());
session.sendMessage(new TextMessage(response.toString()));
}
break;
case "call":
try {
call(user, jsonMessage);
} catch (Throwable t) {
log.error(t.getMessage(), t);
JsonObject response = new JsonObject();
response.addProperty("id", "callResponse");
response.addProperty("response", "rejected");
response.addProperty("message", t.getMessage());
session.sendMessage(new TextMessage(response.toString()));
}
break;
case "incomingCallResponse":
incomingCallResponse(user, jsonMessage);
break;
case "stop":
stop(session);
break;
default:
break;
}
}
private void register(WebSocketSession session, JsonObject jsonMessage)
throws IOException {
...
}
private void call(UserSession caller, JsonObject jsonMessage)
throws IOException {
...
}
private void incomingCallResponse(UserSession callee, JsonObject jsonMessage)
throws IOException {
...
}
public void stop(WebSocketSession session) throws IOException {
...
}
@Override
public void afterConnectionClosed(WebSocketSession session,
CloseStatus status) throws Exception {
registry.removeBySession(session);
}
}
88
Chapter 8. Tutorial 4 - WebRTC one-to-one video call
Kurento Documentation, Release 5.0.5
In the following snippet, we can see the register method. Basically, it obtains the name attribute from register
message and check if there are a registered user with that name. If not, the new user is registered and an acceptance
message is sent to it.
private void register(WebSocketSession session, JsonObject jsonMessage)
throws IOException {
String name = jsonMessage.getAsJsonPrimitive("name").getAsString();
UserSession caller = new UserSession(session, name);
String responseMsg = "accepted";
if (name.isEmpty()) {
responseMsg = "rejected: empty user name";
} else if (registry.exists(name)) {
responseMsg = "rejected: user '" + name + "' already registered";
} else {
registry.register(caller);
}
JsonObject response = new JsonObject();
response.addProperty("id", "resgisterResponse");
response.addProperty("response", responseMsg);
caller.sendMessage(response);
}
In the call method, the server checks if there are a registered user with the name specified in to message attribute
and send an incomingCall message to it. Or, if there isn’t any user with that name, a callResponse message
is sent to caller rejecting the call.
private void call(UserSession caller, JsonObject jsonMessage)
throws IOException {
String to = jsonMessage.get("to").getAsString();
String from = jsonMessage.get("from").getAsString();
JsonObject response = new JsonObject();
if (registry.exists(to)) {
UserSession callee = registry.getByName(to);
caller.setSdpOffer(jsonMessage.getAsJsonPrimitive("sdpOffer")
.getAsString());
caller.setCallingTo(to);
response.addProperty("id", "incomingCall");
response.addProperty("from", from);
callee.sendMessage(response);
callee.setCallingFrom(from);
} else {
response.addProperty("id", "callResponse");
response.addProperty("response", "rejected: user '" + to
+ "' is not registered");
caller.sendMessage(response);
}
}
The stop method finish the video call. This procedure can be called both by caller and callee in the communication.
The result is that both peers release the Media Pipeline and ends the video communication:
public void stop(WebSocketSession session) throws IOException {
String sessionId = session.getId();
8.1. Tutorial 4 - One to one video call
89
Kurento Documentation, Release 5.0.5
if (pipelines.containsKey(sessionId)) {
pipelines.get(sessionId).release();
CallMediaPipeline pipeline = pipelines.remove(sessionId);
pipeline.release();
// Both users can stop the communication. A 'stopCommunication'
// message will be sent to the other peer.
UserSession stopperUser = registry.getBySession(session);
UserSession stoppedUser = (stopperUser.getCallingFrom() != null) ? registry
.getByName(stopperUser.getCallingFrom()) : registry
.getByName(stopperUser.getCallingTo());
JsonObject message = new JsonObject();
message.addProperty("id", "stopCommunication");
stoppedUser.sendMessage(message);
}
}
In the incomingCallResponse method, if the callee user accepts the call, it is established and the media elements are created to connect the caller with the callee in a B2B manner. Basically, the server creates a
CallMediaPipeline object, to encapsulate the media pipeline creation and management. Then, this object is
used to negotiate media interchange with user’s browsers.
The negotiation between WebRTC peer in the browser and WebRtcEndpoint in Kurento Media Server is made
by means of SDP generation at the client (offer) and SDP generation at the server (answer). The SDP answers are generated with the Kurento Java Client inside the class CallMediaPipeline (as we see in a moment). The methods used to generate SDP are generateSdpAnswerForCallee(calleeSdpOffer) and
generateSdpAnswerForCaller(callerSdpOffer):
private void incomingCallResponse(UserSession callee, JsonObject jsonMessage)
throws IOException {
String callResponse = jsonMessage.get("callResponse").getAsString();
String from = jsonMessage.get("from").getAsString();
UserSession calleer = registry.getByName(from);
String to = calleer.getCallingTo();
if ("accept".equals(callResponse)) {
log.debug("Accepted call from '{}' to '{}'", from, to);
CallMediaPipeline pipeline = null;
try {
pipeline = new CallMediaPipeline(kurento);
pipelines.put(calleer.getSessionId(), pipeline);
pipelines.put(callee.getSessionId(), pipeline);
String calleeSdpOffer = jsonMessage.get("sdpOffer")
.getAsString();
String calleeSdpAnswer = pipeline
.generateSdpAnswerForCallee(calleeSdpOffer);
String callerSdpOffer = registry.getByName(from).getSdpOffer();
String callerSdpAnswer = pipeline
.generateSdpAnswerForCaller(callerSdpOffer);
JsonObject startCommunication = new JsonObject();
startCommunication.addProperty("id", "startCommunication");
startCommunication.addProperty("sdpAnswer", calleeSdpAnswer);
90
Chapter 8. Tutorial 4 - WebRTC one-to-one video call
Kurento Documentation, Release 5.0.5
callee.sendMessage(startCommunication);
JsonObject response = new JsonObject();
response.addProperty("id", "callResponse");
response.addProperty("response", "accepted");
response.addProperty("sdpAnswer", callerSdpAnswer);
calleer.sendMessage(response);
} catch (Throwable t) {
log.error(t.getMessage(), t);
if (pipeline != null) {
pipeline.release();
}
pipelines.remove(calleer.getSessionId());
pipelines.remove(callee.getSessionId());
JsonObject response = new JsonObject();
response.addProperty("id", "callResponse");
response.addProperty("response", "rejected");
calleer.sendMessage(response);
response = new JsonObject();
response.addProperty("id", "stopCommunication");
callee.sendMessage(response);
}
} else {
JsonObject response = new JsonObject();
response.addProperty("id", "callResponse");
response.addProperty("response", "rejected");
calleer.sendMessage(response);
}
}
The media logic in this demo is implemented in the class CallMediaPipeline. As you can see, the media pipeline
of this demo is quite simple: two WebRtcEndpoint elements directly interconnected. Please take note that the
WebRtcEndpoints need to be connected twice, one for each media direction.
public class CallMediaPipeline {
private MediaPipeline pipeline;
private WebRtcEndpoint callerWebRtcEP;
private WebRtcEndpoint calleeWebRtcEP;
public CallMediaPipeline(KurentoClient kurento) {
try {
this.pipeline = kurento.createMediaPipeline();
this.callerWebRtcEP = new WebRtcEndpoint.Builder(pipeline).build();
this.calleeWebRtcEP = new WebRtcEndpoint.Builder(pipeline).build();
this.callerWebRtcEP.connect(this.calleeWebRtcEP);
this.calleeWebRtcEP.connect(this.callerWebRtcEP);
} catch (Throwable t) {
if(this.pipeline != null){
pipeline.release();
}
8.1. Tutorial 4 - One to one video call
91
Kurento Documentation, Release 5.0.5
}
}
public String generateSdpAnswerForCaller(String sdpOffer) {
return callerWebRtcEP.processOffer(sdpOffer);
}
public String generateSdpAnswerForCallee(String sdpOffer) {
return calleeWebRtcEP.processOffer(sdpOffer);
}
public void release() {
if (pipeline != null) {
pipeline.release();
}
}
}
In this class we can see the implementation of methods generateSdpAnswerForCaller and
generateSdpAnswerForCallee. These methods delegate to WebRtc endpoints to create the appropriate
answer.
8.1.4 Client-Side
Let’s move now to the client-side of the application. To call the previously created WebSocket service in the serverside, we use the JavaScript class WebSocket. We use an specific Kurento JavaScript library called kurento-utils.js
to simplify the WebRTC interaction with the server. This library depends on adapter.js, which is a JavaScript WebRTC utility maintained by Google that abstracts away browser differences. Finally jquery.js is also needed in this
application.
These libraries are linked in the index.html web page, and are used in the index.js.
In the following snippet we can see the creation of the WebSocket (variable ws) in the path /call. Then,
the onmessage listener of the WebSocket is used to implement the JSON signaling protocol in the clientside. Notice that there are four incoming messages to client: resgisterResponse, callResponse,
incomingCall, and startCommunication. Convenient actions are taken to implement each step in the communication. For example, in functions call and incomingCall (for caller and callee respectively), the function
WebRtcPeer.startSendRecv of kurento-utils.js is used to start a WebRTC communication.
var ws = new WebSocket('ws://' + location.host + '/call');
ws.onmessage = function(message) {
var parsedMessage = JSON.parse(message.data);
console.info('Received message: ' + message.data);
switch (parsedMessage.id) {
case 'resgisterResponse':
resgisterResponse(parsedMessage);
break;
case 'callResponse':
callResponse(parsedMessage);
break;
case 'incomingCall':
incomingCall(parsedMessage);
break;
case 'startCommunication':
92
Chapter 8. Tutorial 4 - WebRTC one-to-one video call
Kurento Documentation, Release 5.0.5
startCommunication(parsedMessage);
break;
case 'stopCommunication':
console.info("Communication ended by remote peer");
stop(true);
break;
default:
console.error('Unrecognized message', parsedMessage);
}
}
function incomingCall(message) {
//If bussy just reject without disturbing user
if(callState != NO_CALL){
var response = {
id : 'incomingCallResponse',
from : message.from,
callResponse : 'reject',
message : 'bussy'
};
return sendMessage(response);
}
setCallState(PROCESSING_CALL);
if (confirm('User ' + message.from + ' is calling you. Do you accept the call?')) {
showSpinner(videoInput, videoOutput);
webRtcPeer = kurentoUtils.WebRtcPeer.startSendRecv(videoInput, videoOutput,
function(sdp, wp) {
var response = {
id : 'incomingCallResponse',
from : message.from,
callResponse : 'accept',
sdpOffer : sdp
};
sendMessage(response);
}, function(error){
setCallState(NO_CALL);
});
} else {
var response = {
id : 'incomingCallResponse',
from : message.from,
callResponse : 'reject',
message : 'user declined'
};
sendMessage(response);
stop();
}
}
function call() {
if(document.getElementById('peer').value == ''){
window.alert("You must specify the peer name");
return;
}
setCallState(PROCESSING_CALL);
showSpinner(videoInput, videoOutput);
8.1. Tutorial 4 - One to one video call
93
Kurento Documentation, Release 5.0.5
kurentoUtils.WebRtcPeer.startSendRecv(videoInput, videoOutput, function(offerSdp, wp) {
webRtcPeer = wp;
console.log('Invoking SDP offer callback function');
var message = {
id : 'call',
from : document.getElementById('name').value,
to : document.getElementById('peer').value,
sdpOffer : offerSdp
};
sendMessage(message);
}, function(error){
console.log(error);
setCallState(NO_CALL);
});
}
8.1.5 Dependencies
This Java Spring application is implementad using Maven. The relevant part of the pom.xml is where Kurento dependencies are declared. As the following snippet shows, we need two dependencies: the Kurento Client Java dependency
(kurento-client) and the JavaScript Kurento utility library (kurento-utils) for the client-side:
<dependencies>
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-client</artifactId>
<version>[5.0.0,6.0.0)</version>
</dependency>
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-utils-js</artifactId>
<version>[5.0.0,6.0.0)</version>
</dependency>
</dependencies>
Kurento framework uses Semantic Versioning for releases. Notice that range [5.0.0,6.0.0) downloads the latest
version of Kurento artefacts from Maven Central in version 5 (i.e. 5.x.x). Major versions are released when incompatible changes are made.
Note: We are in active development. You can find the latest version of Kurento Java Client at Maven Central.
Kurento Java Client has a minimum requirement of Java 7. To configure the application to use Java 7, we have to
include the following properties in the properties section:
<maven.compiler.target>1.7</maven.compiler.target>
<maven.compiler.source>1.7</maven.compiler.source>
8.2 Tutorial 4 - One to one video call
This web application consists on a one-to-one video call using WebRTC technology. In other words, this application
provides a simple video softphone.
94
Chapter 8. Tutorial 4 - WebRTC one-to-one video call
Kurento Documentation, Release 5.0.5
8.2.1 For the impatient: running this example
First of all, you should install Kurento Media Server to run this demo. Please visit the installation guide for further
information.
Be sure to have installed Node.js and Bower in your system. In an Ubuntu machine, you can install both as follows:
curl -sL https://deb.nodesource.com/setup | sudo bash sudo apt-get install -y nodejs
sudo npm install -g bower
To launch the application you need to clone the GitHub project where this demo is hosted and then install and run it,
as follows:
git clone https://github.com/Kurento/kurento-tutorial-node.git
cd kurento-tutorial-node/kurento-one2one-call
npm install
node app.js
Access the application connecting to the URL http://localhost:8080/ through a WebRTC capable browser (Chrome,
Firefox).
8.2.2 Understanding this example
The following picture shows an screenshot of this demo running in a web browser:
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one for the local
stream and other for the remote peer stream). If two users, A and B, are using the application, the media flows in the
following way: The video camera stream of user A is sent to the Kurento Media Server, which sends it to user B. In
the same way, B send to Kurento Media Server, which forwards it to A. This means that KMS is providing a B2B
(back-to-back) call service.
To implement this behavior create a Media Pipeline composed by two WebRtC endpoints connected in B2B. The
implemented media pipeline is illustrated in the following picture:
The client and the server communicate through a signaling protocol based on JSON messages over WebSocket ‘s. The
normal sequence between client and application server logic is as follows:
1. User A is registered in the application server with his name
2. User B is registered in the application server with her name
3. User A issues a call to User B
4. User B accepts the incoming call
5. The communication is established and media flows between User A and User B
6. One of the users finishes the video communication
The detailed message flow in a call are shown in the picture below:
As you can see in the diagram, SDP needs to be interchanged between client and server to establish the WebRTC
connection between the browser and Kurento. Specifically, the SDP negotiation connects the WebRtcPeer in the
browser with the WebRtcEndpoint in the server.
The following sections describe in detail the server-side, the client-side, and how to run the demo. The complete
source code of this demo can be found in GitHub.
8.2. Tutorial 4 - One to one video call
95
Kurento Documentation, Release 5.0.5
Figure 8.5: One to one video call screenshot
Figure 8.6: One to one video call Media Pipeline
96
Chapter 8. Tutorial 4 - WebRTC one-to-one video call
Kurento Documentation, Release 5.0.5
Figure 8.7: One to many one call signaling protocol
8.2. Tutorial 4 - One to one video call
97
Kurento Documentation, Release 5.0.5
8.2.3 Application Server Logic
This demo has been developed using the express framework for Node.js, but express is not a requirement for Kurento.
The main script of this demo is app.js.
var kurento = require('kurento-client');
//...
const ws_uri = "ws://localhost:8888/kurento";
//...
kurento(ws_uri, function(error, _kurentoClient) {
if (error) {
console.log("Could not find media server at address " + ws_uri);
return callback("Could not find media server at address" + ws_uri
+ ". Exiting with error " + error);
}
kurentoClient = _kurentoClient;
callback(null, kurentoClient);
});
This web application follows Single Page Application architecture (SPA) and uses a WebSocket in the path /call to
communicate client with applications server by beans of requests and responses.
In the designed protocol there are three different kind of incoming messages to the applications server : register,
call, incomingCallResponse and stop. These messages are treated in the switch clause, taking the proper
steps in each case.
The following code snippet implements the server part of the signaling protocol depicted in the previous sequence
diagram.
wss.on('connection', function(ws) {
//...
ws.on('message', function(_message) {
var message = JSON.parse(_message);
switch (message.id) {
case 'register':
register(sessionId,
message.name, ws);
break;
case 'call':
call(sessionId, message.to,
message.from, message.sdpOffer); break;
case 'incomingCallResponse':
incomingCallResponse(sessionId,
message.from, message.callResponse, message.sdpOffer);
break;
case 'stop':
stop(sessionId); break;
98
Chapter 8. Tutorial 4 - WebRTC one-to-one video call
Kurento Documentation, Release 5.0.5
}
});
});
In the following snippet, we can see the register method. Basically, it obtains the name attribute from register
message and check if there are a registered user with that name. If not, the new user is registered and an acceptance
message is sent to it.
function register(id, name, ws, callback){
if(userRegistry.getByName(name)){
return onError("already registered");
}
userRegistry.register(new UserSession(id, name, ws));
ws.send(JSON.stringify({id: 'registerResponse', response: 'accepted'}));
}
In the call method, the server checks if there are a registered user with the name specified in to message attribute
and send an incomingCall message to it. Or, if there isn’t any user with that name, a callResponse message
is sent to caller rejecting the call.
function call(callerId, to, from, sdpOffer){
var caller = userRegistry.getById(callerId);
var rejectCause = 'user ' + to + ' is not registered';
if(userRegistry.getByName(to)){
var callee = userRegistry.getByName(to);
caller.sdpOffer = sdpOffer
callee.peer = from;
caller.peer = to;
var message = {
id: 'incomingCall',
from: from
};
return callee.sendMessage(message);
}
var message = {
id: 'callResponse',
response: 'rejected: ',
message: rejectCause
};
caller.sendMessage(message);
}
The stop method finish the video call. This procedure can be called both by caller and callee in the communication.
The result is that both peers release the Media Pipeline and ends the video communication:
function stop(sessionId){
var pipeline = pipelines[sessionId];
delete pipelines[sessionId];
pipeline.release();
var stopperUser = userRegistry.getById(sessionId);
var stoppedUser = userRegistry.getByName(stopperUser.peer);
stopperUser.peer = null;
if(stoppedUser){
stoppedUser.peer = null;
delete pipelines[stoppedUser.id];
var message = {
8.2. Tutorial 4 - One to one video call
99
Kurento Documentation, Release 5.0.5
id: 'stopCommunication',
message: 'remote user hanged out'
}
stoppedUser.sendMessage(message)
}
}
In the incomingCallResponse method, if the callee user accepts the call, it is established and the media elements are created to connect the caller with the callee in a B2B manner. Basically, the server creates a
CallMediaPipeline object, to encapsulate the media pipeline creation and management. Then, this object is
used to negotiate media interchange with user’s browsers.
The negotiation between WebRTC peer in the browser and WebRtcEndpoint in Kurento Media Server
is made by means of SDP s.
An SDP answers is produced by WebRtcEndpoints when invoking
generateSdpAnswerForCallee and generateSdpAnswerForCaller functions:
function incomingCallResponse(calleeId, from, callResponse, calleeSdp){
var callee = userRegistry.getById(calleeId);
if(!from || !userRegistry.getByName(from)){
return onError(null, 'unknown from = ' + from);
}
var caller = userRegistry.getByName(from);
if(callResponse === 'accept'){
var pipeline = new CallMediaPipeline();
pipeline.createPipeline(function(error){
pipeline.generateSdpAnswerForCaller(caller.sdpOffer,
function(error, callerSdpAnswer){
if(error) {
return onError(error, error);
}
pipeline.generateSdpAnswerForCallee(calleeSdp,
function(error, calleeSdpAnswer) {
pipelines[caller.id] = pipeline;
pipelines[callee.id] = pipeline;
var message = {
id: 'startCommunication',
sdpAnswer: calleeSdpAnswer
};
callee.sendMessage(message);
message = {
id: 'callResponse',
response : 'accepted',
sdpAnswer: callerSdpAnswer
};
caller.sendMessage(message);
});
});
});
} else {
100
Chapter 8. Tutorial 4 - WebRTC one-to-one video call
Kurento Documentation, Release 5.0.5
var decline = {
id: 'callResponse',
response: 'rejected',
message: 'user declined'
};
caller.sendMessage(decline);
}
}
The media logic is implemented in the class CallMediaPipeline. As you can see, the required media pipeline is
quite simple: two WebRtcEndpoint elements directly interconnected. Note that the WebRtcEndpoints need to be
connected twice, one for each media direction. Also observe how the methods generateSdpAnswerForCaller
and generateSdpAnswerForCallee described above are implemented.
CallMediaPipeline.prototype.createPipeline = function(callback){
var self = this;
//...
kurentoClient.create('MediaPipeline', function(error, pipeline){
pipeline.create('WebRtcEndpoint', function(error, callerWebRtcEndpoint){
pipeline.create('WebRtcEndpoint', function(error, calleeWebRtcEndpoint){
callerWebRtcEndpoint.connect(calleeWebRtcEndpoint, function(error){
calleeWebRtcEndpoint.connect(callerWebRtcEndpoint, function(error){
self._pipeline = pipeline;
self._callerWebRtcEndpoint = callerWebRtcEndpoint;
self._calleeWebRtcEndpoint = calleeWebRtcEndpoint;
callback(null);
});
});
});
});
});
}
CallMediaPipeline.prototype.generateSdpAnswerForCaller = function(sdpOffer, callback){
this._callerWebRtcEndpoint.processOffer(sdpOffer, callback);
}
CallMediaPipeline.prototype.generateSdpAnswerForCallee = function(sdpOffer, callback){
this._calleeWebRtcEndpoint.processOffer(sdpOffer, callback);
}
CallMediaPipeline.prototype.release = function(){
if(this._pipeline) this._pipeline.release();
this._pipeline = null;
}
8.2.4 Client-Side
Let’s move now to the client-side of the application. To call the previously created WebSocket service in the serverside, we use the JavaScript class WebSocket. We use an specific Kurento JavaScript library called kurento-utils.js
to simplify the WebRTC interaction with the server. This library depends on adapter.js, which is a JavaScript WebRTC utility maintained by Google that abstracts away browser differences. Finally jquery.js is also needed in this
8.2. Tutorial 4 - One to one video call
101
Kurento Documentation, Release 5.0.5
application.
These libraries are linked in the index.html web page, and are used in the index.js.
In the following snippet we can see the creation of the WebSocket (variable ws) in the path /call. Then,
the onmessage listener of the WebSocket is used to implement the JSON signaling protocol in the clientside. Notice that there are four incoming messages to client: resgisterResponse, callResponse,
incomingCall, and startCommunication. Convenient actions are taken to implement each step in the communication. For example, in functions call and incomingCall (for caller and callee respectively), the function
WebRtcPeer.startSendRecv of kurento-utils.js is used to start a WebRTC communication.
var ws = new WebSocket('ws://' + location.host + '/call');
ws.onmessage = function(message) {
var parsedMessage = JSON.parse(message.data);
console.info('Received message: ' + message.data);
switch (parsedMessage.id) {
case 'resgisterResponse':
resgisterResponse(parsedMessage);
break;
case 'callResponse':
callResponse(parsedMessage);
break;
case 'incomingCall':
incomingCall(parsedMessage);
break;
case 'startCommunication':
startCommunication(parsedMessage);
break;
case 'stopCommunication':
console.info("Communication ended by remote peer");
stop(true);
break;
default:
console.error('Unrecognized message', parsedMessage);
}
}
function incomingCall(message) {
//If bussy just reject without disturbing user
if(callState != NO_CALL){
var response = {
id : 'incomingCallResponse',
from : message.from,
callResponse : 'reject',
message : 'bussy'
};
return sendMessage(response);
}
setCallState(PROCESSING_CALL);
if (confirm('User ' + message.from + ' is calling you. Do you accept the call?')) {
showSpinner(videoInput, videoOutput);
webRtcPeer = kurentoUtils.WebRtcPeer.startSendRecv(videoInput, videoOutput,
function(sdp, wp) {
var response = {
id : 'incomingCallResponse',
from : message.from,
102
Chapter 8. Tutorial 4 - WebRTC one-to-one video call
Kurento Documentation, Release 5.0.5
callResponse : 'accept',
sdpOffer : sdp
};
sendMessage(response);
}, function(error){
setCallState(NO_CALL);
});
} else {
var response = {
id : 'incomingCallResponse',
from : message.from,
callResponse : 'reject',
message : 'user declined'
};
sendMessage(response);
stop();
}
}
function call() {
if(document.getElementById('peer').value == ''){
window.alert("You must specify the peer name");
return;
}
setCallState(PROCESSING_CALL);
showSpinner(videoInput, videoOutput);
kurentoUtils.WebRtcPeer.startSendRecv(videoInput, videoOutput, function(offerSdp, wp) {
webRtcPeer = wp;
console.log('Invoking SDP offer callback function');
var message = {
id : 'call',
from : document.getElementById('name').value,
to : document.getElementById('peer').value,
sdpOffer : offerSdp
};
sendMessage(message);
}, function(error){
console.log(error);
setCallState(NO_CALL);
});
}
8.2.5 Dependencies
Dependencies of this demo are managed using npm. Our main dependency is the Kurento Client JavaScript (kurentoclient). The relevant part of the package.json file for managing this dependency is:
"dependencies": {
...
"kurento-client" : "^5.0.0"
}
At the client side, dependencies are managed using Bower. Take a look to the bower.json file and pay attention to the
following section:
8.2. Tutorial 4 - One to one video call
103
Kurento Documentation, Release 5.0.5
"dependencies": {
"kurento-utils" : "^5.0.0"
}
Kurento framework uses Semantic Versioning for releases. Notice that range ^5.0.0 downloads the latest version of
Kurento artefacts from Bower in version 5 (i.e. 5.x.x). Major versions are released when incompatible changes are
made.
Note: We are in active development. You can find the latest version of Kurento JavaScript Client at NPM and Bower.
104
Chapter 8. Tutorial 4 - WebRTC one-to-one video call
CHAPTER 9
Tutorial 5 - WebRTC one-to-one video call with recording and filtering
This is an enhanced version of the previous application recording of the video communication, and also integration
with an augmented reality filter.
9.1 Tutorial 5 - Advanced One to one video call
This web application consists on an advanced one to one video call using WebRTC technology. It is an improved
version of the tutorial 4).
9.1.1 For the impatient: running this example
First of all, you should install Kurento Media Server to run this demo. Please visit the installation guide for further
information.
To launch the application you need to clone the GitHub project where this demo is hosted and then run the main class,
as follows:
git clone https://github.com/Kurento/kurento-tutorial-java.git
cd kurento-tutorial-java/kurento-one2one-call-advanced
mvn compile exec:java
The web application starts on port 8080 in the localhost by default. Therefore, open the URL http://localhost:8080/ in
a WebRTC compliant browser (Chrome, Firefox).
9.1.2 Understanding this example
This application incorporates the recording capability provided by the Kurento Media Server in a one to one video
communication. In addition, a filter element (FaceOverlayFilter) in placed between the WebRtcEndpoints of the Media
Pipeline. The following picture shows an screenshot of this demo running in a web browser:
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one for the local
video camera stream (the caller stream, the smaller video in the picture) and other for the remote peer in the call (the
callee stream, the bigger video in the picture). If two users, A and B, are using the application, the media flows in the
following way: The video camera stream of user A is sent to the Kurento Media Server and sent again to the user B.
On the other hand, user B sends its video camera stream to Kurento and then it is sent to user A.
This application is implemented by means of two Media Pipeline ‘s. First, the rich real-time WebRTC communication
is performed two WebRtcEndpoints interconnected, and with a FaceOverlayFilter in between them. In addition and a
105
Kurento Documentation, Release 5.0.5
Figure 9.1: Advanced one to one video call screenshot
106
Chapter 9. Tutorial 5 - WebRTC one-to-one video call with recording and filtering
Kurento Documentation, Release 5.0.5
RecorderEndpoint is used to store both streams in the file system of the Kurento Media Server. This media pipeline is
illustrated in the following picture:
Figure 9.2: Advanced one to one video call media pipeline (1)
A second media pipeline is needed to play the previously recorded media. This pipeline is composed by a PlayerEndpoint which reads the files stored in the Kurento Media Server. This media element injects the media in a
WebRtcEndpoint which is charge to transport the media to the HTML5 video tag in the browser:
Figure 9.3: Advanced one to one video call media pipeline (2)
Note: The playback of a static file can be done in several ways. In addition to this media pipeline (PlayerEndpoint ->
WebRtcEndpoint), other possibilities can be implemented. For example, a Media Pipeline composed by PlayerEndpoint -> HttpGetEndpoint could be another possible alternative. Also, the recorded file could be served directly by an
HTTP server.
To communicate the client with the server to manage calls we have designed a signaling protocol based on JSON
messages over WebSocket ‘s. The normal sequence between client and server would be as follows:
1. User A is registered in the server with his name
2. User B is registered in the server with her name
3. User A wants to call to User B
4. User B accepts the incoming call
5. The communication is established and media is flowing between User A and User B
6. One of the users finishes the video communication
7. One of the users play the recorded media
9.1. Tutorial 5 - Advanced One to one video call
107
Kurento Documentation, Release 5.0.5
This is very simple protocol designed to show a simple one to one call application implemented with Kurento. In
a professional application it can be improved, for example implementing seeking user, ordered finish, among other
functions.
Assuming that User A is using Client A and User B is using Client B, we can draw the following sequence diagram with
detailed messages between clients and server. The following diagram shows the two parts of the signaling protocol:
first the enhanced real-time communication is performed, and then the playback of the recorded file is carried out.
Figure 9.4: Advanced one to one video call signaling protocol
As you can see in the diagram, SDP needs to be interchanged between client and server to establish the WebRTC
connection between the browser and Kurento. Specifically, the SDP negotiation connects the WebRtcPeer in the
browser with the WebRtcEndpoint in the server.
108
Chapter 9. Tutorial 5 - WebRTC one-to-one video call with recording and filtering
Kurento Documentation, Release 5.0.5
The following sections describe in detail the server-side, the client-side, and how to run the demo. The complete
source code of this demo can be found in GitHub.
9.1.3 Application Server Logic
As in the tutorial 2, this demo has been developed using Java and Spring Boot.
Note: You can use whatever Java server side technology you prefer to build web applications with Kurento. For
example, a pure Java EE application, SIP Servlets, Play, Vertex, etc. We have choose Spring Boot for convenience.
In the following figure you can see a class diagram of the server side code:
Figure 9.5: Server-side class diagram of the advanced one to one video call app
One2OneCallAdvApp
Us erRegis try
CallHandler
KurentoClient
*
Us erS es s ion
CallMediaPipeline
PlayMediaPipeline
The main class of this demo is named One2OneCallAdvApp. As you can see, the KurentoClient is instantiated
in this class as a Spring Bean.
@Configuration
@EnableWebSocket
@EnableAutoConfiguration
public class One2OneCallAdvApp implements WebSocketConfigurer {
@Bean
public CallHandler callHandler() {
return new CallHandler();
}
@Bean
public UserRegistry registry() {
return new UserRegistry();
}
9.1. Tutorial 5 - Advanced One to one video call
109
Kurento Documentation, Release 5.0.5
@Bean
public KurentoClient kurentoClient() {
return KurentoClient.create("ws://localhost:8888/kurento");
}
public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
registry.addHandler(callHandler(), "/call");
}
public static void main(String[] args) throws Exception {
new SpringApplication(One2OneCallAdvApp.class).run(args);
}
}
This web application follows Single Page Application architecture (SPA) and uses a WebSocket to communicate
client with server by means of requests and responses. Specifically, the main app class implements the interface
WebSocketConfigurer to register a WebSocketHanlder to process WebSocket requests in the path /call.
CallHandler class implements TextWebSocketHandler to handle text WebSocket requests. The central piece
of this class is the method handleTextMessage. This method implements the actions for requests, returning
responses through the WebSocket. In other words, it implements the server part of the signaling protocol depicted in
the previous sequence diagram.
In the designed protocol there are three different kind of incoming messages to the Server : register, call,
incomingCallResponse, and play. These messages are treated in the switch clause, taking the proper steps in
each case.
public class CallHandler extends TextWebSocketHandler {
private static final Logger log = LoggerFactory.getLogger(CallHandler.class);
private static final Gson gson = new GsonBuilder().create();
@Autowired
private KurentoClient kurento;
@Autowired
private UserRegistry registry;
@Override
public void handleTextMessage(WebSocketSession session, TextMessage message)
throws Exception {
JsonObject jsonMessage = gson.fromJson(message.getPayload(),
JsonObject.class);
UserSession user = registry.getBySession(session);
if (user != null) {
log.debug("Incoming message from user '{}': {}", user.getName(),
jsonMessage);
} else {
log.debug("Incoming message from new user: {}", jsonMessage);
}
switch (jsonMessage.get("id").getAsString()) {
case "register":
register(session, jsonMessage);
break;
case "call":
call(user, jsonMessage);
110
Chapter 9. Tutorial 5 - WebRTC one-to-one video call with recording and filtering
Kurento Documentation, Release 5.0.5
break;
case "incomingCallResponse":
incomingCallResponse(user, jsonMessage);
break;
case "play":
play(session, jsonMessage);
break;
default:
break;
}
}
private void register(WebSocketSession session, JsonObject jsonMessage)
throws IOException {
...
}
private void call(UserSession caller, JsonObject jsonMessage)
throws IOException {
...
}
private void incomingCallResponse(UserSession callee,
JsonObject jsonMessage) throws IOException {
...
}
private void play(WebSocketSession session, JsonObject jsonMessage)
throws IOException {
...
}
@Override
public void afterConnectionClosed(WebSocketSession session,
CloseStatus status) throws Exception {
registry.removeBySession(session);
}
}
In the following snippet, we can see the register method. Basically, it obtains the name attribute from register
message and check if there are a registered user with that name. If not, the new user is registered and an acceptance
message is sent to it.
private void register(WebSocketSession session, JsonObject jsonMessage)
throws IOException {
String name = jsonMessage.getAsJsonPrimitive("name").getAsString();
UserSession caller = new UserSession(session, name);
String responseMsg = "accepted";
if (name.isEmpty()) {
responseMsg = "rejected: empty user name";
} else if (registry.exists(name)) {
responseMsg = "rejected: user '" + name + "' already registered";
} else {
registry.register(caller);
}
9.1. Tutorial 5 - Advanced One to one video call
111
Kurento Documentation, Release 5.0.5
JsonObject response = new JsonObject();
response.addProperty("id", "resgisterResponse");
response.addProperty("response", responseMsg);
caller.sendMessage(response);
}
In the call method, the server checks if there are a registered user with the name specified in to message attribute
and send an incomingCall message to it. Or, if there isn’t any user with that name, a callResponse message
is sent to caller rejecting the call.
private void call(UserSession caller, JsonObject jsonMessage) throws IOException {
String to = jsonMessage.get("to").getAsString();
if (registry.exists(to)) {
UserSession callee = registry.getByName(to);
caller.setSdpOffer(jsonMessage.getAsJsonPrimitive("sdpOffer").getAsString());
caller.setCallingTo(to);
JsonObject response = new JsonObject();
response.addProperty("id", "incomingCall");
response.addProperty("from", caller.getName());
callee.sendMessage(response);
} else {
JsonObject response = new JsonObject();
response.addProperty("id", "callResponse");
response.addProperty("response", "rejected: user '"+to+"' is not registered");
caller.sendMessage(response);
}
}
In the incomingCallResponse method, if the callee user accepts the call, it is established and the media elements
are created to connect the caller with the callee. Basically, the server creates a CallMediaPipeline object, to
encapsulate the media pipeline creation and management. Then, this object is used to negotiate media interchange
with user’s browsers.
As explained in tutorial 2, the negotiation between WebRTC peer in the browser and WebRtcEndpoint in Kurento
Server is made by means of SDP generation at the client (offer) and SDP generation at the server (answer). The
SDP answers are generated with the Kurento Java Client inside the class CallMediaPipeline (as we see in a
moment). The methods used to generate SDP are generateSdpAnswerForCallee(calleeSdpOffer) and
generateSdpAnswerForCaller(callerSdpOffer):
private void incomingCallResponse(UserSession callee,
JsonObject jsonMessage) throws IOException {
String callResponse = jsonMessage.get("callResponse").getAsString();
String from = jsonMessage.get("from").getAsString();
UserSession calleer = registry.getByName(from);
String to = calleer.getCallingTo();
if ("accept".equals(callResponse)) {
log.debug("Accepted call from '{}' to '{}'", from, to);
CallMediaPipeline pipeline = new CallMediaPipeline(kurento, from,
112
Chapter 9. Tutorial 5 - WebRTC one-to-one video call with recording and filtering
Kurento Documentation, Release 5.0.5
to);
String calleeSdpOffer = jsonMessage.get("sdpOffer").getAsString();
String calleeSdpAnswer = pipeline
.generateSdpAnswerForCallee(calleeSdpOffer);
JsonObject startCommunication = new JsonObject();
startCommunication.addProperty("id", "startCommunication");
startCommunication.addProperty("sdpAnswer", calleeSdpAnswer);
callee.sendMessage(startCommunication);
String callerSdpOffer = registry.getByName(from).getSdpOffer();
String callerSdpAnswer = pipeline
.generateSdpAnswerForCaller(callerSdpOffer);
JsonObject response = new JsonObject();
response.addProperty("id", "callResponse");
response.addProperty("response", "accepted");
response.addProperty("sdpAnswer", callerSdpAnswer);
calleer.sendMessage(response);
pipeline.record();
} else {
JsonObject response = new JsonObject();
response.addProperty("id", "callResponse");
response.addProperty("response", "rejected");
calleer.sendMessage(response);
}
}
Finally, the play method instantiates a PlayMediaPipeline object, which is used to create Media Pipeline in
charge of the playback of the recorded streams in the Kurento Media Server.
private void play(WebSocketSession session, JsonObject jsonMessage)
throws IOException {
String user = jsonMessage.get("user").getAsString();
log.debug("Playing recorded call of user '{}'", user);
PlayMediaPipeline pipeline = new PlayMediaPipeline(kurento, user,
session);
String sdpOffer = jsonMessage.get("sdpOffer").getAsString();
String sdpAnswer = pipeline.generateSdpAnswer(sdpOffer);
JsonObject response = new JsonObject();
response.addProperty("id", "playResponse");
response.addProperty("response", "accepted");
response.addProperty("sdpAnswer", sdpAnswer);
session.sendMessage(new TextMessage(response.toString()));
pipeline.play();
}
The media logic in this demo is implemented in the classes CallMediaPipeline and PlayMediaPipeline. The first media
pipeline consists on two WebRtcEndpoint elements interconnected with a FaceOverlayFilter in between,
and also with and RecorderEndpoint to carry out the recording of the WebRTC communication. Please take
note that the WebRtc endpoints needs to be connected twice, one for each media direction. In this class we can see
the implementation of methods generateSdpAnswerForCaller and generateSdpAnswerForCallee.
9.1. Tutorial 5 - Advanced One to one video call
113
Kurento Documentation, Release 5.0.5
These methods delegate to WebRtc endpoints to create the appropriate answer.
public class CallMediaPipeline {
public static final String RECORDING_PATH = "file:///tmp/";
public static final String RECORDING_EXT = ".webm";
private
private
private
private
WebRtcEndpoint webRtcCaller;
WebRtcEndpoint webRtcCallee;
RecorderEndpoint recorderCaller;
RecorderEndpoint recorderCallee;
public CallMediaPipeline(KurentoClient kurento, String from, String to) {
// Media pipeline
MediaPipeline pipeline = kurento.createMediaPipeline();
// Media Elements (WebRtcEndpoint, RecorderEndpoint, FaceOverlayFilter)
webRtcCaller = new WebRtcEndpoint.Builder(pipeline).build();
webRtcCallee = new WebRtcEndpoint.Builder(pipeline).build();
recorderCaller = new RecorderEndpoint.Builder(pipeline, RECORDING_PATH
+ from + RECORDING_EXT).build();
recorderCallee = new RecorderEndpoint.Builder(pipeline, RECORDING_PATH
+ to + RECORDING_EXT).build();
FaceOverlayFilter faceOverlayFilterCaller = new FaceOverlayFilter.Builder(
pipeline).build();
faceOverlayFilterCaller.setOverlayedImage(
"http://files.kurento.org/imgs/mario-wings.png", -0.35F, -1.2F,
1.6F, 1.6F);
FaceOverlayFilter faceOverlayFilterCallee = new FaceOverlayFilter.Builder(
pipeline).build();
faceOverlayFilterCallee.setOverlayedImage(
"http://files.kurento.org/imgs/Hat.png", -0.2F, -1.35F, 1.5F,
1.5F);
// Connections
webRtcCaller.connect(faceOverlayFilterCaller);
faceOverlayFilterCaller.connect(webRtcCallee);
faceOverlayFilterCaller.connect(recorderCaller);
webRtcCallee.connect(faceOverlayFilterCallee);
faceOverlayFilterCallee.connect(webRtcCaller);
faceOverlayFilterCallee.connect(recorderCallee);
}
public void record() {
recorderCaller.record();
recorderCallee.record();
}
public String generateSdpAnswerForCaller(String sdpOffer) {
return webRtcCaller.processOffer(sdpOffer);
}
public String generateSdpAnswerForCallee(String sdpOffer) {
return webRtcCallee.processOffer(sdpOffer);
}
114
Chapter 9. Tutorial 5 - WebRTC one-to-one video call with recording and filtering
Kurento Documentation, Release 5.0.5
}
The second media pipeline consists on a PlayerEndpoint connected to a WebRtcEndpoint. The
PlayerEndpoint reads the previously recorded media in the file system of the Kurento Media Server. The
WebRtcEndpoint is used in receive-only mode.
public class PlayMediaPipeline {
private static final Logger log = LoggerFactory
.getLogger(PlayMediaPipeline.class);
private WebRtcEndpoint webRtc;
private PlayerEndpoint player;
public PlayMediaPipeline(KurentoClient kurento, String user,
final WebSocketSession session) {
// Media pipeline
MediaPipeline pipeline = kurento.createMediaPipeline();
// Media Elements (WebRtcEndpoint, PlayerEndpoint)
webRtc = new WebRtcEndpoint.Builder(pipeline).build();
player = new PlayerEndpoint.Builder(pipeline, RECORDING_PATH + user
+ RECORDING_EXT).build();
// Connection
player.connect(webRtc);
// Player listeners
player.addErrorListener(new EventListener<ErrorEvent>() {
@Override
public void onEvent(ErrorEvent event) {
log.info("ErrorEvent: {}", event.getDescription());
sendPlayEnd(session);
}
});
player.addEndOfStreamListener(new EventListener<EndOfStreamEvent>() {
@Override
public void onEvent(EndOfStreamEvent event) {
sendPlayEnd(session);
}
});
}
public void sendPlayEnd(WebSocketSession session) {
try {
JsonObject response = new JsonObject();
response.addProperty("id", "playEnd");
session.sendMessage(new TextMessage(response.toString()));
} catch (IOException e) {
log.error("Error sending playEndOfStream message", e);
}
}
public void play() {
player.play();
}
public String generateSdpAnswer(String sdpOffer) {
9.1. Tutorial 5 - Advanced One to one video call
115
Kurento Documentation, Release 5.0.5
return webRtc.processOffer(sdpOffer);
}
}
9.1.4 Client-Side
Let’s move now to the client-side of the application. To call the previously created WebSocket service in the serverside, we use the JavaScript class WebSocket. We use an specific Kurento JavaScript library called kurento-utils.js
to simplify the WebRTC interaction with the server. This library depends on adapter.js, which is a JavaScript WebRTC utility maintained by Google that abstracts away browser differences. Finally jquery.js is also needed in this
application.
These libraries are linked in the index.html web page, and are used in the index.js.
In the following snippet we can see the creation of the WebSocket (variable ws) in the path /call. Then, the
onmessage listener of the WebSocket is used to implement the JSON signaling protocol in the client-side. Notice that there are four incoming messages to client: resgisterResponse, callResponse, incomingCall,
startCommunication, and play. Convenient actions are taken to implement each step in the communication. On the one hand, in functions call and incomingCall (for caller and callee respectively), the function
WebRtcPeer.startSendRecv of kurento-utils.js is used to start a WebRTC communication. On the other hand
in the function play, the function WebRtcPeer.startRecvOnly is called since the WebRtcEndpoint is used
in receive-only.
var ws = new WebSocket('ws://' + location.host + '/call');
ws.onmessage = function(message) {
var parsedMessage = JSON.parse(message.data);
console.info('Received message: ' + message.data);
switch (parsedMessage.id) {
case 'resgisterResponse':
resgisterResponse(parsedMessage);
break;
case 'callResponse':
callResponse(parsedMessage);
break;
case 'incomingCall':
incomingCall(parsedMessage);
break;
case 'startCommunication':
startCommunication(parsedMessage);
break;
case 'stopCommunication':
console.info("Communication ended by remote peer");
stop(true);
break;
case 'playResponse':
playResponse(parsedMessage);
break;
case 'playEnd':
stop();
break;
default:
console.error('Unrecognized message', parsedMessage);
}
}
116
Chapter 9. Tutorial 5 - WebRTC one-to-one video call with recording and filtering
Kurento Documentation, Release 5.0.5
function incomingCall(message) {
//If bussy just reject without disturbing user
if (callState != NO_CALL) {
var response = {
id : 'incomingCallResponse',
from : message.from,
callResponse : 'reject',
message : 'bussy'
};
return sendMessage(response);
}
setCallState(PROCESSING_CALL);
if (confirm('User ' + message.from
+ ' is calling you. Do you accept the call?')) {
showSpinner(videoInput, videoOutput);
webRtcPeer = kurentoUtils.WebRtcPeer.startSendRecv(videoInput, videoOutput,
function(offerSdp) {
var response = {
id : 'incomingCallResponse',
from : message.from,
callResponse : 'accept',
sdpOffer : offerSdp
};
sendMessage(response);
}, function(error) {
setCallState(NO_CALL);
});
} else {
var response = {
id : 'incomingCallResponse',
from : message.from,
callResponse : 'reject',
message : 'user declined'
};
sendMessage(response);
stop();
}
}
function call() {
if (document.getElementById('peer').value == '') {
window.alert("You must specify the peer name");
return;
}
setCallState(PROCESSING_CALL);
showSpinner(videoInput, videoOutput);
webRtcPeer = kurentoUtils.WebRtcPeer.startSendRecv(videoInput, videoOutput,
function(offerSdp) {
console.log('Invoking SDP offer callback function');
var message = {
id : 'call',
from : document.getElementById('name').value,
to : document.getElementById('peer').value,
sdpOffer : offerSdp
};
sendMessage(message);
9.1. Tutorial 5 - Advanced One to one video call
117
Kurento Documentation, Release 5.0.5
}, function(error) {
console.log(error);
setCallState(NO_CALL);
});
}
function play() {
document.getElementById('videoSmall').style.display = 'none';
showSpinner(videoOutput);
webRtcPeer = kurentoUtils.WebRtcPeer.startRecvOnly(videoOutput, function(offerSdp) {
console.log('Invoking SDP offer callback function');
var message = {
id : 'play',
user : document.getElementById('peer').value,
sdpOffer : offerSdp
};
sendMessage(message);
});
}
function stop(message) {
setCallState(NO_CALL);
if (webRtcPeer) {
webRtcPeer.dispose();
webRtcPeer = null;
if (!message) {
var message = {
id : 'stop'
}
sendMessage(message);
}
}
hideSpinner(videoInput, videoOutput);
document.getElementById('videoSmall').style.display = 'block';
}
9.1.5 Dependencies
This Java Spring application is implementad using Maven. The relevant part of the pom.xml is where Kurento dependencies are declared. As the following snippet shows, we need two dependencies: the Kurento Client Java dependency
(kurento-client) and the JavaScript Kurento utility library (kurento-utils) for the client-side:
<dependencies>
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-client</artifactId>
<version>[5.0.0,6.0.0)</version>
</dependency>
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-utils-js</artifactId>
<version>[5.0.0,6.0.0)</version>
</dependency>
</dependencies>
118
Chapter 9. Tutorial 5 - WebRTC one-to-one video call with recording and filtering
Kurento Documentation, Release 5.0.5
Kurento framework uses Semantic Versioning for releases. Notice that range [5.0.0,6.0.0) downloads the latest
version of Kurento artefacts from Maven Central in version 5 (i.e. 5.x.x). Major versions are released when incompatible changes are made.
Note: We are in active development. You can find the latest version of Kurento Java Client at Maven Central.
Kurento Java Client has a minimum requirement of Java 7. To configure the application to use Java 7, we have to
include the following properties in the properties section:
<maven.compiler.target>1.7</maven.compiler.target>
<maven.compiler.source>1.7</maven.compiler.source>
9.1. Tutorial 5 - Advanced One to one video call
119
Kurento Documentation, Release 5.0.5
120
Chapter 9. Tutorial 5 - WebRTC one-to-one video call with recording and filtering
Part V
Mastering Kurento
121
CHAPTER 10
Kurento Architecture
10.1 Kurento Architecture
Kurento, as most multimedia communication technologies out there, is built using two layers (called planes) to abstract
key functions in all interactive communication systems:
• Signaling Plane. The parts of the system in charge of the management of communications, that is, the modules
that provides functions for media negotiation, QoS parametrization, call establishment, user registration, user
presence, etc. are conceived as forming part of the Signaling Plane.
• Media Plane Functionalities such as media transport, media encoding/decoding and media processing make the
Media Plane, which takes care of the handling of media. The distinction comes from the telephony differentiation between the handling of voice and the handling of meta-information such as tone, billing, etc.
The following figure shows a conceptual representation of the high level architecture of Kurento.
Figure 10.1: Kurento Architecture. Kurento architecture follows the traditional separation between signaling and
media planes.
123
Kurento Documentation, Release 5.0.5
The right side of the picture shows the application, which is in charge of the signaling plane and contains the business
logic and connectors of the particular multimedia application being deployed. It can be build with any programming
technology like Java, Node.js, PHP, Ruby, .NET, etc. The application can use mature technologies such as HTTP and
SIP Servlets, Web Services, database connectors, messaging services, etc. Thanks to this, this plane provides access
to the multimedia signaling protocols commonly used by end-clients such as SIP, RESTful and raw HTTP based
formats, SOAP, RMI, CORBA or JMS. These signaling protocols are used by client side of applications to command
the creation of media sessions and to negotiate their desired characteristics on their behalf. Hence, this is the part of
the architecture, which is in contact with application developers and, for this reason, it needs to be designed pursuing
simplicity and flexibility.
On the left side, we have the Kurento Media Server, which implements the media plane capabilities providing access
to the low-level media features: media transport, media encoding/decoding, media transcoding, media mixing, media
processing, etc. The Kurento Media Server must be capable of managing the multimedia streams with minimal latency
and maximum throughput. Hence the Kurento Media Server must be optimized for efficiency.
10.1.1 Kurento APIs and interfaces
The capabilities of the media plane (Kurento Media Server) and signaling plane (Application) are exposed through a
number of APIs, which provide increasing abstraction levels.
Following this, the role of the different APIs can be summarized in the following way:
• Kurento Protocol: Is a network protocol exposing the Kurento Media Server capabilities through WebSocket
(read more in Kurento Protocol section).
• Kurento API: Is the object oriented view of the Kurento Protocol. This API makes possible the creation and
management of media elements and pipelines by using references (ids). Accessing the Kurento API is possible
from any of the computer languages and frameworks implementing Kurento Protocol. (read more in Kurento
API section)
• Kurento Java Client: Is a Java SE layer which consumes the Kurento API and exposes its capabilities through
a simple-to-use modularity based on Java POJOs representing media elements and media pipelines. This API
is abstract in the sense that all the non-intuitive inherent complexities of the internal Kurento Protocol workings
are abstracted and developers do not need to deal with them when creating applications. Using the Kurento Java
Client only requires adding the appropriate dependency to a maven project or to download the corresponding jar
into the application developer CLASSPATH. It is important to remark that the Kurento Java Client is a mediaplane control API. In other words, its objective is to expose the capability of managing media objects, but it does
not provide any signaling plane capabilities.
• Kurento JavaScript Client: Is a JavaScript layer which consumes the Kurento API and exposes its capabilities
to JavaScript developers. It allow to build node.js and browser based applications. In the future, further Kurento
Clients can be created exposing the same kind of modularity in other languages such as Python, C/C++, PHP,
etc.
From an architectural perspective, the only relevant aspect is that application developers can use Kurento Clients or
Kurento API directly for creating their multimedia enabled applications. This opens a wide spectrum of potential usage
scenarios ranging from web applications (written using the Kurento JavaScript client), desktop applications (written
using the Kurento Java Client), distibuted applications (writen using Kurento Protocol, etc.).
10.1.2 Kurento Modules
Kurento has been designed as a pluggable framework. Kurento Media Server uses several modules by default,
named kms-core, kms-elements and kms-filters. In addition, there are others built-in modules to enhance the capabilities provided by the Kurento Media Server. These modules are called kms-crowddetector,
kms-pointerdetector, kms-chroma, and kms-platedetector. Finally Kurento Media Server can be
expanded with new custom modules.
124
Chapter 10. Kurento Architecture
Kurento Documentation, Release 5.0.5
Kurento modules architecture. Kurento Media Server can be extended with built-it modules (crowddetector, pointerdetector, chroma, platedetector) and also with other custom modules.
For further details please visit the Kurento Modules page.
10.1.3 Creating applications with Kurento
Kurento can be used following the architectural principles of the WWW. That is, creating a multimedia applications
basing on it can be a similar experience to creating a web application using any of the popular web development
frameworks.
At the highest abstraction level, web applications have an architecture comprised of three different layers:
• Presentation layer (client side): Here we can find all the application code which is in charge of interacting
with end users so that information is represented in a comprehensive way user input is captured. This usually
consists on HTML pages.
• Application logic (server side): This layer is in charge of implementing the specific functions executed by the
application.
• Service layer (server or Internet side): This layer provides capabilities used by the application logic such as
databases, communications, security, etc. This services can be hosted in the same server as application logic or
can be provided by external parties.
Following this parallelism, multimedia applications created using Kurento can also be implemented with the same
architecture:
• Presentation layer (client side): Is in charge of multimedia representation and multimedia capture. It is usually
based on specific build-in capabilities of the client. For example, when creating a browser-based application,
the presentation layer will use capabilities such as the <video> HTML tag or the WebRTC JavaScript APIs.
10.1. Kurento Architecture
125
Kurento Documentation, Release 5.0.5
• Application logic: This layer provides the specific multimedia logic. In other words, this layer is in charge of
building the appropriate pipeline (by chaining the desired media elements) that the multimedia flows involved
in the application will need to traverse.
• Service layer: This layer provides the multimedia services that support the application logic such as media
recording, media ciphering, etc. The Kurento Media Server (i.e. the specific pipeline of media elements) is in
charge of this layer.
The interesting aspect of this discussion is that, as happens with WWW development, Kurento applications can place
the Presentation layer at the client side and the Service layer at the server side. However, the Application Logic layer,
in both cases, can be located at either of the sides or even distributed between them. This idea is represented in the
following picture:
Layered architecture of web and multimedia applications. Applications created using Kurento (right) can be similar to
standard WWW applications (left). Both types of applications may choose to place the application logic at the client
or at the server code.
This means that Kurento developers can choose to include the code creating the specific media pipeline required by
their applications at the client side (using a suitable Kurento Client or directly with Kurento Protocol) or can place it
at the server side.
Both options are valid but each of them drives to different development styles. Having said this, it is important to
note that in the WWW developers usually tend to maintain client side code as simple as possible, bringing most of
their application logic to the server. Reproducing this kind of development experience is the most usual way of using
Kurento. That is, by locating the multimedia application logic at the server side, so that the specific media pipelines
are created using the Kurento Client for your favorite language.
Note: In the following sections it is considered that all Kurento handling is done at the server side. Although this
is the most common way of using Kurento, is important to note that all multimedia logic can be implemented at the
client with Kurento JavaScript Client.
10.1.4 Communicating client, server and Kurento
As can be observed in Figure above, a Kurento application involves interactions among three main modules:
• Client Application: which involves the native multimedia capabilities of the client platform plus the specific
client-side application logic. It can use Kurento Clients designed to client platforms (for example, Kurento
JavaScript Client).
• Application Server: which involves an application server and the server-side application logic. It can use
Kurento Clients designed to server platforms (for example, Kurento Java Client for Java EE and Kurento
JavaScript Client for Node.js).
• Kurento Media Server: which receives commands for creating specific multimedia capabilities (i.e. specific
pipelines adapted to the needs of specific applications)
The interactions maintained among these modules depend on the specificities of each application. However, in general,
for most applications they can be reduced to the following conceptual scheme:
126
Chapter 10. Kurento Architecture
Kurento Documentation, Release 5.0.5
Main interactions between architectural modules. Main interactions occur in two phases: negotiation and media
exchange. Remark that the color of the different arrows and boxes is aligned with the architectural figures presented
above, so that, for example, orange arrows show exchanges belonging to the signaling plane, blue arrows show
exchanges belonging to the Kurento Protocol, red boxes are associated to the Kurento Media Server and green boxes
with the application.
1. Media negotiation phase (signaling)
As it can be observed, at a first stage, a client (a browser in a computer, a mobile application, etc.) issues a message to
the application requesting some kind of multimedia capability. This message can be implemented with any protocol
(http, websockets, SIP, etc.). For instance, that request could ask for the visualization of a given video clip.
When the application receives the request, if appropriate, it will carry out the specific server side application logic,
which can include Authentication, Authorization and Accounting (AAA), CDR generation, consuming some type of
web service, etc.
After that, the application processes the request and, according to the specific instructions programmed by the developer, commands Kurento Media Server to instantiate the suitable media elements and to chain them in an appropriate
media pipeline. Once the pipeline has been created successfully, kurento Media server responds accordingly and the
application forwards the successful response to the client, showing it how and where the media service can be reached.
During the above mentioned steps no media data is really exchanged. All the interactions have the objective of
negotiating the whats, hows, wheres and whens of the media exchange. For this reason, we call it the negotiation
phase. Clearly, during this phase only signaling protocols are involved.
2. Media exchange phase
After that, a new phase starts devoted to producing the actual media exchange. The client addresses a request for the
media to the Kurento Media Server using the information gathered during the negotiation phase. Following with the
video-clip visualization example mentioned above, the browser will send a GET request to the IP address and port of
the Kurento Media Server where the clip can be obtained and, as a result, an HTTP reponse with the media will be
received.
Following the discussion with that simple example, one may wonder why such a complex scheme for just playing a
video, when in most usual scenarios clients just send the request to the appropriate URL of the video without requiring
any negotiation. The answer is straightforward. Kurento is designed for media applications involving complex media
processing. For this reason, we need to establish a two-phase mechanism enabling a negotiation before the media
exchange. The price to pay is that simple applications, such as one just downloading a video, also need to get through
these phases. However, the advantage is that when creating more advanced services the same simple philosophy will
hold. For example, if we want to add augmented reality or computer vision features to that video-clip, we just need to
create the appropriate pipeline holding the desired media element during the negotiation phase. After that, from the
client perspective, the processed clip will be received as any other video.
10.1. Kurento Architecture
127
Kurento Documentation, Release 5.0.5
10.1.5 Real time WebRTC applications with Kurento
Kurento allows the establishment of real time multimedia session between a browser and the Kurento Media Server
directly through the use of WebRTC. In addition, Kurento Media Server can be used to act as media proxy for making
possible the communication among different clients, which are mediated by the kurento infrastructure. Hence, Kurento
Media Server can act as a conference bridge (Multi-Conference Unit, MCU), as a machine-to-machine communication
system, as a video call recording system, etc.
As shown in the picture, the client exposes its media capabilities through an SDP (Session Description Protocol) sent in
a request. Hence, the application is able to instantiate the appropriate WebRTC endpoint, and to require it to generate a
response SDP based on its own capabilities and on the offered SDP. When the answer SDP is obtained, it is given back
to the client and the media exchange can be started. The interactions among the different modules are summarized in
the following picture
Main interactions in a WebRTC session. Interactions taking place in a Real Time Communications (RTC) session.
During the negotiation phase, a Session Description Protocol (SDP) message is exchanged offering the capabilities of
the client. As a result, Kurento Media Server generates an SDP answer that can be used by the client for extablishing
the media exchange.
The application developer is able to create the desired pipeline during the negotiation phase, so that the real time
multimedia stream is processed accordingly to the application needs. Just as an example, imagine that we want to
create a WebRTC application recording the media received from the client and augmenting it so that if a human face is
found, a hat will be rendered on top of it. This pipeline is schematically shown in the figure below, where we assume
that the Filter element is capable of detecting the face and adding the hat to it.
Example pipeline for a WebRTC session. During the negotiation phase, the application developer can create a pipeline
providing the desired specific functionality. For example, this pipeline uses a WebRtcEndpoint for communicating with
the client, which is connected to a RecorderEndpoint storing the received media streamd and to an augmented reality
filter, which feeds its output media stream back to the client. As a result, the end user will receive its own image filtered
(e.g. with a hat added onto her head) and the stream will be recorded and made available for further recovery into a
repository (e.g. a file).
10.1.6 Kurento Design Principles
Kurento is designed based on the following main principles:
Separate Media and Signaling Planes Signaling and Media are two separate planes and Kurento is designed so that applications can handle separately those facets of multimedia processing.
128
Chapter 10. Kurento Architecture
Kurento Documentation, Release 5.0.5
Distribution of Media and Application Services Kurento Media Server and applications can be collocated, scalated or distributed among different machines.
A single application can invoke the services of more than one Kurento Media Server. The opposite
also applies, that is, a Kurento Media Server can attend the requests of more than one application.
Suitable for the Cloud Kurento is suitable to be integrated into cloud environments to act as a PaaS
(Platform as a Service) component.
Media Pipelines Chaining Media Elements via Media Pipelines is an intuitive approach to challenge the
complexity of multimedia processing.
Application development Developers do not need to be aware of internal Kurento Media Server complexities, all the applications can deployed in any technology or framework the developer like, from
client to server. From browsers to cloud services.
End-to-end Communication Capability Kurento provides end-to-end communication capabilities so
developers do not need to deal with the complexity of transporting, encoding/decoding and rendering media on client devices.
Fully Processable Media Streams Kurento enables not only interactive interpersonal communications
(e.g. Skype-like with conversational call push/reception capabilities), but also human-to-machine
(e.g. Video on Demand through real-time streaming) and machine-to-machine (e.g. remote video
recording, multisensory data exchange) communications.
Modular Processing of Media Modularization achieved through media elements and pipelines allows
defining the media processing functionality of an application through a “graph-oriented” language,
where the application developer is able to create the desired logic by chaining the appropriate functionalities.
Auditable Processing Kurento is able to generate rich and detailed information for QoS monitoring,
billing and auditing.
Seamless IMS integration Kurento is designed to support seamless integration into the IMS infrastructure of Telephony Carriers.
Transparent Media Adaptation Layer Kurento provides a transparent media adaptation layer to make
the convergence among different devices having different requirements in terms of screen size,
power consumption, transmission rate, etc. possible.
10.1. Kurento Architecture
129
Kurento Documentation, Release 5.0.5
130
Chapter 10. Kurento Architecture
CHAPTER 11
Kurento API Reference
11.1 Kurento API Reference
Kurento Media Server exposes an API to high level languages that allow application programmers to control it.
This high level API can be used with a Kurento Client for Java or JavaScript. If you prefer another programming
language, you can use the Kurento Protocol, based on WebSocket and JSON-RPC.
In the following sections we will describe the Kurento API in a high level way. We will show the media capabilities
exposed by Kurento Media Server to clients. If you want see working demos using Kurento, please refer to Tutorials
section.
11.1.1 Media elements and media pipelines
Kurento is based on two concepts that act as building blocks for application developers:
• Media Elements. A Media element is a functional unit performing a specific action on a media stream. Media
elements are a way of every capability is represented as a self-contained “black box” (the media element) to the
application developer, who does not need to understand the low-level details of the element for using it. Media
elements are capable of receiving media from other elements (through media sources) and of sending media to
other elements (through media sinks). Depending on their function, media elements can be split into different
groups:
– Input Endpoints: Media elements capable of receiving media and injecting it into a pipeline. There are
several types of input endpoints. File input endpoints take the media from a file, Network input endpoints
take the media from the network, and Capture input endpoints are capable of capturing the media stream
directly from a camera or other kind of hardware resource.
– Filters: Media elements in charge of transforming or analyzing media. Hence there are filters for performing operations such as mixing, muxing, analyzing, augmenting, etc.
– Hubs: Media Objects in charge of managing multiple media flows in a pipeline. A Hub has several hub
ports where other media elements are connected. Depending on the Hub type, there are different ways to
control the media. For example, there are a Hub called Composite that merge all input video streams in a
unique output video stream with all inputs in a grid.
– Output Endpoints: Media elements capable of taking a media stream out of the pipeline. Again, there
are several types of output endpoints specialized in files, network, screen, etc.
• Media Pipeline: A Media Pipeline is a chain of media elements, where the output stream generated by one
element (source) is fed into one or more other elements input streams (sinks). Hence, the pipeline represents a
“machine” capable of performing a sequence of operations over a stream.
131
Kurento Documentation, Release 5.0.5
Kurento API is an object oriented API. That is, there are classes that can be instantiated. This classes define operations
that can be invoked over objects of this classes. The classes can have an inheritance relationship with other classes,
inheriting operations from parent classes to children ones.
The following class diagram shows some of the relationships of the main classes in the Kurento API.
Figure 11.1: Class diagram of main classes in Kurento API
MediaObject
+ getMediaPipeline() : MediaPipeline
+ getParent() : MediaObject[]
parent
pipeline
MediaElement
+ connect(...) : void
+ getMediaS inks (...) : MediaS ink[]
+ getMediaS rcs (...) : MediaS ource[]
* elements
MediaPipeline
Hub
*
Endpoint
Filter
HubPort
11.1.2 Endpoints
Let us discuss briefly the different Endpoints offered by kurento.
An HttpGetEndpoint is an output endpoint that delivers media using HTML5 pseudo-streaming mechanism by means
of http GET requests.
An HttpPostEndpoint is an input endpoint that accepts media using http POST requests like HTTP file upload function.
132
Chapter 11. Kurento API Reference
Kurento Documentation, Release 5.0.5
A PlayerEndpoint is an input endpoint that retrieves content from file system, http URL or RTSP url and inject it into
the media pipeline.
A RecorderEndpoint is an output endpoint that provides function to store contents in reliable mode (doesn’t discard
data). It contains Media Sink pads for audio and video.
A RtpEndpoint is an output and input endpoint. That is, provides bidirectional content delivery capabilities with
remote networked peers through RTP protocol. As you can imagine, to send and receive media through the network it
uses RTP protocol and SDP for media negotiation.
A WebRtcEndpoint is an output and input endpoint that provides media streaming for Real Time Communications
(RTC) through the web. It implements WebRTC technology to communicate with browsers.
The following class diagram shows the relationships of the main endpoint classes.
11.1.3 Filters
Filters are MediaElements that perform media processing, computer vision, augmented reality, and so on. Let see the
available filters in Kurento:
The ZBarFilter filter detects QR and bar codes in a video stream. When a code is found, the filter raises a
CodeFoundEvent. Clients can add a listener to this event to execute some action.
The FaceOverlayFilter filter detects faces in a video stream and overlaid it with a configurable image.
11.1. Kurento API Reference
133
Kurento Documentation, Release 5.0.5
Figure 11.2: Class diagram of Endpoints in Kurento API
MediaElement
Endpoint
HttpGetEndpoint
S es s ionEndpoint
UriEndpoint
HttpEndpoint
S dpEndpoint
PlayerEndpoint
HttpPos tEndpoint
RtpEndpoint
WebRtcEndpoint
RecorderEndpoint
GStreamerFilter is a generic filter interface that allow use GStreamer filter in Kurento Media Pipelines.
The following class diagram shows the relationships of the main filter classes.
11.1.4 Hubs
Hubs are media objects in charge of managing multiple media flows in a pipeline. A Hub has several hub ports where
other media elements are connected. Let’s see the available hubs in Kurento:
Composite is a hub that mixes the audio stream of its connected inputs and constructs a grid with the video streams
134
Chapter 11. Kurento API Reference
Kurento Documentation, Release 5.0.5
Figure 11.3: Class diagram of Filters in Kurento API
MediaElement
Filter
Z BarFilter
FaceOverlayFilter
GS treamerFilter
of them.
DispatcherOneToMany is a Hub that sends a given input to all the connected output HubPorts.
Dispatcher is a hub that allows routing between arbitrary input-output HubPort pairs.
The following class diagram shows the relationships of the hubs.
You see the details of the Kurento Clients see the JavaDoc/JsDoc:
• kurento-client-java : JavaDoc of Kurento Java Client.
11.1. Kurento API Reference
135
Kurento Documentation, Release 5.0.5
Figure 11.4: Class diagram of Hubs in Kurento API
MediaObject
MediaElement
Hub
*
HubPort
Compos ite
Dis patcher
Dis patcherOneToMany
• kurento-client-js : JsDoc of Kurento JavaScript Client.
• kurento-utils-js : JsDoc of an utility JavaScript library aimed to simplify the development of WebRTC applications.
136
Chapter 11. Kurento API Reference
CHAPTER 12
Kurento Protocol
12.1 Kurento Protocol
Kurento Protocol is the Kurento Media Server protocol based on WebSocket that uses JSON-RPC V2.0 messages for
making requests and sending responses.
12.1.1 JSON-RPC Messages format
Kurento Protocol uses JSON-RPC V2.0 to code its messages. In the following subsections we will show how this
format code the messages in JSON.
Request object
An RPC call is represented by sending a Request object to a server. The Request object has the following members:
• jsonrpc: a string specifying the version of the JSON-RPC protocol. It must be exactly “2.0”.
• id: an identifier established by the client that contains a string or number. The server must reply with the same
value in the Response object. This member is used to correlate the context between both objects.
• method: a string containing the name of the method to be invoked.
• params: a structured value that holds the parameter values to be used during the invocation of the method.
The following JSON shows a sample requests:
{
"jsonrpc": "2.0",
"id": 1,
"method": "create",
"params": {
"type": "PlayerEndPoint",
"creationParams": {
"pipeline": "6829986",
"uri": "http://host/app/video.mp4"
},
"sessionId": "c93e5bf0-4fd0-4888-9411-765ff5d89b93"
}
}
137
Kurento Documentation, Release 5.0.5
Successful Response object
When an RPC call is made the server replies with a Response object. In the case of a successful response, the Response
object will contain the following members:
• jsonrpc: a string specifying the version of the JSON-RPC protocol. It must be exactly “2.0”.
• id: this member is mandatory and it must match the value of the id member in the Request object.
• result: its value is determined by the method invoked on the server. In case the connection is rejected, it’s
returned an object with a rejected attribute containing an object with a code and message attributes with the
reason why the session was not accepted, and no sessionId is defined.
The following example shows a typical successful response:
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"value": "442352747",
"sessionId": "c93e5bf0-4fd0-4888-9411-765ff5d89b93"
}
}
Error Response object
When an RPC call is made the server replies with a Response object. In the case of an error response, the Response
object will contain the following members:
• jsonrpc: a string specifying the version of the JSON-RPC protocol. It must be exactly “2.0”.
• id: this member is mandatory and it must match the value of the id member in the Request object. If there was
an error in detecting the id in the Request object (e.g. Parse Error/Invalid Request), it equals to null.
• error: an object describing the error through the following members:
– code: an integer number that indicates the error type that occurred.
– message: a string providing a short description of the error.
– data: a primitive or structured value that contains additional information about the error. It may be omitted.
The value of this member is defined by the server.
The following example shows a typical error response:
{
"jsonrpc": "2.0",
"id": 1,
"error": {
"code": "33",
"message": "Invalid paramter format"
}
}
12.1.2 Kurento API over JSON-RPC
As explained in Kurento API section, Kurento Media Server exposes a full fledged API to let applications to process
media in several ways.
138
Chapter 12. Kurento Protocol
Kurento Documentation, Release 5.0.5
To allow this rich API, Kurento Clients require requires full-duplex communications between client and server infrastructure. For this reason, the Kurento Protocol is based on WebSocket transports.
Previous to issuing commands, the Kurento Client requires establishing a WebSocket connection with Kurento Media
Server to the URL: ws://hostname:port/kurento
Once the WebSocket has been established, the Kurento Protocol offers five different types of request/response messages:
• create: Instantiates a new media object, that is, a pipeline or media element.
• invoke: Calls a method of an existing media object.
• subscribe: Creates a subscription to an event in a object.
• unsubscribe: Removes an existing subscription to an event.
• release: Deletes the object and release resources used by it.
The Kurento Protocol allows to Kurento Media Server send requests to clients:
• onEvent: This request is sent from kurento Media server to clients when an event occurs.
Create messages
Create message requests the creation of an object of the Kurento API. The parameter type specifies the type of the
object to be created. The parameter creationParams contains all the information needed to create the object.
Each object type needs different creationParams to create the object. These parameters are defined in Kurento
API section.
Finally, a sessionId parameter is included with the identifier of the current session. The value of this parameter is
sent by Kurento Media Server to the client in each response. Only the first request from client to server is allowed to
not include the ‘’sessionId” (because at this point is unknown for the client).
The following example shows a Request object requesting the creation of an object of the type PlayerEndpoint
within the pipeline 6829986 and the parameter uri: http://host/app/video.mp4 in the session
c93e5bf0-4fd0-4888-9411-765ff5d89b93:
{
"jsonrpc": "2.0",
"id": 1,
"method": "create",
"params": {
"type": "PlayerEndPoint",
"creationParams": {
"pipeline": "6829986",
"uri": "http://host/app/video.mp4"
},
"sessionId": "c93e5bf0-4fd0-4888-9411-765ff5d89b93"
}
}
The Response object contains the id of the new object in the field value. This object id has to be used in other
requests of the protocol (as we will describe later). As stated before, the sessionId is also returned in each response.
The following example shows a typical response to a create message:
{
"jsonrpc": "2.0",
"id": 1,
"result": {
12.1. Kurento Protocol
139
Kurento Documentation, Release 5.0.5
"value": "442352747",
"sessionId": "c93e5bf0-4fd0-4888-9411-765ff5d89b93"
}
}
Invoke messages
Invoke message requests the invocation of an operation in the specified object. The parameter object indicates the
id of the object in which the operation will be invoked. The parameter operation carries the name of the operation
to be executed. Finally, the parameter operationParams has the parameters needed to execute the operation. The
object specified has to understand the operation name and parameters. In the Kurento API section is described the
valid operations for all object types.
The following example shows a Request object requesting the invocation of the operation connect on the object
442352747 with parameter sink 6829986. The sessionId is also included as is mandatory for all requests in
the session (except the first one):
{
"jsonrpc": "2.0",
"id": 2,
"method": "invoke",
"params": {
"object": "442352747", "operation": "connect",
"operationParams": {
"sink": "6829986"
},
"sessionId": "c93e5bf0-4fd0-4888-9411-765ff5d89b93"
}
}
The Response object contains the value returned while executing the operation invoked in the object or nothing
if the operation doesn’t return any value.
The following example shows a typical response while invoking the operation connect (that doesn’t return anything):
{
"jsonrpc": "2.0",
"result": {
"sessionId": "c93e5bf0-4fd0-4888-9411-765ff5d89b93"
},
"id": 2
}
Release messages
Release message requests the release of the specified object. The parameter object indicates the id of the object to
be released:
{
"jsonrpc": "2.0",
"id": 3,
"method": "release",
"params": {
"object": "442352747",
"sessionId": "c93e5bf0-4fd0-4888-9411-765ff5d89b93"
140
Chapter 12. Kurento Protocol
Kurento Documentation, Release 5.0.5
}
}
The Response object only contains the sessionID. The following example shows the typical response of a release
request:
{
"jsonrpc":"2.0",
"id":3,
"result": {
"sessionId":"c93e5bf0-4fd0-4888-9411-765ff5d89b93"
}
}
Subscribe messages
Subscribe message requests the subscription to a certain kind of events in the specified object. The parameter object
indicates the id of the object to subscribe for events. The parameter type specifies the type of the events. If a client
is subscribed for a certain type of events in an object, each time an event is fired in this object, a request with method
onEvent is sent from kurento Media Server to the client. This kind of request is described few sections later.
The following example shows a Request object requesting the subscription of the event type EndOfStream on the
object 311861480. The sessionId is also included:
{
"jsonrpc":"2.0",
"id":4,
"method":"subscribe",
"params":{
"object":"311861480",
"type":"EndOfStream",
"sessionId":"c93e5bf0-4fd0-4888-9411-765ff5d89b93"
}
}
The Response object contains the subscription identifier. This value can be used later to remove this subscription.
The following example shows the response of subscription request. The value attribute contains the subscription id:
{
"jsonrpc":"2.0",
"id":4,
"result": {
"value":"353be312-b7f1-4768-9117-5c2f5a087429",
"sessionId":"c93e5bf0-4fd0-4888-9411-765ff5d89b93"
}
}
Unsubscribe messages
Unsubscribe message requests the cancellation of a previous event subscription. The parameter subscription contains
the subscription id received from the server when the subscription was created.
The following example shows a Request object requesting the cancellation of the subscription
353be312-b7f1-4768-9117-5c2f5a087429:
12.1. Kurento Protocol
141
Kurento Documentation, Release 5.0.5
{
"jsonrpc":"2.0",
"id":5,
"method":"unsubscribe",
"params": {
"subscription":"353be312-b7f1-4768-9117-5c2f5a087429",
"sessionId":"c93e5bf0-4fd0-4888-9411-765ff5d89b93"
}
}
The Response object only contains the sessionID. The following example shows the typical response of an
unsubscription request:
{
"jsonrpc":"2.0",
"id":5,
"result": {
"sessionId":"c93e5bf0-4fd0-4888-9411-765ff5d89b93"
}
}
OnEvent Message
When a client is subscribed to a type of events in an object, the server send an onEvent request each time an event
of that type is fired in the object. This is possible because the Kurento Protocol is implemented with websockets and
there is a full duplex channel between client and server. The request that server send to client has all the information
about the event:
• data: Information about this specific of this type of event.
• source: the object source of the event.
• type: The type of the event.
• subscription: subscription id for which the event is fired.
The following example shows a notification sent for server to client to notify an event of type EndOfStream in the
object 311861480 with subscription 353be312-b7f1-4768-9117-5c2f5a087429:
{
"jsonrpc": "2.0",
"id": 6,
"method": "onEvent",
"params": {
"value": {
"data":{
"source":"311861480",
"type":"EndOfStream"
},
"object":"311861480",
"subscription":"353be312-b7f1-4768-9117-5c2f5a087429",
"type":"EndOfStream",
},
"sessionId":"4f5255d5-5695-4e1c-aa2b-722e82db5260"
}
}
The Response object does not contain any information. Is only a form of acknowledge message. The following
example shows the typical response of an onEvent request:
142
Chapter 12. Kurento Protocol
Kurento Documentation, Release 5.0.5
{
"jsonrpc":"2.0",
"id":6,
"result": ""
}
12.1. Kurento Protocol
143
Kurento Documentation, Release 5.0.5
144
Chapter 12. Kurento Protocol
CHAPTER 13
Advanced Installation Guide
13.1 Kurento Media Server Advanced Installation guide
13.1.1 Kurento Media Server Configuration
The KMS configuration file is located in /etc/kurento/kurento.conf.json. After a fresh installation this
file is the following:
{
"mediaServer" : {
"net" : {
// Uncomment just one of them
/*
"rabbitmq": {
"address" : "127.0.0.1",
"port" : 5672,
"username" : "guest",
"password" : "guest",
"vhost" : "/"
}
*/
"websocket": {
"port": 8888,
//"secure": {
// "port": 8433,
// "certificate": "defaultCertificate.pem",
// "password": ""
//},
"path": "kurento",
"threads": 10
}
}
},
"modules": {
"kurento": {
"SdpEndpoint" : {
"sdpPattern" : "sdp_pattern.txt"
},
"HttpEndpoint" : {
// "serverAddress" : "localhost",
/*
Announced IP Addess may be helpful under situations such as the server needs
145
Kurento Documentation, Release 5.0.5
to provide URLs to clients whose host name is different from the one the
server is listening in. If this option is not provided, http server will try
to look for any available address in your system.
*/
// "announcedAddress" : "localhost"
},
"WebRtcEndpoint" : {
// "stunServerAddress" : "stun ip address",
// "stunServerPort" : 3478,
// turnURL gives the necessary info to configure TURN for WebRTC.
//
'address' must be an IP (not a domain).
//
'transport' is optional (UDP by default).
// "turnURL" : "user:[email protected]:port(?transport=[udp|tcp|tls])",
// "pemCertificate" : "file"
},
"PlumberEndpoint" : {
// "bindAddress" : "localhost",
/*
Announced IP Address may be helpful under situations such as the endpoint needs
to provide an IP address to clients whose host name is different from the one
that the element is listening in. If this option is not provided, the bindAddress
will be used instead.
*/
// "announcedAddress" : "localhost"
}
}
//"module1": { .... }
//"module2": { .... }
}
}
13.1.2 Kurento Media Server behind a NAT
KMS can be installed on a private network behind a router with NAT. The picture below shows the typical scenario.
Figure 13.1: Typical scenario of Kurento Media Server behind a NAT
In this case, KMS should announce the router public IP in order to be reachable from the outside. In the example
example, sections HttpEndpoint and PlumberEndpoint within /etc/kurento/kurento.conf.json
should be configured as follows:
146
Chapter 13. Advanced Installation Guide
Kurento Documentation, Release 5.0.5
{
"mediaServer" : {
"net" : {
// Uncomment just one of them
/*
"rabbitmq": {
"address" : "127.0.0.1",
"port" : 5672,
"username" : "guest",
"password" : "guest",
"vhost" : "/"
}
*/
"websocket": {
"port": 8888,
//"secure": {
// "port": 8433,
// "certificate": "defaultCertificate.pem",
// "password": ""
//},
"path": "kurento",
"threads": 10
}
}
},
"modules": {
"kurento": {
"SdpEndpoint" : {
"sdpPattern" : "sdp_pattern.txt"
},
"HttpEndpoint" : {
// "serverAddress" : "localhost",
/*
Announced IP Addess may be helpful under situations such as the server needs
to provide URLs to clients whose host name is different from the one the
server is listening in. If this option is not provided, http server will try
to look for any available address in your system.
/
*
"announcedAddress" : "130.206.82.56"
},
"WebRtcEndpoint" : {
// "stunServerAddress" : "stun ip address",
// "stunServerPort" : 3478,
// turnURL gives the necessary info to configure TURN for WebRTC.
//
'address' must be an IP (not a domain).
//
'transport' is optional (UDP by default).
// "turnURL" : "user:[email protected]:port(?transport=[udp|tcp|tls])",
// "pemCertificate" : "file"
},
"PlumberEndpoint" : {
// "bindAddress" : "localhost",
/*
Announced IP Address may be helpful under situations such as the endpoint needs
to provide an IP address to clients whose host name is different from the one
that the element is listening in. If this option is not provided, the bindAddress
will be used instead.
/
*
"announcedAddress" : "130.206.82.56"
13.1. Kurento Media Server Advanced Installation guide
147
Kurento Documentation, Release 5.0.5
}
}
//"module1": { .... }
//"module2": { .... }
}
}
13.1.3 Verifying Kurento Media Server installation
Kurento Media Server Process
To verify that KMS is up and running use the command:
ps -ef | grep kurento
The output should include the kurento-media-server process:
nobody
1270
1
0 08:52 ?
00:01:00 /usr/bin/kurento-media-server
WebSocket Port
Unless configured otherwise, KMS will open the port 8888 to receive requests and send responses to/from by means
of the Kurento Protocol. To verify if this port is listening execute the following command:
sudo netstat -putan | grep kurento
The output should be similar to the following:
tcp6
0
0 :::8888
:::*
LISTEN
1270/kurento-media-server
Kurento Media Server Log
KMS has a log file located at /var/log/kurento-media-server/media-server.log. You can check it
for example as follows:
tail -f /var/log/kurento-media-server/media-server.log
When KMS starts correctly, this trace is written in the log file:
[time] [0x10b2f880] [info]
148
KurentoMediaServer main.cpp:239 main() Mediaserver started
Chapter 13. Advanced Installation Guide
CHAPTER 14
Working with Nightly Builds
14.1 Working with nightly builds
Kurento is composed by several components. Each component is being developed with very different technologies.
• Kurento Media Server: This is the core component of Kurento. It is implemented using C/C++ and GStreamer
platform.
• Kurento Java Client: This Kurento Client is implemented in Java with Maven and Sprint.
• Kurento JavaScript Client: This Kurento Client is implemented in JavaScript with Node.js and NPM.
In this section, we will see how to use nightly compiled versions of Kurento code base. This is not the recommended
way to use Kurento, but can be useful if you are testing brand new features.
We’ll also explain in detail how Kurento can be built from sources. This is a complex task because Kurento uses
several technologies, although it can be very funny ;)
14.1.1 Using development versions
In this section we are going to explain how to use development versions of Kurento. We build every Kurento component at least once a day as we follow the Continuous Integration principles.
Some components are build nightly, with the code developed that day. Other components are created automatically
when code is merged into source repository.
Using development versions is not the recommended way to use Kurento, but it can be useful to try brand new features.
Warning: You have to use this versions with caution, because them can be broken. Usually they have bugs and
incomplete functionalities. Never use development versions in production.
Kurento Media Server
The development builds of Kurento Media Server are .deb packages hosted in http://ubuntu.kurento.org. You can find
current development version at http://ubuntu.kurento.org/pool/main/k/kurento-media-server/.
To install packages from unstable repository you need to execute:
sudo add-apt-repository ppa:kurento/kurento
sudo apt-add-repository http://ubuntu.kurento.org
wget -O - http://ubuntu.kurento.org/kurento.gpg.key | sudo apt-key add -
149
Kurento Documentation, Release 5.0.5
sudo apt-get update
sudo apt-get install kurento-media-server
As you can imagine, it is not possible to have installed at the same time latest stable version and latest development
version of Kurento Media Server.
Older versions can be manually downloaded from http://ubuntu.kurento.org/repo. Notice dependencies will be downgraded as required by the old package. For example:
sudo dpkg -i kurento_4.2.5-16-g18d9c6~1.gbp18d9c6_i386.deb
sudo apt-get -f install
Kurento Java Client
The development builds of Kurento Java Client Maven artifacts hosted in http://maven.kurento.org.
To use development versions, first you have to add this repository in your Maven installation as a valid snapshot repository. To do this, add following configuration repository to the repositories section to file ~/.m2/settings.xml:
<repositories>
<repository>
<id>kurento-snapshots</id>
<name>Kurento Snapshot Repository</name>
<url>http://maven.kurento.org/archiva/repository/snapshots/</url>
<releases>
<enabled>false</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>kurento-snapshots</id>
<name>Kurento Snapshot Repository</name>
<url>http://maven.kurento.org/archiva/repository/snapshots/</url>
<releases>
<enabled>false</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
</snapshots>
</pluginRepository>
</pluginRepositories>
Then, you have to change the dependency in your application’s pom.xml to point to a development version. There is
no way in Maven to use the latest development version of an artifact. You have to specify the concrete development
version you want to depend on. To know what is the current Kurento Java Client development version, you can take
a look to the internal Kurento Maven repository and search for the latest version. Then, you have to include in your
application’s pom.xml the following dependency:
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-client</artifactId>
<version>latest-version-SNAPSHOT</version>
</dependency>
150
Chapter 14. Working with Nightly Builds
Kurento Documentation, Release 5.0.5
Kurento JavaScript Client
JavaScript is special because in some cases there is no need to build anything. JavaScript is a scripting language
that can execute directly from sources. But in some cases, the code have to be “processed” to be used from client
applications.
Node.js development
If you are using Kurento JavaScript Client from a Node.js application and want to use the latest development version
of this library, you have to change the dependencies section in the application’s package.json. You have to
point directly to the development repository, that is:
"dependencies": {
"kurento-client": "Kurento/kurento-client-js#develop"
}
Browser JavaScript development
If you are using Kurento JavaScript Client from a browser application with Bower and want to use the latest development version of this library, you have to change the dependencies section in the application’s bower.json. You
have to point directly to the development bower repository, that is:
"dependencies": {
"kurento-client": "develop"
"kurento-utils": "develop"
}
Alternatively, if your browser application is pointing directly to JavaScript libraries from HTML resources, then, you
have to change to development URLs:
<script type="text/javascript"
src="http://builds.kurento.org/dev/latest/js/kurento-client.min.js"></script>
14.1. Working with nightly builds
151
Kurento Documentation, Release 5.0.5
152
Chapter 14. Working with Nightly Builds
CHAPTER 15
Kurento Modules
15.1 Kurento Modules
Kurento is a pluggable framework. Each plugin in Kurento is called module. We classify Kurento modules into three
groups, namely:
• Main modules. Incorporated out of the box with Kurento Media Server
– kms-core: Main components of Kurento Media Server.
– kms-elements:
Implementation
PlayerEndpoint, and so on).
of
Kurento
Media
Elements
(WebRtcEndpoint,
– kms-filters: Implementation of Kurento Filters (FaceOverlayFilter, ZBarFilter,
GStreamerFilter).
• Built-in modules. Extra modules developed by the Kurento team to enhance the basic capabilities of Kurento
Media Server. So far, there are four built-in modules, namely:
– kms-pointerdetector: Filter that detects pointers in video streams based on color tracking. The
command to install this module is:
sudo apt-get install kms-pointerdetector
– kms-chroma: Filter that makes transparent a color range in the top layer, revealing another image behind.
sudo apt-get install kms-chroma
– kms-crowddetector: Filter that detects people agglomeration in video streams.
sudo apt-get install kms-crowddetector
– kms-platedetector: Filter that detects vehicle plates in video streams.
sudo apt-get install kms-platedetector
• Custom modules. Extensions to Kurento Media Server which provides new media capabilities. If you are
planning to develop your own custom module, please take a look to the following page:
15.1.1 How to Develop Kurento Modules
You can expand the Kurento Media Server developing your own modules. There are two flavors of Kurento modules:
• Modules based on OpenCV. This kind of modules are recommended if you would like to develop a computer
vision filter.
153
Kurento Documentation, Release 5.0.5
• Modules based on GStreamer. This kind of modules are more powerful but also they are more difficult to
develop. Skills in GStreamer development are necessary.
The starting point to develop a filter is create the filter structure.
For this task, you can use the
kurento-module-scaffold tool. This tool is distributed with the kurento-media-server-dev package. To install this tool run this command in the shell:
sudo apt-get install kurento-media-server-dev
The tool usage is different depending on the chosen flavor:
1. OpenCV module:
kurento-module-scaffold.sh <module_name> <output_directory> opencv_filter
2. Gstreamer module:
kurento-module-scaffold.sh <module_name> <output_directory>
The tool generates the folder tree, all the CmakeLists.txt files necessaries and example files of Kurento module
descriptor files (.kmd). These files describe our modules, the constructor, the methods, the properties, the events and
the complex types defined by the developer.
Once, kmd files are completed we can generate code. The tool kurento-module-creator generates glue code
to server-side. From the root directory:
cd build
cmake ..
The following section details how to create your module depending on the filter type you chose (OpenCV or
GStreamer):
OpenCV module
We have four files in src/server/implementation:
ModuleNameImpl.cpp
ModuleNameImpl.hpp
ModuleNameOpenCVImpl.cpp
ModuleNameOpenCVImpl.hpp
The first two files should not be modified. The last two files will contain the logic of your module. The file
ModuleNameOpenCVImpl.cpp contains functions to deal with the methods and the parameters (you must implement the logic). Also, this file contains a function called process. This function will be called with each new frame,
thus you must implement the logic of your filter inside this function.
GStreamer module
In this case, we have two directories inside the src folder. The gst-plugins folder contains the implementation of your GStreamer element (the kurento-module-scaffold generates a dummy filter). Inside the
server/objects folder you have two files:
ModuleNameImpl.cpp
ModuleNameImpl.hpp
In the file ModuleNameImpl.cpp you have to invoke the methods of your GStreamer element. The module logic
will be implemented in the GStreamer element.
154
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
For both kind of modules
If you need extra compilation dependencies you can add compilation rules to the kurento-module-creator using the
function generate_code in the CmakeLists.txt file in src/server. The following parameters are available:
• MODELS (required): This parameter receives the folders where the models (.kmd files) are located.
• INTERFACE_LIB_EXTRA_SOURCES,
INTERFACE_LIB_EXTRA_HEADERS,
INTERFACE_LIB_EXTRA_INCLUDE_DIRS,
INTERFACE_LIB_EXTRA_LIBRARIES:
These
parameters allow to add additional source code to the static library.
Files included in
INTERFACE_LIB_EXTRA_HEADERS will be installed in the system as headers for this library. All
the parameters accept a list as input.
• SERVER_IMPL_LIB_EXTRA_SOURCES,
SERVER_IMPL_LIB_EXTRA_HEADERS,
SERVER_IMPL_LIB_EXTRA_INCLUDE_DIRS,
SERVER_IMPL_LIB_EXTRA_LIBRARIES:
These parameters allows to add additional source code to the interface library. Files included in
SERVER_IMPL_LIB_EXTRA_HEADERS will be installed in the system as headers for this library. All
the parameters accept a list as input.
• MODULE_EXTRA_INCLUDE_DIRS, MODULE_EXTRA_LIBRARIES: These parameters allows to add extra
include directories and libraries to the module.
• SERVER_IMPL_LIB_FIND_CMAKE_EXTRA_LIBRARIES: This parameter receives a list of strings, each
string has this format libname[ libversion range] (possible ranges can use symbols AND OR < <= >
>= ^ and ~):
^ indicates a version compatible using Semantic Versioning
~ Indicates a version similar, that can change just last indicated version character
• SERVER_STUB_DESTINATION (required): The generated code that you may need to modify will be generated on the folder indicated by this parameter.
Once the module logic is implemented and the compilation process is finished, you need to install your module in your
system. You can follow two different ways:
You
can
generate
the
Debian
package
(debuild -us -uc)
and
install
it
(dpkg -i).
You
can
define
the
following
environment
variables
in
the
file
/etc/default/kurento:
KURENTO_MODULES_PATH=<module_path>/build/src
GST_PLUGIN_PATH=<module_path>/build/src.
Now, you need to generate code for Java or JavaScript to use your module from the client-side.
• For
Java,
from
the
build
directory
you
have
to
execute
cmake ..
-DGENERATE_JAVA_CLIENT_PROJECT=TRUE command generates a Java folder with client code.
You can run make java_install and your module will be installed in your Maven local repository. To use
the module in your Maven project, you have to add the dependency to the pom.xml file:
<dependency>
<groupId>org.kurento.module</groupId>
<artifactId>modulename</artifactId>
<version>moduleversion</version>
</dependency>
• For JavaScript, you should to execute cmake .. -DGENERATE_JS_CLIENT_PROJECT=TRUE. This
command generates a js folder with client code. Now you can add the JavaScript library to use your module in
your application manually. Alternatively, you can use Bower (for JavaScript for browser) or NPM (for JavaScript
for Node.js). To do that, you should add your JavaScript module as a dependency in your bower.json or
package.json file respectively, as follows:
15.1. Kurento Modules
155
Kurento Documentation, Release 5.0.5
"dependencies": {
"modulename": "moduleversion"
}
Examples
Simple examples for both kind of modules are available in GitHub:
• OpenCV module
• GStreamer module
There are a lot of examples of how to define methods, parameters or events in all our public built-in modules:
• kms-pointerdetector
• kms-crowddetector
• kms-chroma
• kms-platedetector
Moreover, all our modules are developed using this methodology, for that reason you can take a look to our main
modules:
• kms-core
• kms-elements
• kms-filters
The following picture shows an schematic view of the Kurento Media Server as described before:
Figure 15.1: Kurento modules architecture. Kurento Media Server can be extended with built-it modules (crowddetector, pointerdetector, chroma, platedetector) and also with other custom modules.
156
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
Taking into account the built-in modules, the Kurento toolbox is extended as follows:
Figure 15.2: Extended Kurento Toolbox. The basic Kurento toolbox (left side of the picture) is extended with more
computer vision and augmented reality filters (right side of the picture) provided by the built-in modules.
The remainder of this page is structured in four sections in which the built-in modules (kms-pointerdetector,
kms-chroma, kms-crowddetector, kms-platedetector) are used to develop simple applications (tutorials) aimed to show how to use them.
15.1.2 Module Tutorial 1 - Pointer Detector Filter
This web application consists on a WebRTC video communication in mirror (loopback) with a pointer tracking filter
element.
Java Module Tutorial 1 - Pointer Detector Filter
This web application consists on a WebRTC video communication in mirror (loopback) with a pointer tracking filter
element.
For the impatient: running this example
First of all, you should install Kurento Media Server to run this demo. Please visit the installation guide for further
information. In addition, the built-in module kms-pointerdetector should be also installed:
sudo apt-get install kms-pointerdetector
15.1. Kurento Modules
157
Kurento Documentation, Release 5.0.5
To launch the application you need to clone the GitHub project where this demo is hosted and then run the main class,
as follows:
git clone https://github.com/Kurento/kurento-tutorial-java.git
cd kurento-tutorial-java/kurento-pointerdetector
mvn compile exec:java
The web application starts on port 8080 in the localhost by default. Therefore, open the URL http://localhost:8080/ in
a WebRTC compliant browser (Chrome, Firefox).
Understanding this example
This application uses computer vision and augmented reality techniques to detect a pointer in a WebRTC stream based
on color tracking.
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one for the video
camera stream (the local client-side stream) and other for the mirror (the remote stream). The video camera stream is
sent to Kurento Media Server, which processes and sends it back to the client as a remote stream. To implement this,
we need to create a Media Pipeline composed by the following Media Element s:
Figure 15.3: WebRTC with PointerDetector filter in loopback Media Pipeline
The complete source code of this demo can be found in GitHub.
This example is a modified version of the Magic Mirror tutorial. In this case, this demo uses a PointerDetector
instead of FaceOverlay filter.
In order to perform pointer detection, there must be a calibration stage, in which the color of the pointer is registered
by the filter. To accomplish this step, the pointer should be placed in a square in the upper left corner of the video, as
follows:
In that precise moment, a calibration message from the client to the server. This is done by clicking on the Calibrate
blue button of the GUI.
After that, the color of the pointer is tracked in real time by Kurento Media Server. PointerDetectorFilter can
also define regions in the screen called windows in which some actions are performed when the pointer is detected when
the pointer enters (‘‘WindowInEvent‘‘event) and exits (‘‘WindowOutEvent‘‘event) the windows. This is implemented
in the server-side logic as follows:
// Media Logic (Media Pipeline and Elements)
MediaPipeline pipeline = kurento.createMediaPipeline();
pipelines.put(session.getId(), pipeline);
WebRtcEndpoint webRtcEndpoint = new WebRtcEndpoint.Builder(pipeline)
.build();
pointerDetectorFilter = new PointerDetectorFilter.Builder(pipeline,
new WindowParam(5, 5, 30, 30)).build();
158
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
Figure 15.4: Pointer calibration stage
15.1. Kurento Modules
159
Kurento Documentation, Release 5.0.5
pointerDetectorFilter
.addWindow(new PointerDetectorWindowMediaParam("window0",
50, 50, 500, 150));
pointerDetectorFilter
.addWindow(new PointerDetectorWindowMediaParam("window1",
50, 50, 500, 250));
webRtcEndpoint.connect(pointerDetectorFilter);
pointerDetectorFilter.connect(webRtcEndpoint);
pointerDetectorFilter
.addWindowInListener(new EventListener<WindowInEvent>() {
@Override
public void onEvent(WindowInEvent event) {
JsonObject response = new JsonObject();
response.addProperty("id", "windowIn");
response.addProperty("roiId", event.getWindowId());
try {
session.sendMessage(new TextMessage(response
.toString()));
} catch (Throwable t) {
sendError(session, t.getMessage());
}
}
});
pointerDetectorFilter
.addWindowOutListener(new EventListener<WindowOutEvent>() {
@Override
public void onEvent(WindowOutEvent event) {
JsonObject response = new JsonObject();
response.addProperty("id", "windowOut");
response.addProperty("roiId", event.getWindowId());
try {
session.sendMessage(new TextMessage(response
.toString()));
} catch (Throwable t) {
sendError(session, t.getMessage());
}
}
});
The following picture illustrates the pointer tracking in one of the defined windows:
In order to send the calibration message from the client side, this function is used in the JavaScript side of this demo:
function calibrate() {
console.log("Calibrate color");
var message = {
id : 'calibrate'
}
sendMessage(message);
}
When this message is received in the application server side, this code is execute to carry out the calibration:
160
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
Figure 15.5: Pointer tracking over a window
15.1. Kurento Modules
161
Kurento Documentation, Release 5.0.5
private void calibrate(WebSocketSession session, JsonObject jsonMessage) {
if (pointerDetectorFilter != null) {
pointerDetectorFilter.trackColorFromCalibrationRegion();
}
}
Dependencies
This Java Spring application is implemented using Maven. The relevant part of the pom.xml is where Kurento dependencies are declared. As the following snippet shows, we need three dependencies: the Kurento Client Java
dependency (kurento-client), the JavaScript Kurento utility library (kurento-utils) for the client-side, and the pointer
detector module (pointerdetector):
<dependencies>
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-client</artifactId>
<version>[5.0.0,6.0.0)</version>
</dependency>
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-utils-js</artifactId>
<version>[5.0.0,6.0.0)</version>
</dependency>
<dependency>
<groupId>org.kurento.module</groupId>
<artifactId>pointerdetector</artifactId>
<version>[1.0.0,2.0.0)</version>
</dependency>
</dependencies>
Kurento framework uses Semantic Versioning for releases. Notice that ranges ([5.0.0,6.0.0) for kurento-client
and kurento-utils-js, and [1.0.0,2.0.0) for pointerdetector) downloads the latest version of Kurento artifacts
from Maven Central.
JavaScript Module Tutorial 1 - Pointer Detector Filter
This web application consists on a WebRTC video communication in mirror (loopback) with a pointer tracking filter
element.
For the impatient: running this example
First of all, you should install Kurento Media Server to run this demo. Please visit the installation guide for further
information. In addition, the built-in module kms-pointerdetector should be also installed:
sudo apt-get install kms-pointerdetector
Be sure to have installed Node.js and Bower in your system. In an Ubuntu machine, you can install both as follows:
curl -sL https://deb.nodesource.com/setup | sudo bash sudo apt-get install -y nodejs
sudo npm install -g bower
162
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
Due to Same-origin policy, this demo has to be served by an HTTP server. A very simple way of doing this is by
means of a HTTP Node.js server which can be installed using npm :
sudo npm install http-server -g
You also need the source code of this demo. You can clone it from GitHub. Then start the HTTP server:
git clone https://github.com/Kurento/kurento-tutorial-js.git
cd kurento-tutorial-js/kurento-pointerdetector
bower install
http-server
Finally access the application connecting to the URL http://localhost:8080/ through a WebRTC capable browser
(Chrome, Firefox).
Understanding this example
This application uses computer vision and augmented reality techniques to detect a pointer in a WebRTC stream based
on color tracking.
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one for the video
camera stream (the local client-side stream) and other for the mirror (the remote stream). The video camera stream is
sent to Kurento Media Server, which processes and sends it back to the client as a remote stream. To implement this,
we need to create a Media Pipeline composed by the following Media Element s:
Figure 15.6: WebRTC with PointerDetector filter in loopback Media Pipeline
The complete source code of this demo can be found in GitHub.
This example is a modified version of the Magic Mirror tutorial. In this case, this demo uses a PointerDetector
instead of FaceOverlay filter.
In order to perform pointer detection, there must be a calibration stage, in which the color of the pointer is registered
by the filter. To accomplish this step, the pointer should be placed in a square in the upper left corner of the video, as
follows:
In that precise moment, a calibration operation should be carried out. This is done by clicking on the Calibrate blue
button of the GUI.
After that, the color of the pointer is tracked in real time by Kurento Media Server. PointerDetectorFilter can
also define regions in the screen called windows in which some actions are performed when the pointer is detected when
the pointer enters (‘‘WindowInEvent‘‘event) and exits (‘‘WindowOutEvent‘‘event) the windows. This is implemented
in the JavaScript logic as follows:
pipeline.create('PointerDetectorFilter', {'calibrationRegion' : {topRightCornerX: 5,
topRightCornerY:5, width:30, height: 30}}, function(error, _filter) {
if (error) return onError(error);
15.1. Kurento Modules
163
Kurento Documentation, Release 5.0.5
Figure 15.7: Pointer calibration stage
164
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
filter = _filter;
webRtc.connect(filter, function(error) {
if (error) return onError(error);
filter.connect(webRtc, function(error) {
if (error) return onError(error);
filter.addWindow({id: 'window0', height: 50, width:50,
upperRightX: 500, upperRightY: 150}, function(error) {
if (error) return onError(error);
});
filter.addWindow({id: 'window1', height: 50, width:50,
upperRightX: 500, upperRightY: 250}, function(error) {
if (error) return onError(error);
});
filter.on ('WindowIn', function (data){
console.log ("Event window in detected in window " + data.windowId);
});
filter.on ('WindowOut', function (data){
console.log ("Event window out detected in window " + data.windowId);
});
});
});
The following picture illustrates the pointer tracking in one of the defined windows:
In order to carry out the calibration process, this JavaScript function is used:
Dependencies
The dependencies of this demo has to be obtained using Bower. The definition of these dependencies are defined in
the bower.json file, as follows:
"dependencies": {
"kurento-client": "^5.0.0",
"kurento-utils": "^5.0.0",
"kurento-module-pointerdetector": "^1.0.0"
}
Kurento framework uses Semantic Versioning for releases. Notice that ranges (^5.0.0 for kurento-client and kurentoutils-js, and ^1.0.0 for pointerdetector) downloads the latest version of Kurento artifacts from Bower.
Node.js Module Tutorial 1 - Pointer Detector Filter
This web application consists on a WebRTC video communication in mirror (loopback) with a pointer tracking filter
element.
For the impatient: running this example
First of all, you should install Kurento Media Server to run this demo. Please visit the installation guide for further
information. In addition, the built-in module kms-pointerdetector should be also installed:
15.1. Kurento Modules
165
Kurento Documentation, Release 5.0.5
Figure 15.8: Pointer tracking over a window
166
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
sudo apt-get install kms-pointerdetector
Be sure to have installed Node.js and Bower in your system. In an Ubuntu machine, you can install both as follows:
curl -sL https://deb.nodesource.com/setup | sudo bash sudo apt-get install -y nodejs
sudo npm install -g bower
To launch the application you need to clone the GitHub project where this demo is hosted and then install and run it,
as follows:
git clone https://github.com/Kurento/kurento-tutorial-node.git
cd kurento-tutorial-node/kurento-pointerdetector
npm install
Finally access the application connecting to the URL http://localhost:8080/ through a WebRTC capable browser
(Chrome, Firefox).
Understanding this example
This application uses computer vision and augmented reality techniques to detect a pointer in a WebRTC stream based
on color tracking.
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one for the video
camera stream (the local client-side stream) and other for the mirror (the remote stream). The video camera stream is
sent to Kurento Media Server, which processes and sends it back to the client as a remote stream. To implement this,
we need to create a Media Pipeline composed by the following Media Element s:
Figure 15.9: WebRTC with PointerDetector filter in loopback Media Pipeline
The complete source code of this demo can be found in GitHub.
This example is a modified version of the Magic Mirror tutorial. In this case, this demo uses a PointerDetector
instead of FaceOverlay filter.
In order to perform pointer detection, there must be a calibration stage, in which the color of the pointer is registered
by the filter. To accomplish this step, the pointer should be placed in a square in the upper left corner of the video, as
follows:
In that precise moment, a calibration operation should be carried out. This is done by clicking on the Calibrate blue
button of the GUI.
After that, the color of the pointer is tracked in real time by Kurento Media Server. PointerDetectorFilter can
also define regions in the screen called windows in which some actions are performed when the pointer is detected when
the pointer enters (‘‘WindowInEvent‘‘event) and exits (‘‘WindowOutEvent‘‘event) the windows. This is implemented
in the JavaScript logic as follows:
15.1. Kurento Modules
167
Kurento Documentation, Release 5.0.5
Figure 15.10: Pointer calibration stage
168
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
pipeline.create('PointerDetectorFilter', {'calibrationRegion' : {topRightCornerX: 5,
topRightCornerY:5, width:30, height: 30}}, function(error, _filter) {
if (error) return onError(error);
filter = _filter;
webRtc.connect(filter, function(error) {
if (error) return onError(error);
filter.connect(webRtc, function(error) {
if (error) return onError(error);
filter.addWindow({id: 'window0', height: 50, width:50,
upperRightX: 500, upperRightY: 150}, function(error) {
if (error) return onError(error);
});
filter.addWindow({id: 'window1', height: 50, width:50,
upperRightX: 500, upperRightY: 250}, function(error) {
if (error) return onError(error);
});
filter.on ('WindowIn', function (data){
console.log ("Event window in detected in window " + data.windowId);
});
filter.on ('WindowOut', function (data){
console.log ("Event window out detected in window " + data.windowId);
});
});
});
The following picture illustrates the pointer tracking in one of the defined windows:
In order to carry out the calibration process, this JavaScript function is used:
Dependencies
Dependencies of this demo are managed using NPM. Our main dependency is the Kurento Client JavaScript (kurentoclient). The relevant part of the package.json file for managing this dependency is:
"dependencies": {
"kurento-client": "^5.0.0",
}
At the client side, dependencies are managed using Bower. Take a look to the bower.json file and pay attention to the
following section:
"dependencies": {
"kurento-utils": "^5.0.0",
"kurento-module-pointerdetector": "^1.0.0"
}
Kurento framework uses Semantic Versioning for releases. Notice that ranges (^5.0.0 for kurento-client and kurentoutils-js, and ^1.0.0 for pointerdetector) downloads the latest version of Kurento artifacts from NPM and Bower.
15.1. Kurento Modules
169
Kurento Documentation, Release 5.0.5
Figure 15.11: Pointer tracking over a window
170
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
15.1.3 Module Tutorial 2 - Chroma Filter
This web application consists on a WebRTC video communication in mirror (loopback) with a chroma filter element.
Java Module Tutorial 2 - Chroma Filter
This web application consists on a WebRTC video communication in mirror (loopback) with a chroma filter element.
For the impatient: running this example
First of all, you should install Kurento Media Server to run this demo. Please visit the installation guide for further
information. In addition, the built-in module kms-chroma should be also installed:
sudo apt-get install kms-chroma
To launch the application you need to clone the GitHub project where this demo is hosted and then run the main class,
as follows:
git clone https://github.com/Kurento/kurento-tutorial-java.git
cd kurento-tutorial-java/kurento-chroma
mvn compile exec:java
The web application starts on port 8080 in the localhost by default. Therefore, open the URL http://localhost:8080/ in
a WebRTC compliant browser (Chrome, Firefox).
Understanding this example
This application uses computer vision and augmented reality techniques to detect a chroma in a WebRTC stream based
on color tracking.
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one for the video
camera stream (the local client-side stream) and other for the mirror (the remote stream). The video camera stream is
sent to Kurento Media Server, which processes and sends it back to the client as a remote stream. To implement this,
we need to create a Media Pipeline composed by the following Media Element s:
Figure 15.12: WebRTC with Chroma filter Media Pipeline
The complete source code of this demo can be found in GitHub.
This example is a modified version of the Magic Mirror tutorial. In this case, this demo uses a Chroma instead of
FaceOverlay filter.
In order to perform chroma detection, there must be a color calibration stage. To accomplish this step, at the beginning
of the demo, a little square appears in upper left of the video, as follows:
15.1. Kurento Modules
171
Kurento Documentation, Release 5.0.5
Figure 15.13: Chroma calibration stage
172
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
In the first second of the demo, a calibration process is done, by detecting the color inside that square. When the
calibration is finished, the square disappears and the chroma is substituted with the configured image. Take into
account that this process requires lighting condition. Otherwise the chroma substitution will not be perfect. This
behavior can be seen in the upper right corner of the following screenshot:
Figure 15.14: Chroma filter in action
The media pipeline of this demo is is implemented in the server-side logic as follows:
private void start(WebSocketSession session, JsonObject jsonMessage) {
try {
// Media Logic (Media Pipeline and Elements)
MediaPipeline pipeline = kurento.createMediaPipeline();
pipelines.put(session.getId(), pipeline);
WebRtcEndpoint webRtcEndpoint = new WebRtcEndpoint.Builder(pipeline)
.build();
ChromaFilter chromaFilter = new ChromaFilter.Builder(pipeline,
new WindowParam(5, 5, 40, 40)).build();
String appServerUrl = System.getProperty("app.server.url",
ChromaApp.DEFAULT_APP_SERVER_URL);
chromaFilter.setBackground(appServerUrl + "/img/mario.jpg");
webRtcEndpoint.connect(chromaFilter);
chromaFilter.connect(webRtcEndpoint);
15.1. Kurento Modules
173
Kurento Documentation, Release 5.0.5
// SDP negotiation (offer and answer)
String sdpOffer = jsonMessage.get("sdpOffer").getAsString();
String sdpAnswer = webRtcEndpoint.processOffer(sdpOffer);
// Sending response back to client
JsonObject response = new JsonObject();
response.addProperty("id", "startResponse");
response.addProperty("sdpAnswer", sdpAnswer);
session.sendMessage(new TextMessage(response.toString()));
} catch (Throwable t) {
sendError(session, t.getMessage());
}
}
Dependencies
This Java Spring application is implemented using Maven. The relevant part of the pom.xml is where Kurento dependencies are declared. As the following snippet shows, we need three dependencies: the Kurento Client Java
dependency (kurento-client), the JavaScript Kurento utility library (kurento-utils) for the client-side, and the chroma
module (chroma):
<dependencies>
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-client</artifactId>
<version>[5.0.0,6.0.0)</version>
</dependency>
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-utils-js</artifactId>
<version>[5.0.0,6.0.0)</version>
</dependency>
<dependency>
<groupId>org.kurento.module</groupId>
<artifactId>chroma</artifactId>
<version>[1.0.0,2.0.0)</version>
</dependency>
</dependencies>
Kurento framework uses Semantic Versioning for releases. Notice that ranges ([5.0.0,6.0.0) for kurento-client
and kurento-utils-js, and [1.0.0,2.0.0) for chroma) downloads the latest version of Kurento artifacts from Maven
Central.
JavaScript Module Tutorial 2 - Chroma Filter
This web application consists on a WebRTC video communication in mirror (loopback) with a chroma filter element.
For the impatient: running this example
First of all, you should install Kurento Media Server to run this demo. Please visit the installation guide for further
information. In addition, the built-in module kms-chroma should be also installed:
174
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
sudo apt-get install kms-chroma
Be sure to have installed Node.js and Bower in your system. In an Ubuntu machine, you can install both as follows:
curl -sL https://deb.nodesource.com/setup | sudo bash sudo apt-get install -y nodejs
sudo npm install -g bower
Due to Same-origin policy, this demo has to be served by an HTTP server. A very simple way of doing this is by
means of a HTTP Node.js server which can be installed using npm :
sudo npm install http-server -g
You also need the source code of this demo. You can clone it from GitHub. Then start the HTTP server:
git clone https://github.com/Kurento/kurento-tutorial-js.git
cd kurento-tutorial-js/kurento-chroma
bower install
http-server
Finally access the application connecting to the URL http://localhost:8080/ through a WebRTC capable browser
(Chrome, Firefox).
Understanding this example
This application uses computer vision and augmented reality techniques to detect a chroma in a WebRTC stream based
on color tracking.
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one for the video
camera stream (the local client-side stream) and other for the mirror (the remote stream). The video camera stream is
sent to Kurento Media Server, which processes and sends it back to the client as a remote stream. To implement this,
we need to create a Media Pipeline composed by the following Media Element s:
Figure 15.15: WebRTC with Chroma filter Media Pipeline
The complete source code of this demo can be found in GitHub.
This example is a modified version of the Magic Mirror tutorial. In this case, this demo uses a Chroma instead of
FaceOverlay filter.
In order to perform chroma detection, there must be a color calibration stage. To accomplish this step, at the beginning
of the demo, a little square appears in upper left of the video, as follows:
In the first second of the demo, a calibration process is done, by detecting the color inside that square. When the
calibration is finished, the square disappears and the chroma is substituted with the configured image. Take into
account that this process requires lighting condition. Otherwise the chroma substitution will not be perfect. This
behavior can be seen in the upper right corner of the following screenshot:
15.1. Kurento Modules
175
Kurento Documentation, Release 5.0.5
Figure 15.16: Chroma calibration stage
176
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
Figure 15.17: Chroma filter in action
15.1. Kurento Modules
177
Kurento Documentation, Release 5.0.5
The media pipeline of this demo is is implemented in the JavaScript logic as follows:
client.create('MediaPipeline', function(error, p) {
if (error) return onError(error);
pipeline = p;
pipeline.create('WebRtcEndpoint', function(error, webRtc) {
if (error) return onError(error);
pipeline.create('ChromaFilter', {window: {topRightCornerX:5 ,
topRightCornerY:5 , width:30 , height:30 }}, function(error, filter) {
if (error) return onError(error);
webRtc.connect(filter, function(error) {
if (error) return onError(error);
filter.connect(webRtc, function(error) {
if (error) return onError(error);
console.log("filter --> WebRtcEndpoint");
});
filter.setBackground (bg_uri, function(error) {
if (error) return onError(error);
console.log("Set Image");
});
});
webRtc.processOffer(sdpOffer, function(error, sdpAnswer) {
if (error) return onError(error);
webRtcPeer.processSdpAnswer(sdpAnswer);
});
});
});
});
Dependencies
The dependencies of this demo has to be obtained using Bower. The definition of these dependencies are defined in
the bower.json file, as follows:
"dependencies": {
"kurento-client": "^5.0.0",
"kurento-utils": "^5.0.0",
"kurento-module-chroma": "^1.0.0"
}
Kurento framework uses Semantic Versioning for releases. Notice that ranges (^5.0.0 for kurento-client and kurentoutils-js, and ^1.0.0 for chroma) downloads the latest version of Kurento artifacts from Bower.
Node.js Module Tutorial 2 - Chroma Filter
This web application consists on a WebRTC video communication in mirror (loopback) with a chroma filter element.
178
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
For the impatient: running this example
First of all, you should install Kurento Media Server to run this demo. Please visit the installation guide for further
information. In addition, the built-in module kms-chroma should be also installed:
sudo apt-get install kms-chroma
Be sure to have installed Node.js and Bower in your system. In an Ubuntu machine, you can install both as follows:
curl -sL https://deb.nodesource.com/setup | sudo bash sudo apt-get install -y nodejs
sudo npm install -g bower
To launch the application you need to clone the GitHub project where this demo is hosted and then install and run it,
as follows:
git clone https://github.com/Kurento/kurento-tutorial-node.git
cd kurento-tutorial-node/kurento-chroma
npm install
Finally access the application connecting to the URL http://localhost:8080/ through a WebRTC capable browser
(Chrome, Firefox).
Understanding this example
This application uses computer vision and augmented reality techniques to detect a chroma in a WebRTC stream based
on color tracking.
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one for the video
camera stream (the local client-side stream) and other for the mirror (the remote stream). The video camera stream is
sent to Kurento Media Server, which processes and sends it back to the client as a remote stream. To implement this,
we need to create a Media Pipeline composed by the following Media Element s:
Figure 15.18: WebRTC with Chroma filter Media Pipeline
The complete source code of this demo can be found in GitHub.
This example is a modified version of the Magic Mirror tutorial. In this case, this demo uses a Chroma instead of
FaceOverlay filter.
In order to perform chroma detection, there must be a color calibration stage. To accomplish this step, at the beginning
of the demo, a little square appears in upper left of the video, as follows:
In the first second of the demo, a calibration process is done, by detecting the color inside that square. When the
calibration is finished, the square disappears and the chroma is substituted with the configured image. Take into
account that this process requires lighting condition. Otherwise the chroma substitution will not be perfect. This
behavior can be seen in the upper right corner of the following screenshot:
15.1. Kurento Modules
179
Kurento Documentation, Release 5.0.5
Figure 15.19: Chroma calibration stage
180
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
Figure 15.20: Chroma filter in action
15.1. Kurento Modules
181
Kurento Documentation, Release 5.0.5
The media pipeline of this demo is is implemented in the JavaScript logic as follows:
getKurentoClient(function(error, kurentoClient) {
if (error) {
return callback(error);
}
kurentoClient.create('MediaPipeline', function(error, pipeline) {
if (error) {
return callback(error);
}
createMediaElements(pipeline, function(error, webRtcEndpoint,
chromaFilter) {
if (error) {
pipeline.release();
return callback(error);
}
connectMediaElements(webRtcEndpoint, chromaFilter,
function(error) {
if (error) {
pipeline.release();
return callback(error);
}
chromaFilter.setBackground (url.format(asUrl) + 'img/mario.jpg',
function(error) {
if (error) {
pipeline.release();
return callback(error);
}
});
webRtcEndpoint.processOffer(sdpOffer, function(error, sdpAnswer) {
if (error) {
pipeline.release();
return callback(error);
}
pipelines[sessionId] = pipeline;
return callback(null, 'sdpAnswer', sdpAnswer);
});
});
});
});
});
Dependencies
Dependencies of this demo are managed using NPM. Our main dependency is the Kurento Client JavaScript (kurentoclient). The relevant part of the package.json file for managing this dependency is:
"dependencies": {
"kurento-client": "^5.0.0",
}
At the client side, dependencies are managed using Bower. Take a look to the bower.json file and pay attention to the
182
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
following section:
"dependencies": {
"kurento-utils": "^5.0.0",
"kurento-module-chroma": "^1.0.0"
}
Kurento framework uses Semantic Versioning for releases. Notice that ranges (^5.0.0 for kurento-client and kurentoutils-js, and ^1.0.0 for chroma) downloads the latest version of Kurento artifacts from NPM and Bower.
15.1.4 Module Tutorial 3 - Crowd Detector Filter
This web application consists on a WebRTC video communication in mirror (loopback) with a crowd detector filter.
This filter detects people agglomeration in video streams.
Java Module Tutorial 3 - Crowd Detector Filter
This web application consists on a WebRTC video communication in mirror (loopback) with a crowd detector filter.
This filter detects people agglomeration in video streams.
For the impatient: running this example
First of all, you should install Kurento Media Server to run this demo. Please visit the installation guide for further
information. In addition, the built-in module kms-crowddetector should be also installed:
sudo apt-get install kms-crowddetector
To launch the application you need to clone the GitHub project where this demo is hosted and then run the main class,
as follows:
git clone https://github.com/Kurento/kurento-tutorial-java.git
cd kurento-tutorial-java/kurento-crowddetector
mvn compile exec:java
The web application starts on port 8080 in the localhost by default. Therefore, open the URL http://localhost:8080/ in
a WebRTC compliant browser (Chrome, Firefox).
Understanding this example
This application uses computer vision and augmented reality techniques to detect a crowd in a WebRTC stream.
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one for the video
camera stream (the local client-side stream) and other for the mirror (the remote stream). The video camera stream is
sent to Kurento Media Server, which processes and sends it back to the client as a remote stream. To implement this,
we need to create a Media Pipeline composed by the following Media Element s:
The complete source code of this demo can be found in GitHub.
This example is a modified version of the Magic Mirror tutorial. In this case, this demo uses a CrowdDetector
instead of FaceOverlay filter.
To setup a CrowdDetectorFilter, first we need to define one or more region of interests (ROIs). A ROI delimits
the zone within the video stream in which crowd are going to be tracked. To define a ROI, we need to configure at
least three points. These points are defined in relative terms (0 to 1) to the video width and height.
15.1. Kurento Modules
183
Kurento Documentation, Release 5.0.5
Figure 15.21: WebRTC with crowdDetector filter Media Pipeline
CrowdDetectorFilter performs two actions in the defined ROIs. On the one hand, the detected crowd are
colored over the stream. On the other hand, different events are raised to the client.
To understand crowd coloring, we can take a look to an screenshot of a running example of
CrowdDetectorFilter. In the picture below, we can see that there are two ROIs (bounded with white lines
in the video). On these ROIs, we can see two different colors over the original video stream: red zones are drawn over
detected static crowds (or moving slowly). Blue zones are drawn over the detected crowds moving fast.
Figure 15.22: Crowd detection sample
Regarding crowd events, there are three types of events, namely:
• CrowdDetectorFluidityEvent. Event raised when a certain level of fluidity is detected in a ROI. Fluidity can be
seen as the level of general movement in a crowd.
• CrowdDetectorOccupancyEvent. Event raised when a level of occupancy is detected in a ROI. Occupancy can
be seen as the level of agglomeration in stream.
184
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
• CrowdDetectorDirectionEvent. Event raised when a movement direction is detected in a ROI by a crowd.
Both fluidity as occupancy are quantified in a relative metric from 0 to 100%. Then, both attributes are qualified into
three categories: i) Minimum (min); ii) Medium (med); iii) Maximum (max).
Regarding direction, it is quantified as an angle (0-360º), where 0 is the direction from the central point of the video
to the top (i.e., north), 90 correspond to the direction to the right (east), 180 is the south, and finally 270 is the west.
With all these concepts, now we can check out the Java server-side code of this demo. As depicted in the snippet
below, we create a ROI by adding RelativePoint instances to a list. Each ROI is then stored into a list of
RegionOfInterest instances.
Then, each ROI should be configured. To do that, we have the following methods:
• setFluidityLevelMin: Fluidity level (0-100%) for the category minimum.
• setFluidityLevelMed: Fluidity level (0-100%) for the category medium.
• setFluidityLevelMax: Fluidity level (0-100%) for the category maximum.
• setFluidityNumFramesToEvent: Number of consecutive frames detecting a fluidity level to rise a event.
• setOccupancyLevelMin: Occupancy level (0-100%) for the category minimum.
• setOccupancyLevelMed: Occupancy level (0-100%) for the category medium.
• setOccupancyLevelMax: Occupancy level (0-100%) for the category maximum.
• setOccupancyNumFramesToEvent: Number of consecutive frames detecting a occupancy level to rise a
event.
• setSendOpticalFlowEvent: Boolean value that indicates whether or not directions events are going to
be tracked by the filter. Be careful with this feature, since it is very demanding in terms of resource usage (CPU,
memory) in the media server. Set to true this parameter only when you are going to need directions events in
your client-side.
• setOpticalFlowNumFramesToEvent: Number of consecutive frames detecting a direction level to rise
a event.
• setOpticalFlowNumFramesToReset: Number of consecutive frames detecting a occupancy level in
which the counter is reset.
• setOpticalFlowAngleOffset: Counterclockwise offset of the angle. This parameters is useful to move
the default axis for directions (0º=north, 90º=east, 180º=south, 270º=west).
All in all, the media pipeline of this demo is is implemented as follows:
private void start(final WebSocketSession session, JsonObject jsonMessage) {
try {
// Media Logic (Media Pipeline and Elements)
MediaPipeline pipeline = kurento.createMediaPipeline();
pipelines.put(session.getId(), pipeline);
WebRtcEndpoint webRtcEndpoint = new WebRtcEndpoint.Builder(pipeline)
.build();
List<RegionOfInterest> rois = new ArrayList<>();
List<RelativePoint> points = new ArrayList<RelativePoint>();
points.add(new
points.add(new
points.add(new
points.add(new
15.1. Kurento Modules
RelativePoint(0, 0));
RelativePoint(0.5F, 0));
RelativePoint(0.5F, 0.5F));
RelativePoint(0, 0.5F));
185
Kurento Documentation, Release 5.0.5
RegionOfInterestConfig config = new RegionOfInterestConfig();
config.setFluidityLevelMin(10);
config.setFluidityLevelMed(35);
config.setFluidityLevelMax(65);
config.setFluidityNumFramesToEvent(5);
config.setOccupancyLevelMin(10);
config.setOccupancyLevelMed(35);
config.setOccupancyLevelMax(65);
config.setOccupancyNumFramesToEvent(5);
config.setSendOpticalFlowEvent(false);
config.setOpticalFlowNumFramesToEvent(3);
config.setOpticalFlowNumFramesToReset(3);
config.setOpticalFlowAngleOffset(0);
rois.add(new RegionOfInterest(points, config, "roi0"));
CrowdDetectorFilter crowdDetectorFilter = new CrowdDetectorFilter.Builder(
pipeline, rois).build();
webRtcEndpoint.connect(crowdDetectorFilter);
crowdDetectorFilter.connect(webRtcEndpoint);
// addEventListener to crowddetector
crowdDetectorFilter.addCrowdDetectorDirectionListener(
new EventListener<CrowdDetectorDirectionEvent>() {
@Override
public void onEvent(CrowdDetectorDirectionEvent event) {
JsonObject response = new JsonObject();
response.addProperty("id", "directionEvent");
response.addProperty("roiId", event.getRoiID());
response.addProperty("angle",
event.getDirectionAngle());
try {
session.sendMessage(new TextMessage(response
.toString()));
} catch (Throwable t) {
sendError(session, t.getMessage());
}
}
});
crowdDetectorFilter.addCrowdDetectorFluidityListener(
new EventListener<CrowdDetectorFluidityEvent>() {
@Override
public void onEvent(CrowdDetectorFluidityEvent event) {
JsonObject response = new JsonObject();
response.addProperty("id", "fluidityEvent");
response.addProperty("roiId", event.getRoiID());
response.addProperty("level",
event.getFluidityLevel());
response.addProperty("percentage",
event.getFluidityPercentage());
try {
session.sendMessage(new TextMessage(response
.toString()));
} catch (Throwable t) {
sendError(session, t.getMessage());
186
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
}
}
});
crowdDetectorFilter.addCrowdDetectorOccupancyListener(
new EventListener<CrowdDetectorOccupancyEvent>() {
@Override
public void onEvent(CrowdDetectorOccupancyEvent event) {
JsonObject response = new JsonObject();
response.addProperty("id", "occupancyEvent");
response.addProperty("roiId", event.getRoiID());
response.addProperty("level",
event.getOccupancyLevel());
response.addProperty("percentage",
event.getOccupancyPercentage());
try {
session.sendMessage(new TextMessage(response
.toString()));
} catch (Throwable t) {
sendError(session, t.getMessage());
}
}
});
// SDP negotiation (offer and answer)
String sdpOffer = jsonMessage.get("sdpOffer").getAsString();
String sdpAnswer = webRtcEndpoint.processOffer(sdpOffer);
// Sending response back to client
JsonObject response = new JsonObject();
response.addProperty("id", "startResponse");
response.addProperty("sdpAnswer", sdpAnswer);
session.sendMessage(new TextMessage(response.toString()));
} catch (Throwable t) {
sendError(session, t.getMessage());
}
}
Dependencies
This Java Spring application is implemented using Maven. The relevant part of the pom.xml is where Kurento dependencies are declared. As the following snippet shows, we need three dependencies: the Kurento Client Java
dependency (kurento-client), the JavaScript Kurento utility library (kurento-utils) for the client-side, and the crowd
detector module (crowddetector):
<dependencies>
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-client</artifactId>
<version>[5.0.0,6.0.0)</version>
</dependency>
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-utils-js</artifactId>
<version>[5.0.0,6.0.0)</version>
</dependency>
<dependency>
15.1. Kurento Modules
187
Kurento Documentation, Release 5.0.5
<groupId>org.kurento.module</groupId>
<artifactId>crowddetector</artifactId>
<version>[1.0.0,2.0.0)</version>
</dependency>
</dependencies>
Kurento framework uses Semantic Versioning for releases. Notice that ranges ([5.0.0,6.0.0) for kurento-client
and kurento-utils-js, and [1.0.0,2.0.0) for crowddetector) downloads the latest version of Kurento artifacts from
Maven Central.
JavaScript Module Tutorial 3 - Crowd Detector Filter
This web application consists on a WebRTC video communication in mirror (loopback) with a crowd detector filter.
This filter detects people agglomeration in video streams.
For the impatient: running this example
First of all, you should install Kurento Media Server to run this demo. Please visit the installation guide for further
information. In addition, the built-in module kms-crowddetector should be also installed:
sudo apt-get install kms-crowddetector
Be sure to have installed Node.js and Bower in your system. In an Ubuntu machine, you can install both as follows:
curl -sL https://deb.nodesource.com/setup | sudo bash sudo apt-get install -y nodejs
sudo npm install -g bower
Due to Same-origin policy, this demo has to be served by an HTTP server. A very simple way of doing this is by
means of a HTTP Node.js server which can be installed using npm :
sudo npm install http-server -g
You also need the source code of this demo. You can clone it from GitHub. Then start the HTTP server:
git clone https://github.com/Kurento/kurento-tutorial-js.git
cd kurento-tutorial-js/kurento-crowddetector
bower install
http-server
Finally access the application connecting to the URL http://localhost:8080/ through a WebRTC capable browser
(Chrome, Firefox).
Understanding this example
This application uses computer vision and augmented reality techniques to detect a crowd in a WebRTC stream.
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one for the video
camera stream (the local client-side stream) and other for the mirror (the remote stream). The video camera stream is
sent to Kurento Media Server, which processes and sends it back to the client as a remote stream. To implement this,
we need to create a Media Pipeline composed by the following Media Element s:
The complete source code of this demo can be found in GitHub.
This example is a modified version of the Magic Mirror tutorial. In this case, this demo uses a CrowdDetector
instead of FaceOverlay filter.
188
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
Figure 15.23: WebRTC with crowdDetector filter Media Pipeline
To setup a CrowdDetectorFilter, first we need to define one or more region of interests (ROIs). A ROI delimits
the zone within the video stream in which crowd are going to be tracked. To define a ROI, we need to configure at
least three points. These points are defined in relative terms (0 to 1) to the video width and height.
CrowdDetectorFilter performs two actions in the defined ROIs. On the one hand, the detected crowd are
colored over the stream. On the other hand, different events are raised to the client.
To understand crowd coloring, we can take a look to an screenshot of a running example of
CrowdDetectorFilter. In the picture below, we can see that there are two ROIs (bounded with white lines
in the video). On these ROIs, we can see two different colors over the original video stream: red zones are drawn over
detected static crowds (or moving slowly). Blue zones are drawn over the detected crowds moving fast.
Figure 15.24: Crowd detection sample
Regarding crowd events, there are three types of events, namely:
15.1. Kurento Modules
189
Kurento Documentation, Release 5.0.5
• CrowdDetectorFluidityEvent. Event raised when a certain level of fluidity is detected in a ROI. Fluidity can be
seen as the level of general movement in a crowd.
• CrowdDetectorOccupancyEvent. Event raised when a level of occupancy is detected in a ROI. Occupancy can
be seen as the level of agglomeration in stream.
• CrowdDetectorDirectionEvent. Event raised when a movement direction is detected in a ROI by a crowd.
Both fluidity as occupancy are quantified in a relative metric from 0 to 100%. Then, both attributes are qualified into
three categories: i) Minimum (min); ii) Medium (med); iii) Maximum (max).
Regarding direction, it is quantified as an angle (0-360º), where 0 is the direction from the central point of the video
to the top (i.e., north), 90 correspond to the direction to the right (east), 180 is the south, and finally 270 is the west.
With all these concepts, now we can check out the Java server-side code of this demo. As depicted in the snippet
below, we create a ROI by adding RelativePoint instances to a list. Each ROI is then stored into a list of
RegionOfInterest instances.
Then, each ROI should be configured. To do that, we have the following methods:
• fluidityLevelMin: Fluidity level (0-100%) for the category minimum.
• fluidityLevelMed: Fluidity level (0-100%) for the category medium.
• fluidityLevelMax: Fluidity level (0-100%) for the category maximum.
• fluidityNumFramesToEvent: Number of consecutive frames detecting a fluidity level to rise a event.
• occupancyLevelMin: Occupancy level (0-100%) for the category minimum.
• occupancyLevelMed: Occupancy level (0-100%) for the category medium.
• occupancyLevelMax: Occupancy level (0-100%) for the category maximum.
• occupancyNumFramesToEvent: Number of consecutive frames detecting a occupancy level to rise a
event.
• sendOpticalFlowEvent: Boolean value that indicates whether or not directions events are going to be
tracked by the filter. Be careful with this feature, since it is very demanding in terms of resource usage (CPU,
memory) in the media server. Set to true this parameter only when you are going to need directions events in
your client-side.
• opticalFlowNumFramesToEvent: Number of consecutive frames detecting a direction level to rise a
event.
• opticalFlowNumFramesToReset: Number of consecutive frames detecting a occupancy level in which
the counter is reset.
• opticalFlowAngleOffset: Counterclockwise offset of the angle. This parameters is useful to move the
default axis for directions (0º=north, 90º=east, 180º=south, 270º=west).
All in all, the media pipeline of this demo is is implemented as follows:
kurentoClient(ws_uri, function(error, client) {
if (error) return onError(error);
client.create('MediaPipeline', function(error, p) {
if (error) return onError(error);
pipeline = p;
pipeline.create('WebRtcEndpoint', function(error, webRtc) {
if (error) return onError(error);
190
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
var _roi = {
'id' : 'roi1',
'points' : [{'x' : 0, 'y' : 0}, {'x' : 0.5, 'y' : 0},
{'x' : 0.5, 'y' : 0.5}, {'x' : 0, 'y' : 0.5}],
'regionOfInterestConfig' : {
'occupancyLevelMin' : 10,
'occupancyLevelMed' : 35,
'occupancyLevelMax' : 65,
'occupancyNumFramesToEvent' : 5,
'fluidityLevelMin' : 10,
'fluidityLevelMed' : 35,
'fluidityLevelMax' : 65,
'fluidityNumFramesToEvent' : 5,
'sendOpticalFlowEvent' : false,
'opticalFlowNumFramesToEvent' : 3,
'opticalFlowNumFramesToReset' : 3,
'opticalFlowAngleOffset' : 0
}
};
pipeline.create('CrowdDetectorFilter', {'rois' : [_roi]},
function(error, filter) {
if (error) return onError(error);
webRtc.connect(filter, function(error) {
if (error) return onError(error);
filter.connect(webRtc, function(error) {
if (error) return onError(error);
filter.on ('CrowdDetectorDirection', function (data){
console.log ("Direction event received in roi " + data.roiID +
" with direction " + data.directionAngle);
});
filter.on ('CrowdDetectorFluidity', function (data){
console.log ("Fluidity event received in roi " + data.roiID +
". Fluidity level " + data.fluidityPercentage +
" and fluidity percentage " + data.fluidityLevel);
});
filter.on ('CrowdDetectorOccupancy', function (data){
console.log ("Occupancy event received in roi " + data.roiID +
". Occupancy level " + data.occupancyPercentage +
" and occupancy percentage " + data.occupancyLevel);
});
});
});
webRtc.processOffer(sdpOffer, function(error, sdpAnswer) {
if (error) return onError(error);
console.log("SDP answer obtained. Processing ...");
webRtcPeer.processSdpAnswer(sdpAnswer);
});
});
});
15.1. Kurento Modules
191
Kurento Documentation, Release 5.0.5
});
});
Dependencies
The dependencies of this demo has to be obtained using Bower. The definition of these dependencies are defined in
the bower.json file, as follows:
"dependencies": {
"kurento-client": "^5.0.0",
"kurento-utils": "^5.0.0",
"kurento-module-crowddetector": "^1.0.0"
}
Kurento framework uses Semantic Versioning for releases. Notice that ranges (^5.0.0 for kurento-client and kurentoutils-js, and ^1.0.0 for crowddetector) downloads the latest version of Kurento artifacts from Bower.
Node.js Module Tutorial 3 - Crowd Detector Filter
This web application consists on a WebRTC video communication in mirror (loopback) with a crowd detector filter.
This filter detects people agglomeration in video streams.
For the impatient: running this example
First of all, you should install Kurento Media Server to run this demo. Please visit the installation guide for further
information. In addition, the built-in module kms-crowddetector should be also installed:
sudo apt-get install kms-crowddetector
Be sure to have installed Node.js and Bower in your system. In an Ubuntu machine, you can install both as follows:
curl -sL https://deb.nodesource.com/setup | sudo bash sudo apt-get install -y nodejs
sudo npm install -g bower
To launch the application you need to clone the GitHub project where this demo is hosted and then install and run it,
as follows:
git clone https://github.com/Kurento/kurento-tutorial-node.git
cd kurento-tutorial-node/kurento-crowddetector
npm install
Finally access the application connecting to the URL http://localhost:8080/ through a WebRTC capable browser
(Chrome, Firefox).
Understanding this example
This application uses computer vision and augmented reality techniques to detect a crowd in a WebRTC stream.
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one for the video
camera stream (the local client-side stream) and other for the mirror (the remote stream). The video camera stream is
sent to Kurento Media Server, which processes and sends it back to the client as a remote stream. To implement this,
we need to create a Media Pipeline composed by the following Media Element s:
192
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
Figure 15.25: WebRTC with crowdDetector filter Media Pipeline
The complete source code of this demo can be found in GitHub.
This example is a modified version of the Magic Mirror tutorial. In this case, this demo uses a CrowdDetector
instead of FaceOverlay filter.
To setup a CrowdDetectorFilter, first we need to define one or more region of interests (ROIs). A ROI delimits
the zone within the video stream in which crowd are going to be tracked. To define a ROI, we need to configure at
least three points. These points are defined in relative terms (0 to 1) to the video width and height.
CrowdDetectorFilter performs two actions in the defined ROIs. On the one hand, the detected crowd are
colored over the stream. On the other hand, different events are raised to the client.
To understand crowd coloring, we can take a look to an screenshot of a running example of
CrowdDetectorFilter. In the picture below, we can see that there are two ROIs (bounded with white lines
in the video). On these ROIs, we can see two different colors over the original video stream: red zones are drawn over
detected static crowds (or moving slowly). Blue zones are drawn over the detected crowds moving fast.
Regarding crowd events, there are three types of events, namely:
• CrowdDetectorFluidityEvent. Event raised when a certain level of fluidity is detected in a ROI. Fluidity can be
seen as the level of general movement in a crowd.
• CrowdDetectorOccupancyEvent. Event raised when a level of occupancy is detected in a ROI. Occupancy can
be seen as the level of agglomeration in stream.
• CrowdDetectorDirectionEvent. Event raised when a movement direction is detected in a ROI by a crowd.
Both fluidity as occupancy are quantified in a relative metric from 0 to 100%. Then, both attributes are qualified into
three categories: i) Minimum (min); ii) Medium (med); iii) Maximum (max).
Regarding direction, it is quantified as an angle (0-360º), where 0 is the direction from the central point of the video
to the top (i.e., north), 90 correspond to the direction to the right (east), 180 is the south, and finally 270 is the west.
With all these concepts, now we can check out the Java server-side code of this demo. As depicted in the snippet
below, we create a ROI by adding RelativePoint instances to a list. Each ROI is then stored into a list of
RegionOfInterest instances.
Then, each ROI should be configured. To do that, we have the following methods:
• fluidityLevelMin: Fluidity level (0-100%) for the category minimum.
• fluidityLevelMed: Fluidity level (0-100%) for the category medium.
• fluidityLevelMax: Fluidity level (0-100%) for the category maximum.
• fluidityNumFramesToEvent: Number of consecutive frames detecting a fluidity level to rise a event.
• occupancyLevelMin: Occupancy level (0-100%) for the category minimum.
• occupancyLevelMed: Occupancy level (0-100%) for the category medium.
15.1. Kurento Modules
193
Kurento Documentation, Release 5.0.5
Figure 15.26: Crowd detection sample
194
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
• occupancyLevelMax: Occupancy level (0-100%) for the category maximum.
• occupancyNumFramesToEvent: Number of consecutive frames detecting a occupancy level to rise a
event.
• sendOpticalFlowEvent: Boolean value that indicates whether or not directions events are going to be
tracked by the filter. Be careful with this feature, since it is very demanding in terms of resource usage (CPU,
memory) in the media server. Set to true this parameter only when you are going to need directions events in
your client-side.
• opticalFlowNumFramesToEvent: Number of consecutive frames detecting a direction level to rise a
event.
• opticalFlowNumFramesToReset: Number of consecutive frames detecting a occupancy level in which
the counter is reset.
• opticalFlowAngleOffset: Counterclockwise offset of the angle. This parameters is useful to move the
default axis for directions (0º=north, 90º=east, 180º=south, 270º=west).
All in all, the media pipeline of this demo is is implemented as follows:
function start(sessionId, sdpOffer, callback) {
if (!sessionId) {
return callback("Cannot use undefined sessionId");
}
// Check if session is already transmitting
if (pipelines[sessionId]) {
return callback("Close current session before starting a new one or use " +
"another browser to open a tutorial.")
}
getKurentoClient(function(error, kurentoClient) {
if (error) {
return callback(error);
}
kurentoClient.create('MediaPipeline', function(error, pipeline) {
if (error) {
return callback(error);
}
createMediaElements(pipeline, function(error, webRtcEndpoint,
crowdDetector) {
if (error) {
pipeline.release();
return callback(error);
}
connectMediaElements(webRtcEndpoint, crowdDetector,
function(error) {
if (error) {
pipeline.release();
return callback(error);
}
crowdDetector.on ('CrowdDetectorDirection', function (_data){
return callback(null, 'crowdDetectorDirection', _data);
});
15.1. Kurento Modules
195
Kurento Documentation, Release 5.0.5
crowdDetector.on ('CrowdDetectorFluidity', function (_data){
return callback(null, 'crowdDetectorFluidity', _data);
});
crowdDetector.on ('CrowdDetectorOccupancy', function (_data){
return callback(null, 'crowdDetectorOccupancy', _data);
});
webRtcEndpoint.processOffer(sdpOffer, function(
error, sdpAnswer) {
if (error) {
pipeline.release();
return callback(error);
}
pipelines[sessionId] = pipeline;
return callback(null, 'sdpAnswer', sdpAnswer);
});
});
});
});
});
}
function createMediaElements(pipeline, callback) {
pipeline.create('WebRtcEndpoint', function(error, webRtcEndpoint) {
if (error) {
return callback(error);
}
var _roi = {
'id' : 'roi1',
'points' : [{'x' : 0, 'y' : 0}, {'x' : 0.5, 'y' : 0},
{'x' : 0.5, 'y' : 0.5}, {'x' : 0, 'y' : 0.5}],
'regionOfInterestConfig' : {
'occupancyLevelMin' : 10,
'occupancyLevelMed' : 35,
'occupancyLevelMax' : 65,
'occupancyNumFramesToEvent' : 5,
'fluidityLevelMin' : 10,
'fluidityLevelMed' : 35,
'fluidityLevelMax' : 65,
'fluidityNumFramesToEvent' : 5,
'sendOpticalFlowEvent' : false,
'opticalFlowNumFramesToEvent' : 3,
'opticalFlowNumFramesToReset' : 3,
'opticalFlowAngleOffset' : 0
}
};
pipeline.create('CrowdDetectorFilter', {'rois' : [_roi]},
function(error, crowdDetector) {
if (error) {
return callback(error);
}
return callback(null, webRtcEndpoint,
crowdDetector);
});
});
196
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
}
Dependencies
Dependencies of this demo are managed using NPM. Our main dependency is the Kurento Client JavaScript (kurentoclient). The relevant part of the package.json file for managing this dependency is:
"dependencies": {
"kurento-client": "^5.0.0",
}
At the client side, dependencies are managed using Bower. Take a look to the bower.json file and pay attention to the
following section:
"dependencies": {
"kurento-utils": "^5.0.0",
"kurento-module-crowddetector": "^1.0.0"
}
Kurento framework uses Semantic Versioning for releases. Notice that ranges (^5.0.0 for kurento-client and kurentoutils-js, and ^1.0.0 for crowddetector) downloads the latest version of Kurento artifacts from NPM and Bower.
15.1.5 Module Tutorial 4 - Plate Detector Filter
This web application consists on a WebRTC video communication in mirror (loopback) with a plate detector filter
element.
Java Module Tutorial 4 - Plate Detector Filter
This web application consists on a WebRTC video communication in mirror (loopback) with a plate detector filter
element.
For the impatient: running this example
First of all, you should install Kurento Media Server to run this demo. Please visit the installation guide for further
information. In addition, the built-in module kms-platedetector should be also installed:
sudo apt-get install kms-platedetector
To launch the application you need to clone the GitHub project where this demo is hosted and then run the main class,
as follows:
git clone https://github.com/Kurento/kurento-tutorial-java.git
cd kurento-tutorial-java/kurento-platedetector
mvn compile exec:java
The web application starts on port 8080 in the localhost by default. Therefore, open the URL http://localhost:8080/ in
a WebRTC compliant browser (Chrome, Firefox).
15.1. Kurento Modules
197
Kurento Documentation, Release 5.0.5
Understanding this example
This application uses computer vision and augmented reality techniques to detect a plate in a WebRTC stream on
optical character recognition (OCR).
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one for the video
camera stream (the local client-side stream) and other for the mirror (the remote stream). The video camera stream is
sent to Kurento Media Server, which processes and sends it back to the client as a remote stream. To implement this,
we need to create a Media Pipeline composed by the following Media Element s:
Figure 15.27: WebRTC with plateDetector filter Media Pipeline
The complete source code of this demo can be found in GitHub.
This example is a modified version of the Magic Mirror tutorial. In this case, this demo uses a PlateDetector
instead of FaceOverlay filter. An screenshot of the running example is shown in the following picture:
The following snippet shows how the media pipeline is implemented in the Java server-side code of the
demo. An important issue in this code is that a listener is added to the PlateDetectorFilter object
(addPlateDetectedListener). This way, each time a plate is detected in the stream, a message is sent to
the client side. As shown in the screenshot below, this event is printed in the console of the GUI.
private void start(final WebSocketSession session, JsonObject jsonMessage) {
try {
// Media Logic (Media Pipeline and Elements)
MediaPipeline pipeline = kurento.createMediaPipeline();
pipelines.put(session.getId(), pipeline);
WebRtcEndpoint webRtcEndpoint = new WebRtcEndpoint.Builder(pipeline)
.build();
PlateDetectorFilter plateDetectorFilter = new PlateDetectorFilter.Builder(
pipeline).build();
webRtcEndpoint.connect(plateDetectorFilter);
plateDetectorFilter.connect(webRtcEndpoint);
plateDetectorFilter
.addPlateDetectedListener(new EventListener<PlateDetectedEvent>() {
@Override
public void onEvent(PlateDetectedEvent event) {
JsonObject response = new JsonObject();
response.addProperty("id", "plateDetected");
response.addProperty("plate", event.getPlate());
try {
session.sendMessage(new TextMessage(response
.toString()));
} catch (Throwable t) {
198
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
Figure 15.28: Plate detector demo in action
15.1. Kurento Modules
199
Kurento Documentation, Release 5.0.5
sendError(session, t.getMessage());
}
}
});
// SDP negotiation (offer and answer)
String sdpOffer = jsonMessage.get("sdpOffer").getAsString();
String sdpAnswer = webRtcEndpoint.processOffer(sdpOffer);
// Sending response back to client
JsonObject response = new JsonObject();
response.addProperty("id", "startResponse");
response.addProperty("sdpAnswer", sdpAnswer);
session.sendMessage(new TextMessage(response.toString()));
} catch (Throwable t) {
sendError(session, t.getMessage());
}
}
Dependencies
This Java Spring application is implemented using Maven. The relevant part of the pom.xml is where Kurento dependencies are declared. As the following snippet shows, we need three dependencies: the Kurento Client Java dependency (kurento-client), the JavaScript Kurento utility library (kurento-utils) for the client-side, and the plate detector
module (platedetector):
<dependencies>
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-client</artifactId>
<version>[5.0.0,6.0.0)</version>
</dependency>
<dependency>
<groupId>org.kurento</groupId>
<artifactId>kurento-utils-js</artifactId>
<version>[5.0.0,6.0.0)</version>
</dependency>
<dependency>
<groupId>org.kurento.module</groupId>
<artifactId>platedetector</artifactId>
<version>[1.0.0,2.0.0)</version>
</dependency>
</dependencies>
Kurento framework uses Semantic Versioning for releases. Notice that ranges ([5.0.0,6.0.0) for kurento-client
and kurento-utils-js, and [1.0.0,2.0.0) for platedetector) downloads the latest version of Kurento artifacts from
Maven Central.
JavaScript Module Tutorial 4 - Plate Detector Filter
This web application consists on a WebRTC video communication in mirror (loopback) with a plate detector filter
element.
200
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
For the impatient: running this example
First of all, you should install Kurento Media Server to run this demo. Please visit the installation guide for further
information. In addition, the built-in module kms-platedetector should be also installed:
sudo apt-get install kms-platedetector
Be sure to have installed Node.js and Bower in your system. In an Ubuntu machine, you can install both as follows:
curl -sL https://deb.nodesource.com/setup | sudo bash sudo apt-get install -y nodejs
sudo npm install -g bower
Due to Same-origin policy, this demo has to be served by an HTTP server. A very simple way of doing this is by
means of a HTTP Node.js server which can be installed using npm :
sudo npm install http-server -g
You also need the source code of this demo. You can clone it from GitHub. Then start the HTTP server:
git clone https://github.com/Kurento/kurento-tutorial-js.git
cd kurento-tutorial-js/kurento-platedetector
bower install
http-server
Finally access the application connecting to the URL http://localhost:8080/ through a WebRTC capable browser
(Chrome, Firefox).
Understanding this example
This application uses computer vision and augmented reality techniques to detect a plate in a WebRTC stream on
optical character recognition (OCR).
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one for the video
camera stream (the local client-side stream) and other for the mirror (the remote stream). The video camera stream is
sent to Kurento Media Server, which processes and sends it back to the client as a remote stream. To implement this,
we need to create a Media Pipeline composed by the following Media Element s:
Figure 15.29: WebRTC with plateDetector filter Media Pipeline
The complete source code of this demo can be found in GitHub.
This example is a modified version of the Magic Mirror tutorial. In this case, this demo uses a PlateDetector
instead of FaceOverlay filter. An screenshot of the running example is shown in the following picture:
The following snippet shows how the media pipeline is implemented in the Java server-side code of the
demo. An important issue in this code is that a listener is added to the PlateDetectorFilter object
15.1. Kurento Modules
201
Kurento Documentation, Release 5.0.5
Figure 15.30: Plate detector demo in action
202
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
(addPlateDetectedListener). This way, each time a plate is detected in the stream, a message is sent to
the client side. As shown in the screenshot below, this event is printed in the console of the GUI.
kurentoClient(ws_uri, function(error, client) {
if (error) return onError(error);
client.create('MediaPipeline', function(error, p) {
if (error) return onError(error);
pipeline = p;
pipeline.create('WebRtcEndpoint', function(error, webRtc) {
if (error) return onError(error);
pipeline.create('PlateDetectorFilter', function(error, filter) {
if (error) return onError(error);
webRtc.connect(filter, function(error) {
if (error) return onError(error);
filter.connect(webRtc, function(error) {
if (error) return onError(error);
filter.on ('PlateDetected', function (data){
console.log ("License plate detected " + data.plate);
});
});
});
webRtc.processOffer(sdpOffer, function(error, sdpAnswer) {
if (error) return onError(error);
webRtcPeer.processSdpAnswer(sdpAnswer);
});
});
});
});
});
Dependencies
The dependencies of this demo has to be obtained using Bower. The definition of these dependencies are defined in
the bower.json file, as follows:
"dependencies": {
"kurento-client": "^5.0.0",
"kurento-utils": "^5.0.0",
"kurento-module-platedetector": "^1.0.0"
}
Kurento framework uses Semantic Versioning for releases. Notice that ranges (^5.0.0 for kurento-client and kurentoutils-js, and ^1.0.0 for platedetector) downloads the latest version of Kurento artifacts from Bower.
15.1. Kurento Modules
203
Kurento Documentation, Release 5.0.5
Node.js Module Tutorial 4 - Plate Detector Filter
This web application consists on a WebRTC video communication in mirror (loopback) with a plate detector filter
element.
For the impatient: running this example
First of all, you should install Kurento Media Server to run this demo. Please visit the installation guide for further
information. In addition, the built-in module kms-platedetector should be also installed:
sudo apt-get install kms-platedetector
Be sure to have installed Node.js and Bower in your system. In an Ubuntu machine, you can install both as follows:
curl -sL https://deb.nodesource.com/setup | sudo bash sudo apt-get install -y nodejs
sudo npm install -g bower
To launch the application you need to clone the GitHub project where this demo is hosted and then install and run it,
as follows:
git clone https://github.com/Kurento/kurento-tutorial-node.git
cd kurento-tutorial-node/kurento-platedetector
npm install
Finally access the application connecting to the URL http://localhost:8080/ through a WebRTC capable browser
(Chrome, Firefox).
Understanding this example
This application uses computer vision and augmented reality techniques to detect a plate in a WebRTC stream on
optical character recognition (OCR).
The interface of the application (an HTML web page) is composed by two HTML5 video tags: one for the video
camera stream (the local client-side stream) and other for the mirror (the remote stream). The video camera stream is
sent to Kurento Media Server, which processes and sends it back to the client as a remote stream. To implement this,
we need to create a Media Pipeline composed by the following Media Element s:
Figure 15.31: WebRTC with plateDetector filter Media Pipeline
The complete source code of this demo can be found in GitHub.
This example is a modified version of the Magic Mirror tutorial. In this case, this demo uses a PlateDetector
instead of FaceOverlay filter. An screenshot of the running example is shown in the following picture:
204
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
Figure 15.32: Plate detector demo in action
15.1. Kurento Modules
205
Kurento Documentation, Release 5.0.5
The following snippet shows how the media pipeline is implemented in the Java server-side code of the
demo. An important issue in this code is that a listener is added to the PlateDetectorFilter object
(addPlateDetectedListener). This way, each time a plate is detected in the stream, a message is sent to
the client side. As shown in the screenshot below, this event is printed in the console of the GUI.
function start(sessionId, sdpOffer, callback) {
if (!sessionId) {
return callback("Cannot use undefined sessionId");
}
// Check if session is already transmitting
if (pipelines[sessionId]) {
return callback("Close current session before starting a new one or use " +
"another browser to open a tutorial.")
}
getKurentoClient(function(error, kurentoClient) {
if (error) {
return callback(error);
}
kurentoClient.create('MediaPipeline', function(error, pipeline) {
if (error) {
return callback(error);
}
createMediaElements(pipeline, function(error, webRtcEndpoint,
plateDetectorFilter) {
if (error) {
pipeline.release();
return callback(error);
}
connectMediaElements(webRtcEndpoint, plateDetectorFilter,
function(error) {
if (error) {
pipeline.release();
return callback(error);
}
plateDetectorFilter.on ('PlateDetected', function (data){
return callback(null, 'plateDetected', data);
});
webRtcEndpoint.processOffer(sdpOffer, function(
error, sdpAnswer) {
if (error) {
pipeline.release();
return callback(error);
}
pipelines[sessionId] = pipeline;
return callback(null, 'sdpAnswer', sdpAnswer);
});
});
});
});
});
206
Chapter 15. Kurento Modules
Kurento Documentation, Release 5.0.5
}
Dependencies
Dependencies of this demo are managed using NPM. Our main dependency is the Kurento Client JavaScript (kurentoclient). The relevant part of the package.json file for managing this dependency is:
"dependencies": {
"kurento-client": "^5.0.0",
}
At the client side, dependencies are managed using Bower. Take a look to the bower.json file and pay attention to the
following section:
"dependencies": {
"kurento-utils": "^5.0.0",
"kurento-module-platedetector": "^1.0.0"
}
Kurento framework uses Semantic Versioning for releases. Notice that ranges (^5.0.0 for kurento-client and kurentoutils-js, and ^1.0.0 for platedetector) downloads the latest version of Kurento artifacts from NPM and Bower.
15.1. Kurento Modules
207
Kurento Documentation, Release 5.0.5
208
Chapter 15. Kurento Modules
CHAPTER 16
Kurento Java Client JavaDoc
• kurento-client-java
209
Kurento Documentation, Release 5.0.5
210
Chapter 16. Kurento Java Client JavaDoc
CHAPTER 17
Kurento JavaScript Client JsDoc
• kurento-client-js
211
Kurento Documentation, Release 5.0.5
212
Chapter 17. Kurento JavaScript Client JsDoc
CHAPTER 18
Kurento JavaScript Utils JsDoc
• kurento-utils-js
213
Kurento Documentation, Release 5.0.5
214
Chapter 18. Kurento JavaScript Utils JsDoc
Part VI
Kurento FAQ
215
Kurento Documentation, Release 5.0.5
This is a list of Frequently Asked Questions about Kurento. Feel free to suggest new entries or different wording for
answers!
217
Kurento Documentation, Release 5.0.5
218
CHAPTER 19
How do I...
...install Kurento Media Server in an Amazon EC2 instance?
You need to install a TURN server, for example coturn. Here are some instructions on how to install this
TURN server for Kurento:
1. Download the package from the project’s page.
2. Extract the contents. You should have a INSTALL file with instructions, and a .deb package. Follow
the instructions to install the package.
3. Once the package is installed, you’ll need to modify the startup script in /etc/init.d/coturn.
• Add the external and local IPs as vars:
EXTERNAL_IP=$(curl http://169.254.169.254/latest/meta-data/public-ipv4)
LOCAL_IP=$(curl http://169.254.169.254/latest/meta-data/local-ipv4)
• Modify the DAEMON_ARGS var to take these IPs into account, along with the long-term credentials user and password (kurento:kurento in this case, but could be different), realm and some
other options:
DAEMON_ARGS="-c /etc/turnserver.conf -f -o -a -v -r kurento.org
-u kurento:kurento --no-stdout-log --external-ip $EXTERNAL_IP/$LOCAL_IP"
4. Then let’s enable the turnserver to run as an automatic service daemon. For this, open the file
/etc/defaults/coturn and uncomment the key:
TURNSERVER_ENABLED=1
5. Now, you have to tell the Kurento server where is the turnserver installed. For this, modify the turnURL
key in /etc/kurento/kurento.conf.json:
"turnURL" : "kurento:kurento@<public-ip>:3478",
The following ports should be open in the firewall:
• 3478 TCP & UDP
• 49152 - 65535 UDP: As per RFC 5766, these are the ports that the TURN server will use to exchange
media. These ports can be changed using the --max-port and --min-port options from the
turnserver.
6. The last thing to do, is to start the coturn server and the media server:
sudo service coturn start && sudo service kurento-media-server restart
...configure Kurento Media Server to use Secure WebSocket (WSS)?
219
Kurento Documentation, Release 5.0.5
First, you need to change the configuration file of Kurento Media
/etc/kurento/kurento.conf.json, uncommenting the following lines:
Server,
i.e.
"secure": {
"port": 8433,
"certificate": "defaultCertificate.pem",
"password": ""
},
You will also need a PEM certificate that should be in the same path or the configuration file or you may
need to specify the full path on certificate field.
Second, you have to change the WebSocket URI in your application logic. For instance, in the hello-world
application within the tutorials, this would be done as follows:
• Java: Changing this line in HelloWorldApp.java:
final static String DEFAULT_KMS_WS_URI = "wss://localhost:8433/kurento";
• Browser JavaScript: Changing this line in index.js:
const ws_uri = 'wss://' + location.hostname + ':8433/kurento';
• Node.js: Changing this line in app.js:
const ws_uri = "wss://localhost:8433/kurento";
If this PEM certificate is a signed certificate (by a Certificate Authority such as Verisign), then you are
done. If you are going to use a self-signed certificate (suitable for development), then there is still more
work to do.
You can generate a self signed certificate by doing this:
certtool --generate-privkey --outfile defaultCertificate.pem
echo 'organization = your organization name' > certtool.tmpl
certtool --generate-self-signed --load-privkey defaultCertificate.pem \
--template certtool.tmpl >> defaultCertificate.pem
sudo chown nobody defaultCertificate.pem
Due to the fact that the certificate is self-signed, applications will reject it by default. For this reason, you
have to trust it. Regarding browser applications, it can be ignored by done via HTTPS in your browser to
the WSS port (https://localhost:8433/ with the above configuration) and accepting the certificate permanently. Regarding Java applications, follow the instructions of this link (get InstallCert.java from
here). Regarding Node applications, please take a look to this link.
...know how many Media Pipelines do I need for my Application?
Media Elements can only communicate with each other when they are part of the same pipeline. Different
MediaPipelines in the server are independent do not share audio, video, data or events.
A good heuristic is that you will need one pipeline per each set of communicating partners in a channel,
and one Endpoint in this pipeline per audio/video streams reaching a partner.
...know how many Endpoints do I need?
Your application will need to create an Endpoint for each media stream flowing to (or from) the pipeline.
As we said in the previous answer, each set of communicating partners in a channel will be in the same
Media Pipeline, and each of them will use one oe more Endpoints. They could use more than one if they
are recording or reproducing several streams.
...know to what client a given WebRtcEndPoint belongs or where is it coming from?
220
Chapter 19. How do I...
Kurento Documentation, Release 5.0.5
Kurento API currently offers no way to get application attributes stored in a Media Element. However, the application developer can maintain a hashmap or equivalent data structure mapping the
WebRtcEndpoint internal Id (which is a string) to whatever application information is desired.
221
Kurento Documentation, Release 5.0.5
222
Chapter 19. How do I...
CHAPTER 20
Why do I get the error...
...”Cannot create gstreamer element”?
This is a typical error which happens when you update Kurento Media Server from version 4 to 5. The
problem is related to the GStreamer dependency version. The solution is the following:
sudo
sudo
sudo
sudo
sudo
apt-get
apt-get
apt-get
apt-get
apt-get
remove kurento*
autoremove
update
dist-upgrade
install kurento-media-server
223
Kurento Documentation, Release 5.0.5
224
Chapter 20. Why do I get the error...
Part VII
Glossary
225
Kurento Documentation, Release 5.0.5
This is a glossary of terms that often appear in discussion about multimedia transmissions. Most of the terms are
described and linked to its wikipedia, RFC or W3C relevant documents. Some of the terms are specific to gstreamer
or kurento.
Agnostic, Media One of the big problems of media is that the number of variants of video and audio codecs, formats
and variants quickly creates high complexity in heterogeneous applications. So kurento developed the concept
of an automatic converter of media formats that enables development of agnostic elements. Whenever a media
element’s source is connected to another media element’s sink, the kurento framework verifies if media adaption
and transcoding is necessary and, if needed, it transparently incorporates the appropriate transformations making
possible the chaining of the two elements into the resulting Pipeline.
AVI Audio Video Interleaved, known by its initials AVI, is a multimedia container format introduced by Microsoft
in November 1992 as part of its Video for Windows technology. AVI files can contain both audio and video
data in a file container that allows synchronous audio-with-video playback. AVI is a derivative of the Resource
Interchange File Format (RIFF).
See also:
Wikipedia reference of the AVI format
Wikipedia reference of the RIFF format
Bower Bower is a package manager for the web. It offers a generic solution to the problem of front-end package
management, while exposing the package dependency model via an API that can be consumed by a build stack.
Builder Pattern The builder pattern is an object creation software design pattern whose intention is to find a solution
to the telescoping constructor anti-pattern. The telescoping constructor anti-pattern occurs when the increase of
object constructor parameter combination leads to an exponential list of constructors. Instead of using numerous
constructors, the builder pattern uses another object, a builder, that receives each initialization parameter step by
step and then returns the resulting constructed object at once.
See also:
Wikipedia reference of the Builder Pattern
CORS
is a mechanism that allows JavaScript code on a web page to make XMLHttpRequests to different domains than
the one the JavaScript originated from. It works by adding new HTTP headers that allow servers to serve resources to permitted origin domains. Browsers support these headers and enforce the restrictions they establish.
See also:
enable-cors.org for information on the relevance of CORS and how and when to enable it.
DOM, Document Object Model Document Object Model is a cross-platform and language-independent convention
for representing and interacting with objects in HTML, XHTML and XML documents.
EOS Acronym of End Of Stream. In Kurento some elements will raise an EndOfStream() event when the media
they are processing is finished.
GStreamer GStreamer is a pipeline-based multimedia framework written in the C programming language.
H.264 A Video Compression Format. The H.264 standard can be viewed as a “family of standards” composed of a
number of profiles. Each specific decoder deals with at least one such profiles, but not necessarily all. See
See also:
RFC 6184 RTP Payload Format for H.264 Video. This RFC obsoletes RFC 3984.
HTTP The is an application protocol for distributed, collaborative, hypermedia information systems. HTTP is the
foundation of data communication for the World Wide Web.
See also:
227
Kurento Documentation, Release 5.0.5
RFC 2616
IMS is
Mobile Architectural Framework for delivering IP Multimedia Services in 3G (and beyond) Mobile Networks.
See also:
RFC 3574
Java EE Java EE, or Java Platform, Enterprise Edition, is a standardised set of APIs for Enterprise software development.
See also:
Oracle Site Java EE Overview
Wikipedia
jQuery jQuery is a cross-platform JavaScript library designed to simplify the client-side scripting of HTML.
JSON JSON (JavaScript Object Notation) is a lightweight data-interchange format. It is designed to be easy to
understand and write for humans and easy to parse for machines.
JSON-RPC JSON-RPC is a simple remote procedure call protocol encoded in JSON. JSON-RPC allows for notifications and for multiple calls to be sent to the server which may be answered out of order.
Kurento Kurento is a platform for the development of multimedia enabled applications. Kurento is the Esperanto
term for the English word ‘stream’. We chose this name because we believe the Esperanto principles are inspiring for what the multimedia community needs: simplicity, openness and universality. Kurento is open source,
released under LGPL 2.1, and has several components, providing solutions to most multimedia common services
requirements. Those components include: term:Kurento Media Server <Kurento Media Server>, term:Kurento
API <Kurento API>, term:Kurento Protocol <Kurento Protocol>, and term:Kurento Client <Kurento Client>.
Kurento API Kurento API is an object oriented API to create media pipelines to control media. It can be seen as
and interface to Kurento Media Server. It can be used from the Kurento Protocol or from Kurento Clients.
Kurento Client A Kurento Client is a programming library (Java or JavaScript) used to control Kurento Media
Server from an application. For example, with this library, any developer can create a web application that uses
Kurento Media Server to receive audio and video from the user web browser, process it and send it back again
over Internet. Kurento Client exposes the Kurento API to app developers.
Kurento Protocol Communication between KMS and clients by means of JSON-RPC messages. It is based on
WebSocket that uses JSON-RPC V2.0 messages for making requests and sending responses.
Kurento Media Server Kurento Media Server is the core element of Kurento since it responsible for media transmission, processing, loading and recording.
Maven Maven is a build automation tool used primarily for Java projects.
Media Element A MediaElement is a module that encapsulates a specific media capability. For example, a
RecorderEndpoint, a Video PlayerEndpoint
Media Pipeline A Media Pipeline is a chain of media elements, where the output stream generated by one element
(source) is fed into one or more other elements input streams (sinks). Hence, the pipeline represents a “machine”
capable of performing a sequence of operations over a stream.
Media Plane In the traditional , the handling of media is conceptually splitted in two layers. The one that handles the
media itself, with functionalities such as media transport, encoding/decoding, and processing, is called Media
Plane.
See also:
Signaling Plane
228
Kurento Documentation, Release 5.0.5
MP4 MPEG-4 Part 14 or MP4 is a digital multimedia format most commonly used to store video and audio, but can
also be used to store other data such as subtitles and still images.
See also:
Wikipedia definition of .
Multimedia Multimedia is concerned with the computer controlled integration of text, graphics, video, animation,
audio, and any other media where information can be represented, stored, transmitted and processed digitally.
There is a temporal relationship between many forms of media, for instance audio, video and animations. There
2 are forms of problems involved in
• Sequencing within the media, i.e. playing frames in correct order or time frame.
• Synchronisation, i.e. inter-media scheduling. For example, keeping video and audio synchronized or
displaying captions or subtitles in the required intervals.
See also:
Wikipedia definition of
Multimedia container format Container or wrapper formats are metafile formats whose specification describes how
different data elements and metadata coexist in a computer file.
Simpler multimedia container formats can contain different types of audio formats, while more advanced container formats can support multiple audio and video streams, subtitles, chapter-information, and meta-data,
along with the synchronization information needed to play back the various streams together. In most cases, the
file header, most of the metadata and the synchro chunks are specified by the container format.
See also:
Wikipedia definition of
NAT, Network Address Translation Network address translation (NAT) is the technique of modifying network address information in Internet Protocol (IP) datagram packet headers while they are in transit across a traffic
routing device for the purpose of remapping one IP address space into another.
See also:
definition at Wikipedia
NAT-T, NAT Traversal NAT traversal (sometimes abbreviated as NAT-T) is a general term for techniques that establish and maintain Internet protocol connections traversing network address translation (NAT) gateways, which
break end-to-end connectivity. Intercepting and modifying traffic can only be performed transparently in the
absence of secure encryption and authentication.
See also:
NAT Traversal White Paper White paper on NAT-T and solutions for end-to-end connectivity in its presence
Node.js Node.js is a cross-platform runtime environment for server-side and networking applications. Node.js applications are written in JavaScript, and can be run within the Node.js runtime on OS X, Microsoft Windows and
Linux with no changes.
npm npm is the official package manager for Node.js.
OpenCL OpenCL™ is standard framework for cross-platform, parallel programming of heterogeneous platforms
consisting of central processing units (CPUs), graphics processing units (GPUs), digital signal processors
(DSPs), field-programmable gate arrays (FPGAs) and other processors.
OpenCV OpenCV (Open Source Computer Vision Library) is a BSD-licensed open source computer vision and
machine learning software library. OpenCV aims to provide a common infrastructure for computer vision
applications and to accelerate the use of machine perception.
229
Kurento Documentation, Release 5.0.5
Pad, Media A Media Pad is is an element´s interface with the outside world. Data streams from the MediaSource
pad to another element’s MediaSink pad.
See also:
GStreamer Pad Definition of the Pad structure in GStreamer
Kurento MediaPad Kurento Media API Java interface for the MediaPad
PubNub PubNub is a publish/subscribe cloud service for sending and routing data. It streams data to global audiences
on any device using persistent socket connections. PubNub has been designed to deliver data with low latencies
to end-user devices. These devices can be behind firewalls, NAT environments, and other hard-to-reach network
environments. PubNub provides message caching for retransmission of lost signals over unreliable network
environments. This is accomplished by maintaining an always open socket connection to every device.
QR QR code (Quick Response Code) is a type of two-dimensional barcode. that became popular in the mobile phone
industry due to its fast readability and greater storage capacity compared to standard UPC barcodes.
See also:
Entry in wikipedia
REST
is an architectural style consisting of a coordinated set of constraints applied to components, connectors, and
data elements, within a distributed hypermedia system. The term representational state transfer was introduced
and defined in 2000 by Roy Fielding in his doctoral dissertation.
RTCP The is a sister protocol of the RTP, that provides out-of-band statistics and control information for an RTP
flow.
See also:
RFC 3605
RTP The is a standard packet format designed for transmitting audio and video streams on IP networks. It is used in
conjunction with the RTP Control Protocol. Transmissions using
typically use SDP to describe the technical parameters of the media streams.
See also:
RFC 3550
Same-origin policy The is web application security model. The policy permits scripts running on pages originating
from the same site to access each other’s DOM with no specific restrictions, but prevents access to DOM on
different sites.
SDP, Session Description Protocol The describes initialization parameters for a streaming media session. Both
parties of a streaming media session exchange SDP files to negotiate and agree in the parameters to be used for
the streaming.
See also:
RFC 4566 Definition of Session Description Protocol
RFC 4568 Security Descriptions for Media Streams in SDP
Semantic Versioning
Semantic Versioning is a formal convention for specifying compatibility using a three-part version number:
major version; minor version; and patch.
Signaling Plane It is the layer of a media system in charge of the information exchanges concerning the establishment
and control of the different media circuits and the management of the network, in contrast to the transfer of
media, done by the Signaling Plane.
230
Kurento Documentation, Release 5.0.5
Functions such as media negotiation, QoS parametrization, call establishment, user registration, user presence,
etc. as managed in this plane.
See also:
Media Plane
Sink, Media A Media Sink is a MediaPad that outputs a Media Stream. Data streams from a MediaSource pad to
another element’s MediaSink pad.
SIP
is a signaling plane protocol widely used for controlling multimedia communication sessions such as voice and
video calls over Internet Protocol (IP) networks. SIP works in conjunction with several other application layer
protocols:
• SDP for media identification and negotiation
• RTP, SRTP or WebRTC for the transmission of media streams
• A TLS layer may be used for secure transmission of SIP messages
Source, Media A Media Source is a Media Pad that generates a Media Stream.
SPA, Single-Page Application A single-page application is a web application that fits on a single web page with the
goal of providing a more fluid user experience akin to a desktop application.
Sphinx Documentation generation system used for kurento documentation
See also:
Easy and beautiful documentation with Sphinx
Spring Boot Spring Boot is Spring’s convention-over-configuration solution for creating stand-alone, productiongrade Spring based applications that can you can “just run”. It embeds Tomcat or Jetty directly and so there is
no need to deploy WAR files in order to run web applications.
SRTCP SRTCP provides the same security-related features to RTCP, as the ones provided by SRTP to RTP. Encryption, message authentication and integrity, and replay protection are the features added by SRTCP to RTCP.
See also:
SRTP
SRTP
is a profile of RTP (Real-time Transport Protocol), intended to provide encryption, message authentication and
integrity, and replay protection to the RTP data in both unicast and multicast applications. Similar to how
RTP has a sister RTCP protocol, SRTP also has a sister protocol, called Secure RTCP (or SRTCP);
See also:
RFC 3711
SSL Secure Socket Layer. See TLS.
TLS
and its prececessor Secure Socket Layer (SSL)
See also:
RFC 5246 Version 1.2 of the Transport Layer Security protocol
TURN, Traversal Using Relays around NAT TURN is a protocol that allows for a client behind a NAT or firewall
to receive incoming data over TCP or UDP connections.
231
Kurento Documentation, Release 5.0.5
VP8 VP8 is a video compression format created by On2 Technologies as a successor to VP7. Its patents rights are
owned by Google, who made an irrevocable patent promise on its patents for implementing it and released a
specification under the Creative Commons Attribution 3.0 license.
See also:
RFC 6386 VP8 Data Format and Decoding Guide
VP8 page at Wikipedia
WebM WebM is an open media file format designed for the web. WebM files consist of video streams compressed
with the VP8 video codec and audio streams compressed with the Vorbis audio codec. The WebM file structure
is based on the Matroska media container.
WebRTC WebRTC is an open source project that provides rich Real-Time Communcations capabilities to web
browsers via Javascript and HTML5 APIs and components. These APIs are being drafted by the World Wide
Web Consortium (W3C).
See also:
WebRTC Working Draft
WebSocket WebSocket specification (developed as part of the HTML5 initiative) defines a full-duplex single socket
connection over which messages can be sent between client and server.
232
Index
A
M
Agnostic, Media, 227
AVI, 227
Maven, 228
Media
Element, 131
Pad, 230
Pipeline, 228
Sink, 231
Source, 231
Media Element, 228
Media Pipeline, 228
Media Plane, 228
MP4, 229
Multimedia, 229
Multimedia container format, 229
B
Bower, 227
Builder Pattern, 227
C
CORS, 227
D
Document Object Model, 227
DOM, 227
E
EOS, 227
G
GStreamer, 227
H
H.264, 227
HTTP, 227
I
N
NAT, 229
NAT Traversal, 229
NAT-T, 229
Network Address Translation, 229
Node.js, 229
npm, 229
O
OpenCL, 229
OpenCV, 229
IMS, 228
P
J
Pad, Media, 230
Pipeline: single
Media, 131
Plane
Media, 228
Signaling, 230
PubNub, 230
Java EE, 228
jQuery, 228
JSON, 228
JSON-RPC, 228
K
Kurento, 228
Kurento API, 228
Kurento Client, 228
Kurento Media Server, 228
Kurento Protocol, 228
Q
QR, 230
R
REST, 230
233
Kurento Documentation, Release 5.0.5
RFC
RFC 2616, 227
RFC 3550, 230
RFC 3574, 228
RFC 3605, 230
RFC 3711, 231
RFC 3984, 227
RFC 4566, 230
RFC 4568, 230
RFC 5246, 231
RFC 6184, 227
RFC 6386, 232
RTCP, 230
RTP, 230
S
Same-origin policy, 230
SDP, 230
Semantic Versioning, 230
Session Description Protocol, 230
Signaling Plane, 230
Single-Page Application, 231
Sink, Media, 231
SIP, 231
Source, Media, 231
SPA, 231
Sphinx, 231
Spring Boot, 231
SRTCP, 231
SRTP, 231
SSL, 231
T
TLS, 231
Traversal Using Relays around NAT, 231
TURN, 231
V
VP8, 232
W
WebM, 232
WebRTC, 232
WebSocket, 232
234
Index