We specialize in databases, Web sites, cloud services, ERP and mobile apps with a focus on service: we help businesses invent the tools that really fit Â
kurento-room-client-android is a Java library for Android. This library can be used to deploy applications for interac- tion with Kurento room server. This documentation Provides help on how to install and use the library.
Source code is available at https://github.com/nubomedia-vtt/kurento-room-client-android.
Support is provided through the Nubomedia VTT Public Mailing List available at https://groups.google.com/forum/#!forum/nubomedia-vtt
Identifikasi Masalah
Salah satu permasalahan yang ada di klien Kurento Room berbasis android adalah koneksi websocket ke server. Kurento Room secara default menggunakan Maven org.java_websocket yang bisa diakses di situs resmi repositori Maven https://mvnrepository.com/artifact/org.java-websocket/Java-WebSocket/1.3.0 atau kode sumber nya bisa juga dilihat di Github https://github.com/TooTallNate/Java-WebSocket, kalau dilihat di Github tertulis terakhir update sekitar 2 tahun yang lalu (terhitung saya mempublikasikan tulisan ini). Dan terjadi banyak kendala pada umumnya untuk membangun koneksi ke sever kurento room yang berbasis SSL. Dokumentasi kurento room secara resmi mengatakan dalam tulisannya; https://media.readthedocs.org/pdf/doc-kurento-room-client-android/latest/doc-kurento-room-client-android.pdf
However, org.java_websocket version 1.3.0 is not compatible with Android 5.0.x systems due to malfunction in wss protocol handshake. Until a newer version is uploaded to Maven, a workaround is to compile a newer version from git: https://github.com/TooTallNate/Java-WebSocket
This limitation is known to exist only in wss TSL handshake. Android 5.1.x and up should not have this issue.
Kadang tidak seperti yang tertulis disana “This limitation is known to exist only in wss TSL handshake. Android 5.1.x and up should not have this issue”, saya pernah mencoba menggunakan dengan versi Android 5.1.1 dan masih sering terjadi masalah terutama diproses SSL handshaking nya.
Kenapa menggunakan nv-websocket-client?
Seperti tertulis di Github, nv-websocket-client (High-quality WebSocket client implementation in Java) memproklamirkan diri sebagai WebSocket yang mempunyai kualitas tinggi (high-quality websocket) dengan spesifikasi sebagai berikut:
complies with RFC 6455 (The WebSocket Protocol),
works on Java SE 1.5+ and Android,
supports all the frame types (continuation, binary, text, close, ping and pong),
provides a method to send a fragmented frame in addition to methods for unfragmented frames,
provides a method to get the underlying raw socket of a WebSocket to configure it,
provides a method for Basic Authentication,
provides a factory class which utilizes javax.net.SocketFactory interface,
provides a rich listener interface to hook WebSocket events,
has fine-grained error codes for fine-grained controllability on errors,
allows to disable validity checks on RSV1/RSV2/RSV3 bits and opcode of frames,
supports HTTP proxy, especially "Secure WebSocket" (wss) through "Secure Proxy" (https),
and supports RFC 7692 (Compression Extensions for WebSocket), also known as permessage-deflate (not enabled by default).
Arisitektur jaringan client-server
Arsitektur jaringan klien-server kurento room yang saya implementasikan adalah seperti ini:
Android klien => Cloudflare  => Server Nginx (sebagai proxy) => server Kurento Room
Kalau kita lihat seperti diatas adalah ada beberapa sertifikat SSL yang perlu disiapkan, yaitu kita harus mendapatkan sertifikat ssl dari cloudflare, server nginx dan server kurento (jika nginx mempunyai sertifikat ssl yang berbeda dengan sertifikat server kurento room yang biasanya dalam format java keystore). Buat satu sertifikat ssl dalam format BKS yang nanti akan kita jadikan untuk proses jabat tangan (handshaking) antara klien (dalam hal ini android) ke server websocket dengan ssl (wss) kurento room tadi. Anda bisa mencari berbagai literatur untuk proses pembuatan sertifikat dalam format BKS ini.
We often get requests from IT specialists and system integrators to tell about the key differences between solutions by TrueConf and Vidyo.
Indeed, both companies have a similar approach in increasing capacity of video conferencing servers (so called MCU) by using the latest technologies, including scalable video coding (SVC), and by avoiding unnecessary transcoding and mixing of the video streams on the server. In other words, both solutions useswitching video conferencing architecture compared to legacy MCUs with mixing and transcoding. System’s capacity and scalability are limited only by the network’s bandwidth not by CPU or DSP calculation power.
In first part of our comparison we will address infrastructure differences between TrueConf and Vidyo. We hope that it will help you to better understand the current offerings on the video conferencing market.
Contents
What TrueConf and Vidyo Have in Common
Difference in Ideology
Infrastructure Comparison
What TrueConf and Vidyo Have in Common
These two pictures look alike at the first glance: they both shows the same functionality, but principles on which they are built differ radically. These features, as we believe, belong to video conferencing systems of current and future generations.
Let’s start with the general, but the most important features that distinguish TrueConf and Vidyo from Polycom/Cisco/LifeSize/Radvision/ClearOne/Huawei/ZTE or other standard based legacy VC solutions.
Both solutions utilize their own proprietary protocols: based on UDP, in the case of Vidyo, and based on TCP, in case of TrueConf. Why we chose TCP, you may ask? The answer is simple: it’s easier to get through a Firewall/NAT/Proxy, it also needs just one TCP port (4307) to be opened; but most important it allows us to adjust video streams to changing network conditions almost instantly delivering great network resiliency.
Interoperability with third-party equipment including standard based legacy video conferencing solutionsrequires a gateway that converts streams from one protocol to another. At the same time video and audio streams are not always necessary to transcode from one codec to another.
Both solutions are NOT engaged in decoding, resizing and mixing of several video streams into one during group video conferences. They don’t need a transcoding, which requires a lot of processing power and causes high upfront costs as it happen when classic MCUs are deployed.
On the contrary, they use modern video codecs extensions and algorithms that support scalable video coding, which allow you to do the same conversion of video streams without high CPU/DSP load on the server, where final layout is composed on endpoint from multiple video streams. This approach is usually called Switching.
Paragraph 3 also explains an extraordinary ability of these systems to deliver video streams optimized for channel capacity, screen, camera and CPU capabilities of each individual participant and it’s layout. And all of this is achieved by simple drop of data packets in the network flows without any significant computations on the server side.
Without transcoding, the video conferencing server does not cause any delays in the communication session.
You can thank specialists in data compression and algorithms, and, of course, Gordon Moore’s law for such dramatic changes in the world of video conferencing.
As a result, the system requirements for Switching servers are significantly lower than for the MCU-like ones. What is more important the end user will not see any difference in quality between them. Moreover,the cost of video conferencing infrastructure lowers by reducing the cost of server itself, shorter deployment period, using desktops and mobiles as terminals, and relatively simple scalability.
Difference in Ideology
The first thing to understand is that Vidyo sells hardware devices, despite the fact that they use ordinary PCs to build them. For customers who got used to deal with legacy products made by Cisco/Polycom this is a more familiar approach, but in terms of technology there is no need to complicate things up and ship hardware any more.
TrueConf video conferencing solutions are 100% software, which can be downloaded from our websitewith free trial available. Even our TrueConf Terminal for meeting rooms can be purchased as a software license and assembled with any peripheral equipment. We do not make the problem more difficult – everything is as simple as possible and we will provide the details later in this article.
You can only test Vidyo through the Internet by connecting to a local service provider or reseller’s Vidyo infrastructure. You will not be able to test Vidyo solution in “action” in your private network conditions until you buy yourself a set of hardware.
Infrastructure Comparison
The schemes clearly show that both solutions work with various terminals on different protocols. But in case of Vidyo, you need to pay attention to the fact that the basic video conferencing functionality is done by device called VidyoRouter. Additional features, such as a gateway, which is required to connect to solutions based on other protocols, recording, NAT traversal features require purchasing and deployment of additional hardware.
On the other hand, these modules are already included as a part of TrueConf Server software. You will not have to expand video conferencing infrastructure, wait for the delivery of equipment or customize it. Everything is installed and ready to use immediately after the launch. TrueConf Server deployment time in the local network takes several minutes.
You can see a comparative table of tasks for which Vidyo solutions require increased investment in infrastructure, while increasing its complexity:
VidyoRouter
1U Rack mount.
Up to 150 concurrent connections in XL version.
Virtualization: VidyoRouter VE for VMware® ESXi™.
TrueConf Server
Can be installed on any compatible PC
Up to 2000 concurrent connections per instance.
Compatible with any virtual platforms that can run Microsoft Windows Server.
VidyoPortal
(device is sold separately)
System management via web browser.
Conferences scheduling.
Management for users groups, tenants and polices.
LDAP / Active Directory integration
Personal area for users to host and join conferences.
Built-in Web Manager
All settings can be securely accessed and managed remotely via browser
Conferences scheduling and management.
Users groups, polices and multi-tennacy supported.
LDAP / AD supported as well
Users can use client apps for Windows, Linux, OS X, Android and iOS to create Ad-hoc conferences.
Learn more →
VidyoGateway
(device is sold separately)
Gateway for connecting to H.323/SIP devices.
Supports single 720p connection.
Up to 2x 1080p or up to 5x 720p connections per device in XL version.
Built-in Multi Gateway
Up to 10x HD 720p connections via SIP per each TrueConf Server instance*.
Support RTSP protocol used in IP-cameras.
Communicate natively with WebRTC peers via VP8 SVC.
Can host multi-protocol video conferences, eg. Native + WebRTC + SIP.
H.323 is coming soon.
Learn more →
VidyoReplay
(device is sold separately)
Video conference recording.
Webcast of video conferences (one-way communication).
Included in TrueConf Server
Recording is available in client applications and on the server side.
WebRTC client can be used for streaming.
VidyoWeb
(browser plug-in)
Requires installation of a plug-in for the corresponding browser on the client side.
Collaboration features and content sharing available.
Video resolution up to HD 720p.
Built-in WebRTC Support
Plugin-free web-based video conferences in browser.
Can display content as video in a mixed layout.
VP8 SVC powered mixed video up to 720p.
* Higher system requirements may apply.
In the second part of our review we will focus on Vidyo and TrueConf client applications / terminals and licensing aspects and make a conclusion of what we found in our review.
Google just announced that the upcoming release of its Chrome browser, version 48, will have VP9 support for WebRTC.  This is an important milestone for WebRTC and Chrome for a number of reasons.  To appreciate why, it is useful to look a little bit at the history of video codec support in WebRTC as well as Google+ Hangouts, Google’s popular videoconferencing app.
When Google+ Hangouts was originally launched, it used H.264 SVC, the scalable video coding extension of H.264 that Vidyo co-developed.  The use of scalability in the video codec is essential for implementing a radically different server design for multipoint video, able to deliver an unprecedented range of features: error resilience and localization, rate adaptation, personalized layout, cascading, etc.  More significantly, all this is done with extremely low delay (an order of magnitude less than a typical transcoding MCU), at a massive scale, and without any signal processing at the server.  Vidyo introduced this server design in 2008 in its patented VidyoRouter™ product.
Hangouts moved to use the open-source VP8 video codec in August 2013 so that, among other things, the client could eventually run over WebRTC as explained in interviews by senior Google management. As VP8 does not offer spatial scalability, a simpler version of it called simulcasting was used.  With this technique an endpoint produces multiple video streams at different bit rates and resolutions.  The server receives both, and selects which one to forward to receiving participants. (We later on coined the term “Selective Forwarding Unit”, or SFU, to describe the operation of these servers in a generic way.)
At the same time the transition to VP8 was being made, Vidyo and Google announced that Vidyo would be collaborating with Google to develop a scalable extension for the VP9 video codec as part of the WebRTC client open source project. Â The goal is to combine the power of WebRTC with the benefits of scalability to be able to deliver the best possible experience for the end users.
The inclusion of VP9 in WebRTC in Chrome 48 marks an important milestone in this collaboration. Â It is the first widely available software release of this new codec (outside a flag, across all Chrome platforms). The release incorporates the proposed standard RTP packetization for VP9, which was co-designed and developed with Vidyo and Google, and which supports the new scalability features. Â Spatial and temporal scalability features in the codec itself are already in the WebM and WebRTC code repositories.
As additional experience in deployed applications is obtained, and appropriate API support is made available at the WebRTC layer, we expect they will find their way into future versions of the Chrome browser in a backwards-compatible way.
Vidyo has utilized scalable coding to built a new server architecture for large-scale, very high quality video communication, on virtually any network and device. Â This architecture excels in environments that require large scale and/or are hosted in the cloud. Â It is also inherently codec-agnostic: the choice of the codec, from an infrastructure point of view, is purely a business decision. Â As long as scalability is available, then the infrastructure can perform its magic.
We are very excited that we will soon be able to bring the proven benefits of this design to the WebRTC world. While this release is the first step, as the saying goes, the first step is half the journey.
Mobile video calling demands consistently high QoE
A range of client, network and traffic variables affect QoE
New network designs and smarter algorithms will improve QoE
Today’s networks are “big” enough but not necessarily “fast” enough when it comes to mobile video calling. What are the key factors that influence quality of experience (QoE) for mobile video calls and are residential broadband networks ready for it?
WANTED: A BETTER MOBILE VIDEO CALLING EXPERIENCE
Today, mobile video calling applications largely depend on video adaptation algorithms, advanced codecs on clients and an overlay peer-to-peer network to optimize QoE.
But QoE for mobile video calling depends on more than the success of these techniques. It also depends on the network, competing traffic and the video “engine” in the client application. For example:
Is there sufficient link bandwidth available for video calling?
Is the network channel “stable,” and does it provide high throughput, low latency links?
Does a prioritization scheme provide the necessary bandwidths among competing traffic flows?
Are the video and audio codecs agile enough to operate with varying link bandwidths, with very low bandwidths?
How quickly can client applications process video streams in real time?
The Bell Labs study found that some of the factors listed above have a major effect on QoE for mobile video calling, while others have almost none at all.
SIGNIFICANT ISSUE: LINK BANDWIDTH
For video calling applications that generate large traffic volumes, maintaining high throughput on both downstream and upstream links is critically important. In today’s asymmetrically provisioned networks, the upstream link becomes the bottleneck in video calls.
As shown in Table 1, major residential broadband networks in the U.S. provide greater speeds on downlinks than on uplinks. It is interesting to note that Long Term Evolution (LTE) mobile broadband networks now offer uplink speeds that exceed those of Digital Subscriber Line (DSL) residential broadband networks. With these speeds, the news of LTE smartphones with integrated Skype™ mobile video calling is not surprising.
Link speed stability also affects mobile video calling applications. Studies have found that high variations in residential broadband link speeds over the short term create challenges for mobile video calling applications, even if speeds remain stable over the longer term.
SIGNIFICANT ISSUE: VIDEO ADAPTATION TO CHANGES IN LINK BANDWIDTH
In addition to the type of video and audio codec used, today’s video calling applications primarily distinguish QoE through video adaptation algorithms — bit-rate control and Forward Error Correction (FEC) mechanisms — that react to network congestion and random loss. Different reactions lead to different quality of experience.
Most bit-rate control mechanisms reduce the transmission rate when congestion is detected and optimized for the available bandwidth. Generally, applications consider packet loss as a sign of congestion. However, in wireless networks packet loss can occur randomly due to signal fade, radio frequency (RF) interference and other channel impairments. If the application interprets all packet losses as congestion, it will incorrectly reduce its transmission rate during random loss, hence lowering QoE.
A “smarter” mobile video calling application distinguishes between congestion and random loss. To make this distinction, the application must monitor packet delay and packet loss. During congestion, packet delay should spike, while with random loss packet delay should not change.
To avoid packet loss regardless of link conditions, the transmission rate should always adjust promptly to changes in bandwidth. In addition, when a minimum bit rate is reached, a video call should be dropped (audio only) to prevent artifacts due to high packet losses.
Theoretically, video codecs should adapt to bandwidth changes by supporting any requested bit rate. This “coarseness” of bit rates provides the flexibility to adapt to highly variable links. It is key to making the best use of available link bandwidth — especially with modern codecs like H.264 where there is a high correlation between frames.
SIGNIFICANT ISSUE: PACKET LATENCY
For two-way, real-time mobile video calling, the packet latency, or delay, on upstream links is particularly critical. Packet delay is comprised of:
Propagation delay: The amount of time it takes for a signal to travel from sender to receiver.
Transmission delay: The amount of time required to push all the bits in a packet into the wire.
Queuing delay: The wait time due to queues in the network to avoid packet dropping.
Queuing delays are typically the largest contributor to total packet delay. Studies have shown that queuing delays can reach 600 ms in DSL networks and 2 or more seconds in cable networks (due to large queues in some of these residential access networks).
For interactive applications, the ITU G.114 standard recommends a maximum one-way delay of 150 ms because most users notice a round-trip delay of 250 ms or more. As a result, ideally, mobile video calls should not exceed 250 ms for end-to-end packet delay.
Jitter can also affect packet delay and must be taken into account. Jitter can cause adaptive protocols that interpret Round Trip Time (RTT) changes as a sign of congestion to begin congestion avoidance too early.
Recent Bell Labs research has suggested there are “buffer bloats” in many network elements, including operating systems and hosts, Network Interface Cards (NICs) and routers. Together, these “bloats” can cause significant delays in the network despite continued increases in bandwidth capacity. Any large upstream queue delays will impair mobile video call QoE.
SIGNIFICANT ISSUE: COMPETING TRAFFIC FLOWS
With more and more connected devices, and the popularity of video streaming applications such as Netflix and YouTube, the impact of competing traffic on mobile video calling QoE is expected to become a dominant challenge.
A typical video calling application simply relies on network variables — available bandwidth, packet loss, and jitter — to throttle video and audio bit rates. It has no visibility of other applications that are competing for shared network resources.
To a mobile video calling application, competing traffic is reflected as lower available bandwidth. With no centrally controlled prioritization mechanism, applications simply compete for available bandwidth. That means a video calling application with a good video adaptation algorithm can actually penalize itself. As it adapts its bit rate for the bandwidth, other applications consume any available bandwidth.
Controlled prioritization mechanisms to “manage” competing traffic can be client-based, network-based, or a combination.
In a client-based approach, the mobile operating system (OS) platform gives priority to a certain application and its traffic over others for a given set of use cases. For example, the Apple® iPhone® and Microsoft® Windows® Phone 7 support multi-tasking in a “controlled” fashion. Multiple applications can run at the same time, but the OS gives priority to applications, such as VoIP, over others. And not all applications can run simultaneously.
In the network-based approach, network bandwidth allocation and traffic prioritization can be done at the home router or home service gateway — based on user specifications and real-time application requirements, for example.
In a combination approach, competing traffic is prioritized by the client and the network. This approach provides prioritization control down to a specific device for a given home network. For example, traffic from a video calling application connected through a TV may be given a higher priority than traffic from that same application on a smartphone.
SECONDARY CONCERN: VIDEO AND AUDIO CODEC PERFORMANCE
Although there are numerous video codec standards, the most common ones used on consumer electronic devices are H.264, On2 VP7, and likely WebM on future Android devices.
H.264 is the most popular codec for mobile video calling applications today. H.264 is reported to provide 50 percent bit-rate savings. That means it can deliver the same quality at half the bit rate compared to previous generation MPEG-2, H.263 or MPEG-4 Part 2 codecs.
With the scalability and compressed bit rates that can be achieved with modern codecs, they are becoming a minor issue in QoE evaluation.
MINIMAL EFFECT: PACKET LOSS
Most DSL and cable networks have very low packet loss rates — typically below 1 percent, and 3G/LTE networks are engineered for low packet loss rate (typical target of 0.01 percent to 1 percent depending on the application). In addition, some DSL uplinks actively manage queues by proactively dropping packets using congestion avoidance algorithms such as Random Early Detection (RED).
Packet loss is likely an insignificant factor in QoE for mobile video calls in residential broadband networks, considering these networks show remarkably low loss rates.
MINIMAL EFFECT: VIDEO PROCESSING POWER
Rapid innovation in mobile processor technologies means most smartphones and tablets now feature 1 GHz processors with built-in hardware graphics and video acceleration. They also feature the latest and fastest video and graphics processing chips.
With the trend toward multicore processors with integrated Graphics Processing Units (GPUs), the video processing power on client devices is not an issue for mobile video calling. The only consideration is the impact of video processing on battery life.
TOWARD MASS-MARKET ADOPTION
The network obstacles currently limiting QoE for mobile video calling can be addressed. Immersive applications, such as mobile video calling, will require new network designs and smarter algorithms to manage competing traffic on access and home networks.
A home service gateway that can prioritize traffic by pre-allocating and dynamically adjusting link bandwidths based on user preferences could also improve QoE for mobile video calling. For the wireless network, the mobile video calling service will likely require mapping to a quality of service (QoS) Class Identifier (QCI). It will also require priority weighting or guaranteed bit rates (GBRs) in base stations.
The Alcatel-Lucent Open API QoS (OAQ) solution provides this user-controlled prioritization by providing application programming interfaces (APIs) for the ACP client or server to specify which flow(s) get priority through the network. Moreover, the use of Data Packet Inspection (DPI) using the application-aware functionality in the Alcatel-Lucent 7750 Service Router (7750 SR) and its Multiservice Integrated Service Adapter (MS-ISA) blade can provide another helpful way to mark and prioritize traffic in the network. With these types of technology enhancements — along with adoption of new business models and resolution of regulatory challenges — mobile video calling has the potential to move into the mainstream.
To contact the author or request additional information, please send e-mail to [email protected].
FOOTNOTES
[1] The study defined mobile video calling broadly from a client device perspective — real-time video calls conducted through mobile devices over wireless LANs (WLANs) through fixed broadband or 3G/LTE mobile networks.
Traccar is an open source GPS tracking system for various GPS tracking devices. System supports more than 80 different communication protocols from popular vendors. Traccar includes web interface (view demo) to manage tracking devices online.
Server is written in Java and portable between most operating systems and platforms. At the moment official installation packages are provided for Windows, Mac OS X and Linux. You can get installer from the download page. For installation and configuration details please see quick start guide or documentation index.
One of the main project’s missions is to support as many tracking devices as possible. Check your device in the list of supported devices. If your device is not in the list, please contact me to implement support for it.
Traccar is completely free and open source. Traccar software is licensed under the Apache License 2.0.
For any question, problems or requests please visit support page.
Traccar Client
Traccar Client is fully compatible with Traccar Server and you can use it with your own hosted instance of Traccar. Other popular GPS tracking platforms support Traccar Client apps as well.
* In addition to standard version available on the Google Play, Traccar Client for Android comes in a special hidden version. It includes modifications to make the app less visible to the phone’s owner. Name is changed from “Traccar Client” to “Device Settings”. Default Android settings icon is used as an app icon. After first start, the app removes itself from the launcher. To open it again dial 8722227 (TRACCAR).
All Traccar Client apps are open source. Source code is available on GitHub under the Apache License 2.0 licence.
Source code:Â https://github.com/tananaev/traccar
Traccar WebUI
To support your traccar WebUI with geofence feature, device management, report, tracking history, recording device trace and more powerfull features, you could change or upgrade your webUI with Traccar Web UI mod http://traccar.litvak.su/. WebUI mod Source code available at github https://github.com/vitalidze/traccar-web. Step by step webUI installation at http://traccar.litvak.su/installation.html
JHipster is a Yeoman generator, used to create a Spring Boot + AngularJS project. An Open Source application generator for creating Spring Boot + AngularJS projects in seconds! http://jhipster.github.io
Goal
Our goal is to generate for you a complete and modern Web app, unifying:
A high-performance and robust Java stack on the server side with Spring Boot
A sleek, modern, mobile-first front-end with AngularJS and Bootstrap
A powerful workflow to build your application with Yeoman, Bower, Gulp and Maven
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.
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.
Typical WebRTC Media Server capabilities
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.
Kurento Media Server capabilities
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 FaceOverlayFilterdetects 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.
Some Media Elements provided out of the box by Kurento
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.
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 theWebRtcEndpoint (which is capable of receiving WebRTC streams) to be feed to theRecorderEndpoint (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 calledWebRtcPeer. Nevertheless, the standard WebRTC API (getUserMedia, RTCPeerConnection, and so on) can also be used to connect to WebRtcEndpoints. For further information please visit thetutorials section.
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, 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.
At Kurento we strive to provide services for developers of advanced video applications for the Web and smartphone platforms. We found that a common use case is represented by multi-party group calls requiring a media server for advanced media processing.
This project introduces the Rooms API, designed for the development of conferencing applications whose centerpiece is the Kurento Media Server. The conference groups (rooms) will be managed using the API, which at the same time provides the means to interconnect the end-users through a Kurento Media Server instance.
The API’s core module, Room SDK, is a Java library for the server-side and has the main functionality of managing multi-conference sessions.
Additionally, we provide extra components that can be used when developing applications that follow the architecture depicted above:
Room Server: a container-based implementation of the server, uses JSON-RPC over WebSocketsfor communications with the clients
Room JavaScript Client: module implementing a Room client for Web applications (works with the Room Server only)
Room Client: a client library for Java web applications or Android clients (works with the Room Server only)
Core API
The core module defines a programming model for applications developed using the Java language. Some of the benefits from using this library:
control over the lifecycle of a multimedia conference (room)
access to typical operations required for managing the participants (join, exit, publish or receive media streams, etc.)
simple media signaling, the application is required only to provide the media initialization and negotiation parameters received from the clients
multimedia legs or service topologies are hidden by default (media elements like image filters can still be applied to a participant’s stream)
This component requires access to at least one instance of a Kurento Media Server for WebRTCmedia handling.
Developers can integrate this API directly into their application, but it’s important to understand that this library doesn’t possess, on its own, the ability to communicate with the clients. Further details can be found in the core API section.
Other components
Our server implementation, the Room Server, packs the functionality from the Room SDK with technologies such as Spring Boot and JSON-RPC over WebSockets. As such, it combines the client communications component and the core Room API, providing a fully-fledged Rooms server application. It can be easily integrated into other applications that use the Spring Boot framework.
Both client libraries are designed to be used in combination with the Room Server, as for signaling they use the JSON-RPC API exposed by our server component.
The Java client doesn’t deal with media handling but only defines a Java API over the JSON-RPC protocol supported by the Room Server.
On the other hand, the JavaScript client also controls the browser’s media initialization and negotiation details, enabling the developer to focus on application functionality.
At the moment, there is no iOS client available.
Also, please observe that the server’s WebSocket API has a limitation concerning an user’s name, which is that it cannot contain lower dashes.
Integration example
The Room Demo module is a Single-Page Application based on the Room Server and the Room JavaScript Client. It enables users to simultaneously establish multiple connections to other users connected to the same session or room.
Please note that even though the core module is the Room SDK, developers are free to pick whatever component they need in order to build their application: some might need some minor modifications on the client side, whilst others would want to inject their logic on server side and might even have to modify the SDK.
For example, the demo shows how to integrate some of the provided components together with the client-side technology AngularJS and some small modifications of the server (adds a image filter for the video streams and a custom message type).
We provide a Quick start guide for the demo’s installation and execution.
There’s also a short Developer guide for applications based on this API.
As depicted in the figure below, Kurento architecture comprises three main componentsÂ
Figure 1. Kurento architecture which provides three main components. Kurento Application Server (right), Kurento Media Server (left) and Kurento client side capabilities (top).
Kurento Application Server (KAS): This consists on a Java EE compatible container (such as JBoss, Tomcat or equivalent) on top of which the Kurento Media Framework (KMF) is deployed. KMF has been conceived to provide Java developers a rich toolbox suitable for satisfying common requirements emerging in multimedia services. KMF comprises two sub APIs.
Kurento Media Server (KMS): KMS is the core of the Kurento infrastructure. It is a media server written on top of GStreamer, which offers different types of media capabilities such as media reception and delivery through different protocols and formats (e.g. RTP, SRTP, HTTP, etc.), media transcoding for the most popular formats and codecs (e.g. H.264, H.263, VP8, etc.), media recording, media playing, computer vision, augmented reality and others.
Kurento client side APIs: These include Kurento Web SDK (KWS) and Kurento Android SDK (KANDS). Both of them make possible to access Kurento infrastructure capabilities in a simple and seamless manner.
Content API: This is a signaling API, meaning that it is in charge of managing control communications with the client. It provides developers the ability to specify the application logic that executes when specific events occur (e.g. when the client wants to establish a session, when the media exchange starts, when media exchange concludes, when errors arise, etc.) Thanks to this API, developers can customize aspects such as authentication, permissions, accounting, etc. For all this, developers will have access to the rich environment exposed by the Java platform.
Media API: This is a media control API. It consists on stubs that make possible controlling the lifecycle and behavior of Kurento Media Server (KMS) media capabilities. The Media API is an abstract API so that most of the complex low level details (garbage collection, format and codecs, etc.) are hidden.
