This presentation was used in the context of a FI-WARE webminar for introducing Kurento. Kurento is a framework for building multimedia and streaming applications based on predefined blocks. Send and receive median through RTP, WebRTC, HTTP and RTSP. Use processing for making face detection, plate recognition or object tracking. Use augmented reality, group communications or media mixing and blending among others. During the webminar, we used Kurento APIs for showing how to create media applications for videoconferencing or video streaming in a simple and seamless manner. We also demonstrated how these applications can be enriched with Kurento's advanced processing capabilities.
This presentation was carried out at the different FI-WARE Bootcamps, for presenting Kurento, its capabilities and APIs to a group of startups.
Kurento makes it possible to create rich video applications supporting WebRTC and HTTP pseudo-streaming (video tag) and exposing Kurento Media Server capabilities, which include computer vision, augmented reality, group communications and recording.
Kurento: a media server architecture and API for WebRTCLuis Lopez
Introducing Kurento for WebRTC Expo 2013 (Paris). Kurento is an Open Source multimedia framework, which provides a Java EE compatible API suitable for adding real-time communication capabilities to any WWW application in a simple and seamless way.
FOSDEM 2016 - Creating rich WebRTC Applications with KurentoLuis Lopez
WebRTC is a disruptive media technology bringing real-time multimedia communications to HTML5 standards. WebRTC is currently available for billions of users as a built-in feature of common browsers such as Chrome and Firefox. This makes possible the emergence of a truly open and interoperable technology competing with proprietary conferencing solutions and enabling developers to create specific-purpose WWW peer-to-peer real-time media applications in a simple and seamless manner.
However, WebRTC developers commonly require more than plain peer-to-peer video conferencing. For this, we introduce Kurento (http://www.kurento.org), a Free Open Source Software (FOSS) initiative build on top of GStreamer providing developers a set of high level abstract APIs making possible the creation of HTML5 multimedia-enabled web application. Kurento pushes GStreamer to the limit building a media server with interesting features such as media recording, media mixing for group communications, media adaption and transcoding, media augmentation, integration with computer vision capabilities, etc.
In the talk we will introduce what’s Kurento and how WWW developers can take advantage of it showing the following aspects of the framework:
- First, introducing Kurento Java and JavaScript APIs and we explain how they interact with the signaling plane in an application server. This allows WebRTC application developers to create their application logic using popular technologies such as Java EE or Node.js.
- Second, by presenting a unique media plane written on top of GStreamer. GStreamer is based on the concept of media pipelines, which can be seen as chains of media elements performing operations to a media flow in real-time. Currently there are more than 1000 media elements written for GStreamer implementing many different capabilities such as codecs (e.g. H.264, H.263, VP8, etc.), recorders and players (for storing/recovering media from files), blenders (for augmenting media), filters (i.e. face blurring, face recognition, etc.) and others. Hence, Kurento enables to inject WebRTC streams into a chain of such elements and perform, in real time, the operations the developer wishes.
- Third, introducing and abstraction of all the complexities of signaling, media control and media management through a powerful server-side API that can be used by average developers who do not require particular expertise about multimedia protocols or formats.
Developing rich multimedia applications with Kurento: a tutorial for JavaScri...Luis Lopez
This presentation was carried out at DevCon5'14 (New York) for introducing the Kurento new JavaScript developer APIs. These APIs make possible to create rich video applications supporting WebRTC and HTTP pseudo-streaming (video tag) and leveraging Kurento Media Server capabilities, which include computer vision, augmented reality, group communications and recording.
In this presentation we introduce Nubomedia (http://www.nubomedia.eu), the first open source PaaS platform capable of acting as an “infinite media server”. Most state-of-the-art media servers just provide three types of capabilities: transcoding, group communications and recording. Nubomedia is a research effort funded by the European Commission which, in addition to these, provides flexible media processing features including computer vision, augmented reality, media blending, media filtering and much more. In a world where plain communications are becoming a commodity, business models based on “just calls” are not really profitable. For this reason, these advanced media processing mechanisms open new opportunities given that they might provide differentiation and added value to applications in many specific verticals including e-Health, e-Learning, security, entertainment, games, advertising or CRMs just to cite a few.
Developing rich multimedia applications with FI-WARE.Luis Lopez
FI-WARE will deliver a novel service infrastructure, building upon elements called Generic Enablers (GEs), which offer reusable and commonly shared functions making it easier to develop Future Internet Applications in multiple sectors. This presentation provides an overview of Kurento: the FI-WARE Generic Enabler that will ease development of advanced multimedia stream processing applications.
Implementing a WebRTC endpoint in GStreamer: challenges, problems and perspec...Luis Lopez
WebRTC is one of the main trends on the multimedia arena in the last few years. The ability of bringing real-time audio and video to WWW browsers opens new horizons for developers to create context aware customized applications for inter-human communications. However, for WebRTC technologies to work seamlessly in WWW applications, it’s necessary to manage with a number of present and future complex challenges.
In this talk, we present the experience of the Kurento Media Server team in creating a WebRTC endpoint for GStreamer. We describe the main problems and limitations basing on current GStreamer status describing which parts of WebRTC standards can be currently implemented with GStreamer and which parts require further evolutions and efforts from the community. We will also describe the plans and drafts that are emerging at different standardization groups, including the WebRTC WG at W3C and the RTCWeb WG at IETF. Basing on this, we will try to forecast how WebRTC technologies in particular, but also how real-time multimedia communications in general, may be evolving in the next couple of years and the activities that the GStreamer community should be considering for adapting to these evolutions.
In particular, we shall introduce in detail topics such as the following:
• The evolution of ICE (Interactive Connectivity Establishment).
• Congestion control for RTC streams.
• Implementing WebRTC security securely
• Implementing and optimizing the AVPF profile for RTP
• Benchmarking WebRTC: stats metrics
• Managing sensor data through DataChannels.
This presentation was carried out at the different FI-WARE Bootcamps, for presenting Kurento, its capabilities and APIs to a group of startups.
Kurento makes it possible to create rich video applications supporting WebRTC and HTTP pseudo-streaming (video tag) and exposing Kurento Media Server capabilities, which include computer vision, augmented reality, group communications and recording.
Kurento: a media server architecture and API for WebRTCLuis Lopez
Introducing Kurento for WebRTC Expo 2013 (Paris). Kurento is an Open Source multimedia framework, which provides a Java EE compatible API suitable for adding real-time communication capabilities to any WWW application in a simple and seamless way.
FOSDEM 2016 - Creating rich WebRTC Applications with KurentoLuis Lopez
WebRTC is a disruptive media technology bringing real-time multimedia communications to HTML5 standards. WebRTC is currently available for billions of users as a built-in feature of common browsers such as Chrome and Firefox. This makes possible the emergence of a truly open and interoperable technology competing with proprietary conferencing solutions and enabling developers to create specific-purpose WWW peer-to-peer real-time media applications in a simple and seamless manner.
However, WebRTC developers commonly require more than plain peer-to-peer video conferencing. For this, we introduce Kurento (http://www.kurento.org), a Free Open Source Software (FOSS) initiative build on top of GStreamer providing developers a set of high level abstract APIs making possible the creation of HTML5 multimedia-enabled web application. Kurento pushes GStreamer to the limit building a media server with interesting features such as media recording, media mixing for group communications, media adaption and transcoding, media augmentation, integration with computer vision capabilities, etc.
In the talk we will introduce what’s Kurento and how WWW developers can take advantage of it showing the following aspects of the framework:
- First, introducing Kurento Java and JavaScript APIs and we explain how they interact with the signaling plane in an application server. This allows WebRTC application developers to create their application logic using popular technologies such as Java EE or Node.js.
- Second, by presenting a unique media plane written on top of GStreamer. GStreamer is based on the concept of media pipelines, which can be seen as chains of media elements performing operations to a media flow in real-time. Currently there are more than 1000 media elements written for GStreamer implementing many different capabilities such as codecs (e.g. H.264, H.263, VP8, etc.), recorders and players (for storing/recovering media from files), blenders (for augmenting media), filters (i.e. face blurring, face recognition, etc.) and others. Hence, Kurento enables to inject WebRTC streams into a chain of such elements and perform, in real time, the operations the developer wishes.
- Third, introducing and abstraction of all the complexities of signaling, media control and media management through a powerful server-side API that can be used by average developers who do not require particular expertise about multimedia protocols or formats.
Developing rich multimedia applications with Kurento: a tutorial for JavaScri...Luis Lopez
This presentation was carried out at DevCon5'14 (New York) for introducing the Kurento new JavaScript developer APIs. These APIs make possible to create rich video applications supporting WebRTC and HTTP pseudo-streaming (video tag) and leveraging Kurento Media Server capabilities, which include computer vision, augmented reality, group communications and recording.
In this presentation we introduce Nubomedia (http://www.nubomedia.eu), the first open source PaaS platform capable of acting as an “infinite media server”. Most state-of-the-art media servers just provide three types of capabilities: transcoding, group communications and recording. Nubomedia is a research effort funded by the European Commission which, in addition to these, provides flexible media processing features including computer vision, augmented reality, media blending, media filtering and much more. In a world where plain communications are becoming a commodity, business models based on “just calls” are not really profitable. For this reason, these advanced media processing mechanisms open new opportunities given that they might provide differentiation and added value to applications in many specific verticals including e-Health, e-Learning, security, entertainment, games, advertising or CRMs just to cite a few.
Developing rich multimedia applications with FI-WARE.Luis Lopez
FI-WARE will deliver a novel service infrastructure, building upon elements called Generic Enablers (GEs), which offer reusable and commonly shared functions making it easier to develop Future Internet Applications in multiple sectors. This presentation provides an overview of Kurento: the FI-WARE Generic Enabler that will ease development of advanced multimedia stream processing applications.
Implementing a WebRTC endpoint in GStreamer: challenges, problems and perspec...Luis Lopez
WebRTC is one of the main trends on the multimedia arena in the last few years. The ability of bringing real-time audio and video to WWW browsers opens new horizons for developers to create context aware customized applications for inter-human communications. However, for WebRTC technologies to work seamlessly in WWW applications, it’s necessary to manage with a number of present and future complex challenges.
In this talk, we present the experience of the Kurento Media Server team in creating a WebRTC endpoint for GStreamer. We describe the main problems and limitations basing on current GStreamer status describing which parts of WebRTC standards can be currently implemented with GStreamer and which parts require further evolutions and efforts from the community. We will also describe the plans and drafts that are emerging at different standardization groups, including the WebRTC WG at W3C and the RTCWeb WG at IETF. Basing on this, we will try to forecast how WebRTC technologies in particular, but also how real-time multimedia communications in general, may be evolving in the next couple of years and the activities that the GStreamer community should be considering for adapting to these evolutions.
In particular, we shall introduce in detail topics such as the following:
• The evolution of ICE (Interactive Connectivity Establishment).
• Congestion control for RTC streams.
• Implementing WebRTC security securely
• Implementing and optimizing the AVPF profile for RTP
• Benchmarking WebRTC: stats metrics
• Managing sensor data through DataChannels.
Recording and media manipulation of WebRTC streamsLuis Lopez
This presentation introduces Kurento technologies to developers at the WebRTC Conference & Expo 2014 in San Jose. It focuses on Kurento Client APIs and on its capabilities for recording and manipulating the audio and video streams in WebRTC sessions.
WebRTC infrastructures in the large (with experiences on real cloud deployments)Luis Lopez
WebRTC technologies are currently showing their potential for providing peer-to-peer real-time communications in a seamless and scalable way. However, most relevant use cases demanded by users require further features such as group communications, media recording and media interoperability. Providing them requires the presence of WebRTC media infrastructures that are sometimes complex to manage and to scale.
In this talk, we present the experiences of the Kurento.org team creating auto-scalable WebRTC infrastructures in the large. Following results generated by the NUBOMEDIA and FIWARE research projects, we introduce stateless and stateful scalability models, which provide different scalability definitions and properties. Stateless models are suitable services requiring large number of WebRTC sessions with few participants each. Such models are commonly deployed today and they are compatible with current state-of-the-art on RTP topologies (e.g. following SFU or MCU architectures). On the other hand, stateful models are capable of scaling to very large sessions (with thousands or hundred of thousands of participants) but require new types of RTP topologies beyond plain SFU and MCU models.
During the talk, we also show how to deploy such stateful and stateless infrastructures on top of IaaS clouds such as Amazon or OpenStack so that their scalability can be automatically managed. We also present the different KPIs that auto-scaling algorithms may use as well as our experiences on the accuracy and appropriateness of them. To conclude, we introduce some real-word problems on such deployments related to infrastructure monitoring and instrumentation, fault-tolerance and fault resilience mechanism and security issues.
Developing rich multimedia applications with Kurento: a tutorial for Java Dev...Luis Lopez
This presentation contains a tutorial devoted to showing how Java developers can create rich multimedia applications with Kurento. Java developers will find natural Kurento development model, which is based on standard Java EE technologies and is inspired on the WWW Servlet model.
If you have ever developed a Web application, you may be familiar with this scheme. At the browser, HTML and JavaScript code is in charge of user interaction and generates HTTP requests to the server. This code is usually programmed with the help of APIs such as jQuery, DOM, XHR or others. Upon reception, HTTP requests are processed by some kind of server side technology (e. g.. PHP, Java, Ruby, etc.) using service APIs providing features such as DB access, communications, transactions, XML parsing, and others. As a result, an HTTP response is issued and sent back to the client. Following this scheme, both server and client side APIs are just capabilities simplifying developer work and providing abstractions for programming faster and more efficiently.
Kurento technologies adapt to the Web development model so that, from a programmer perspective, Kurento can be seen just as an additional set of APIs. Developers does not need to learn novel programming schemes and can reuse all their knowledge and previous background on WWW application development. When you need multimedia, just use Kurento APIs. For the rest, use your preferred APIs or reuse previous code. Kurento APIs have been designed for simplicity and Web developers will find them familiar and intuitive. Most of the low level details related to codecs, formats, protocols, profiles and containers are abstracted by the framework. Programmers just concentrate on specifying the sequence of processing steps that they want to execute on the media flows.
elasticRTC -- how to have your own WebRTC cloud scaling to be billions in min...Luis Lopez
Creating WebRTC applications is simple, but making them scalable in a robust and efficient way isn’t. Due to this, many application developers do not dare to use their own infrastructures and instead prefer to leverage third party clouds for creating their scalable WebRTC services. These clouds are private and usually expose some kind of API that developers consume for accessing WebRTC communication capabilities such as group-communications, media recording or media transcoding. This model is very convenient for creating simple vertical applications, but it also has some drawbacks. First, these clouds billing models are based on pay-per-minute schemes that are not always compatible with the business models desired by application developers. Second, the exposed APIs tend to be restrictive and limit the freedom of developers for innovating. Third, these clouds, being fully private, cannot be extended or customized for specific needs developers may have.
In this talk, we propose an alternative solution to private WebRTC PaaS models based on leveraging novel cloud orchestration technologies such as Cloud Formation or Heat Templates for enabling developers to create their very own platform on top of public clouds. We analyze the technological ingredients required for enabling such models and present some experiments and production deployments showing how any developer may bring her own IaaS cloud for growing on it a full featured WebRTC platform with elastic scalability and full control on the billing and on the underlying technology evolution.
The future of multimedia communications and services: Kurento and it's roleLuis Lopez
This is a presentation specifically created for the GSMA interest group on WebRTC. This presentations introduces Kurento from the perspective of operators. Kurento is a multimedia development framework. It has been created to ease the life of multimedia application developers. Using multimedia capabilities such as embedding a video onto your app or establishing a video conferencing link between two clients may be tricky, but there is no rocket science there. However, for applications requiring more advanced features things quickly get unmanageable. If you have been involved in multimedia projects, you probably know that features such as interoperable group communications, different communication roles (e. g.. publishers/viewers), video transforming and transcoding, video storage and tagging, integration into legacy video/voice infrastructures, computer vision, augmented reality, integration with external systems and databases and many others, pose quite a complex challenge, which usually requires huge expertise and effort. Specially when real-time communications are involved. If this is your case, Kurento will help you.
WebRTC services have already permeated in corporate communications in the form of videoconferencing solutions. However, WebRTC has the potential of going beyond and catalyze a new class of services providing more than calls with capabilities such as mass-scale real-time media broadcasting, enriched and augmented video, person-to-machine and machine-to-machine communications. In this talk we introduce the technologies required for implementing these ideas and some early experiments performed in the Kurento open source software community in areas such as entertainment, video surveillance, interactive media broadcasting, gaming or advertising. To conclude, we discuss their potential business applications beyond plain call models.
Advanced Kurento Real Time Media Stream ProcessingFIWARE
Advanced Kurento Real Time Media Stream Processing presentation, by Juan Ángel Fuentes.
Stream Oriented GE. How-to sessions. 1st FIWARE Summit, Málaga, Dec. 13-15, 2016.
WebRTC/Kurento/NUBOMEDIA Hackathon at IETF’96Boni García
In this hackathon you will be playing with WebRTC technologies and standards for creating rich real-time communication applications. For this, in addition to using WebRTC clients, we will introduce a WebRTC infrastructure suitable for providing advanced capabilities that include group communications, recording, transcoding and media processing. This infrastructure will be based on NUBOMEDIA: a cloud Platform as a Service where you will be able to deploy, execute and scale your WebRTC applications in a seamless way.
WebRTC - On Standards, Identity and Telco StrategyJose de Castro
WebRTC is dramatically changing the face of communications by making real-time voice and video just another feature available on websites and mobile applications.
This presents a tremendous opportunity for telcos... not by monetizing WebRTC directly but by *using* WebRTC to deliver new compelling products to their subscribers and enterprise customers.
This presentation offers a brief overview of WebRTC, the various identity models and some suggestions on go-to-market strategy.
WebRTC gives us a way to do real-time, peer-to-peer communication on the web. In this talk, we'll go over the current state of WebRTC (both the awesome parts and the parts which need to be improved) as well as what could come in the future. Mostly though, we'll take a look at how to combine WebRTC with other web technologies to create great experiences on the front-end for real-time, p2p web apps.
A short intro and update on WebRTC presented at WebRTC Boston 6 covering:
- some recognizable WebRTC use case examples
- review of all the standardized API's that come with WebRTC
- Intro to some of the servers that may be needed with WebRTC
- what's next for WebRTC including Machine learning, lower-level API's, new options for customization, new codecs, and a new transport
See the presentation at https://youtu.be/ptnceQZ4fPg
Thanks to WebRTC Boston 6 sponsors:
Google
YouTube
callstats.io - WebRTC Analytics https://callstats.io
Kranky Geek - RTC Events and Videos https://krankygeek.com
Our previous talk "Intro to Reactive Programming" defined reactive programming and provided details around key initiatives such as Reactive Streams and ReactiveX. In this talk we'll focus on where we are today with building reactive web applications. We'll take a look at the choice of runtimes, how Reactive Streams may be applied to network I/O, and what the programming model may look like. While this is a forward looking talk, we'll spend plenty of time demoing code built with with back-pressure ready libraries available today.
This is your one stop shop introduction to get oriented to the world of reactive programming. There are lots of such intros out there even manifestos. We hope this is the one where you don't get lost and it makes sense. Get a definition of what "reactive" means and why it matters. Learn about Reactive Streams and Reactive Extensions and the emerging ecosystem around them. Get a sense for what going reactive means for the programming model. See lots of hands-on demos introducing the basic concepts in composition libraries using RxJava and Reactor.
The many benefits of a RESTful architecture has made it the standard way in which to design web based APIs. For example, the principles of REST state that we should leverage standard HTTP verbs which helps to keep our APIs simple. Server components that are considered RESTFul should be stateless which help to ensure that they can easily scale. We can leverage caching to gain further performance and scalability benefits.
However, the best practices of REST and security often seem to clash. How should a user be authenticated in a stateless application? How can a secured resource also support caching? Securing RESTful endpoints is further complicated by the the fact that security best practices evolve so rapidly.
In this talk Rob will discuss how to properly secure your RESTful endpoints. Along the way we will explore some common pitfalls when applying security to RESTful APIs. Finally, we will see how the new features in Spring Security can greatly simplify securing your RESTful APIs.
Recording and media manipulation of WebRTC streamsLuis Lopez
This presentation introduces Kurento technologies to developers at the WebRTC Conference & Expo 2014 in San Jose. It focuses on Kurento Client APIs and on its capabilities for recording and manipulating the audio and video streams in WebRTC sessions.
WebRTC infrastructures in the large (with experiences on real cloud deployments)Luis Lopez
WebRTC technologies are currently showing their potential for providing peer-to-peer real-time communications in a seamless and scalable way. However, most relevant use cases demanded by users require further features such as group communications, media recording and media interoperability. Providing them requires the presence of WebRTC media infrastructures that are sometimes complex to manage and to scale.
In this talk, we present the experiences of the Kurento.org team creating auto-scalable WebRTC infrastructures in the large. Following results generated by the NUBOMEDIA and FIWARE research projects, we introduce stateless and stateful scalability models, which provide different scalability definitions and properties. Stateless models are suitable services requiring large number of WebRTC sessions with few participants each. Such models are commonly deployed today and they are compatible with current state-of-the-art on RTP topologies (e.g. following SFU or MCU architectures). On the other hand, stateful models are capable of scaling to very large sessions (with thousands or hundred of thousands of participants) but require new types of RTP topologies beyond plain SFU and MCU models.
During the talk, we also show how to deploy such stateful and stateless infrastructures on top of IaaS clouds such as Amazon or OpenStack so that their scalability can be automatically managed. We also present the different KPIs that auto-scaling algorithms may use as well as our experiences on the accuracy and appropriateness of them. To conclude, we introduce some real-word problems on such deployments related to infrastructure monitoring and instrumentation, fault-tolerance and fault resilience mechanism and security issues.
Developing rich multimedia applications with Kurento: a tutorial for Java Dev...Luis Lopez
This presentation contains a tutorial devoted to showing how Java developers can create rich multimedia applications with Kurento. Java developers will find natural Kurento development model, which is based on standard Java EE technologies and is inspired on the WWW Servlet model.
If you have ever developed a Web application, you may be familiar with this scheme. At the browser, HTML and JavaScript code is in charge of user interaction and generates HTTP requests to the server. This code is usually programmed with the help of APIs such as jQuery, DOM, XHR or others. Upon reception, HTTP requests are processed by some kind of server side technology (e. g.. PHP, Java, Ruby, etc.) using service APIs providing features such as DB access, communications, transactions, XML parsing, and others. As a result, an HTTP response is issued and sent back to the client. Following this scheme, both server and client side APIs are just capabilities simplifying developer work and providing abstractions for programming faster and more efficiently.
Kurento technologies adapt to the Web development model so that, from a programmer perspective, Kurento can be seen just as an additional set of APIs. Developers does not need to learn novel programming schemes and can reuse all their knowledge and previous background on WWW application development. When you need multimedia, just use Kurento APIs. For the rest, use your preferred APIs or reuse previous code. Kurento APIs have been designed for simplicity and Web developers will find them familiar and intuitive. Most of the low level details related to codecs, formats, protocols, profiles and containers are abstracted by the framework. Programmers just concentrate on specifying the sequence of processing steps that they want to execute on the media flows.
elasticRTC -- how to have your own WebRTC cloud scaling to be billions in min...Luis Lopez
Creating WebRTC applications is simple, but making them scalable in a robust and efficient way isn’t. Due to this, many application developers do not dare to use their own infrastructures and instead prefer to leverage third party clouds for creating their scalable WebRTC services. These clouds are private and usually expose some kind of API that developers consume for accessing WebRTC communication capabilities such as group-communications, media recording or media transcoding. This model is very convenient for creating simple vertical applications, but it also has some drawbacks. First, these clouds billing models are based on pay-per-minute schemes that are not always compatible with the business models desired by application developers. Second, the exposed APIs tend to be restrictive and limit the freedom of developers for innovating. Third, these clouds, being fully private, cannot be extended or customized for specific needs developers may have.
In this talk, we propose an alternative solution to private WebRTC PaaS models based on leveraging novel cloud orchestration technologies such as Cloud Formation or Heat Templates for enabling developers to create their very own platform on top of public clouds. We analyze the technological ingredients required for enabling such models and present some experiments and production deployments showing how any developer may bring her own IaaS cloud for growing on it a full featured WebRTC platform with elastic scalability and full control on the billing and on the underlying technology evolution.
The future of multimedia communications and services: Kurento and it's roleLuis Lopez
This is a presentation specifically created for the GSMA interest group on WebRTC. This presentations introduces Kurento from the perspective of operators. Kurento is a multimedia development framework. It has been created to ease the life of multimedia application developers. Using multimedia capabilities such as embedding a video onto your app or establishing a video conferencing link between two clients may be tricky, but there is no rocket science there. However, for applications requiring more advanced features things quickly get unmanageable. If you have been involved in multimedia projects, you probably know that features such as interoperable group communications, different communication roles (e. g.. publishers/viewers), video transforming and transcoding, video storage and tagging, integration into legacy video/voice infrastructures, computer vision, augmented reality, integration with external systems and databases and many others, pose quite a complex challenge, which usually requires huge expertise and effort. Specially when real-time communications are involved. If this is your case, Kurento will help you.
WebRTC services have already permeated in corporate communications in the form of videoconferencing solutions. However, WebRTC has the potential of going beyond and catalyze a new class of services providing more than calls with capabilities such as mass-scale real-time media broadcasting, enriched and augmented video, person-to-machine and machine-to-machine communications. In this talk we introduce the technologies required for implementing these ideas and some early experiments performed in the Kurento open source software community in areas such as entertainment, video surveillance, interactive media broadcasting, gaming or advertising. To conclude, we discuss their potential business applications beyond plain call models.
Advanced Kurento Real Time Media Stream ProcessingFIWARE
Advanced Kurento Real Time Media Stream Processing presentation, by Juan Ángel Fuentes.
Stream Oriented GE. How-to sessions. 1st FIWARE Summit, Málaga, Dec. 13-15, 2016.
WebRTC/Kurento/NUBOMEDIA Hackathon at IETF’96Boni García
In this hackathon you will be playing with WebRTC technologies and standards for creating rich real-time communication applications. For this, in addition to using WebRTC clients, we will introduce a WebRTC infrastructure suitable for providing advanced capabilities that include group communications, recording, transcoding and media processing. This infrastructure will be based on NUBOMEDIA: a cloud Platform as a Service where you will be able to deploy, execute and scale your WebRTC applications in a seamless way.
WebRTC - On Standards, Identity and Telco StrategyJose de Castro
WebRTC is dramatically changing the face of communications by making real-time voice and video just another feature available on websites and mobile applications.
This presents a tremendous opportunity for telcos... not by monetizing WebRTC directly but by *using* WebRTC to deliver new compelling products to their subscribers and enterprise customers.
This presentation offers a brief overview of WebRTC, the various identity models and some suggestions on go-to-market strategy.
WebRTC gives us a way to do real-time, peer-to-peer communication on the web. In this talk, we'll go over the current state of WebRTC (both the awesome parts and the parts which need to be improved) as well as what could come in the future. Mostly though, we'll take a look at how to combine WebRTC with other web technologies to create great experiences on the front-end for real-time, p2p web apps.
A short intro and update on WebRTC presented at WebRTC Boston 6 covering:
- some recognizable WebRTC use case examples
- review of all the standardized API's that come with WebRTC
- Intro to some of the servers that may be needed with WebRTC
- what's next for WebRTC including Machine learning, lower-level API's, new options for customization, new codecs, and a new transport
See the presentation at https://youtu.be/ptnceQZ4fPg
Thanks to WebRTC Boston 6 sponsors:
Google
YouTube
callstats.io - WebRTC Analytics https://callstats.io
Kranky Geek - RTC Events and Videos https://krankygeek.com
Our previous talk "Intro to Reactive Programming" defined reactive programming and provided details around key initiatives such as Reactive Streams and ReactiveX. In this talk we'll focus on where we are today with building reactive web applications. We'll take a look at the choice of runtimes, how Reactive Streams may be applied to network I/O, and what the programming model may look like. While this is a forward looking talk, we'll spend plenty of time demoing code built with with back-pressure ready libraries available today.
This is your one stop shop introduction to get oriented to the world of reactive programming. There are lots of such intros out there even manifestos. We hope this is the one where you don't get lost and it makes sense. Get a definition of what "reactive" means and why it matters. Learn about Reactive Streams and Reactive Extensions and the emerging ecosystem around them. Get a sense for what going reactive means for the programming model. See lots of hands-on demos introducing the basic concepts in composition libraries using RxJava and Reactor.
The many benefits of a RESTful architecture has made it the standard way in which to design web based APIs. For example, the principles of REST state that we should leverage standard HTTP verbs which helps to keep our APIs simple. Server components that are considered RESTFul should be stateless which help to ensure that they can easily scale. We can leverage caching to gain further performance and scalability benefits.
However, the best practices of REST and security often seem to clash. How should a user be authenticated in a stateless application? How can a secured resource also support caching? Securing RESTful endpoints is further complicated by the the fact that security best practices evolve so rapidly.
In this talk Rob will discuss how to properly secure your RESTful endpoints. Along the way we will explore some common pitfalls when applying security to RESTful APIs. Finally, we will see how the new features in Spring Security can greatly simplify securing your RESTful APIs.
SophiaConf2010 Présentation des Retours d'expériences de la Conférence du 08 ...TelecomValley
SophiaConf2010 Présentation des Retours d'expériences de la Conférence du 08 Juillet - HTML 5, une plateforme contemporaine pour le Web : Stefano Crosta, Chief Technical Officer de SLICE FACTORY ; Raphaël Troncy, Maître de Conférences à Eurecom.
Arcomem training Specifying Crawls Beginnersarcomem
This presentation on Specifying Crawls is part of the ARCOMEM training curriculum. Feel free to roam around or contact us on Twitter via @arcomem to learn more about ARCOMEM training on archiving Social Media.
Similar to Developing applications with Kurento (20)
Meet up Milano 14 _ Axpo Italia_ Migration from Mule3 (On-prem) to.pdfFlorence Consulting
Quattordicesimo Meetup di Milano, tenutosi a Milano il 23 Maggio 2024 dalle ore 17:00 alle ore 18:30 in presenza e da remoto.
Abbiamo parlato di come Axpo Italia S.p.A. ha ridotto il technical debt migrando le proprie APIs da Mule 3.9 a Mule 4.4 passando anche da on-premises a CloudHub 1.0.
Italy Agriculture Equipment Market Outlook to 2027harveenkaur52
Agriculture and Animal Care
Ken Research has an expertise in Agriculture and Animal Care sector and offer vast collection of information related to all major aspects such as Agriculture equipment, Crop Protection, Seed, Agriculture Chemical, Fertilizers, Protected Cultivators, Palm Oil, Hybrid Seed, Animal Feed additives and many more.
Our continuous study and findings in agriculture sector provide better insights to companies dealing with related product and services, government and agriculture associations, researchers and students to well understand the present and expected scenario.
Our Animal care category provides solutions on Animal Healthcare and related products and services, including, animal feed additives, vaccination
Gen Z and the marketplaces - let's translate their needsLaura Szabó
The product workshop focused on exploring the requirements of Generation Z in relation to marketplace dynamics. We delved into their specific needs, examined the specifics in their shopping preferences, and analyzed their preferred methods for accessing information and making purchases within a marketplace. Through the study of real-life cases , we tried to gain valuable insights into enhancing the marketplace experience for Generation Z.
The workshop was held on the DMA Conference in Vienna June 2024.
APNIC Foundation, presented by Ellisha Heppner at the PNG DNS Forum 2024APNIC
Ellisha Heppner, Grant Management Lead, presented an update on APNIC Foundation to the PNG DNS Forum held from 6 to 10 May, 2024 in Port Moresby, Papua New Guinea.
Understanding User Behavior with Google Analytics.pdfSEO Article Boost
Unlocking the full potential of Google Analytics is crucial for understanding and optimizing your website’s performance. This guide dives deep into the essential aspects of Google Analytics, from analyzing traffic sources to understanding user demographics and tracking user engagement.
Traffic Sources Analysis:
Discover where your website traffic originates. By examining the Acquisition section, you can identify whether visitors come from organic search, paid campaigns, direct visits, social media, or referral links. This knowledge helps in refining marketing strategies and optimizing resource allocation.
User Demographics Insights:
Gain a comprehensive view of your audience by exploring demographic data in the Audience section. Understand age, gender, and interests to tailor your marketing strategies effectively. Leverage this information to create personalized content and improve user engagement and conversion rates.
Tracking User Engagement:
Learn how to measure user interaction with your site through key metrics like bounce rate, average session duration, and pages per session. Enhance user experience by analyzing engagement metrics and implementing strategies to keep visitors engaged.
Conversion Rate Optimization:
Understand the importance of conversion rates and how to track them using Google Analytics. Set up Goals, analyze conversion funnels, segment your audience, and employ A/B testing to optimize your website for higher conversions. Utilize ecommerce tracking and multi-channel funnels for a detailed view of your sales performance and marketing channel contributions.
Custom Reports and Dashboards:
Create custom reports and dashboards to visualize and interpret data relevant to your business goals. Use advanced filters, segments, and visualization options to gain deeper insights. Incorporate custom dimensions and metrics for tailored data analysis. Integrate external data sources to enrich your analytics and make well-informed decisions.
This guide is designed to help you harness the power of Google Analytics for making data-driven decisions that enhance website performance and achieve your digital marketing objectives. Whether you are looking to improve SEO, refine your social media strategy, or boost conversion rates, understanding and utilizing Google Analytics is essential for your success.
1. Open APIs for Open Minds
Real-time Multimedia Stream Processing
Developing rich multimedia applications with Kurento
2. Mul$media
infrastructures
for
the
Future
Internet
2
Media
is
here
Media
got
there
Media
got
there
Analyze
Transform
Store
Transport
Enrich
Augment
Adapt
Sensors
Context
Events
Media
is
here
4. Future
Internet
Mul$media
Infrastructure
Simple
Development
APIs
The
FI-‐WARE
Stream-‐oriented
Generic
Enabler
Implementa$on
4
5. 5
• Interoperable
media
exchange
(mul$plaNorm/mul$protocol)
• WebRTC,
RTP,
HTTP
(video
tag),
etc.
• Process
media
(Computer
vision,
augmented
reality,
media
indexing,
etc.)
• Media
and
metadata
recording
and
recovery
• Transform
and
adapt
media
(H.264,
H.263,
VP8,
Ogg,
and
others)
• Media
rou$ng
and
mixing
• Etc.
Provides
mul$media
capabili$es
to
the
FI-‐WARE
infrastructure
• REST
API
• JavaScript
API
• Java
API
Exposes
those
capabili$es
through
a
simple
to
use
APIs
• LGPL
2.1
Is
distributed
through
a
flexible
FOSS
license
Kurento
6. Kurento
Media
Server
(KMS):
the
nucleus
of
Kurento
6
• KMS
is
a
middleware
for
media
streams
– Receives
the
stream
– Process
the
stream
– Issues
the
stream
Send
Receive
Analyze
Augment
Enrich
Transform
Transcode
Record
Process
Replicate
Media
Source
Media
Sink
KMS
7. The
Media
API:
The
API
for
accessing
KMS
capabili$es
7
Send
Receive
Analyze
Augment
Enrich
Transform
Transcode
Record
Process
Replicate
Media
Source
Media
Sink
KMS
Java
Media
API
JavaScript
Media
API
Other
languages
Applica$ons
define
the
processing
of
streams
geang
through
KMS
8. Media
API:
Media
Elements
and
Media
Pipelines
8
Sink%SRC%
Sink%
SRC%
SRC%Sink%
Sink%
§ Media Element
• Provides a specific media
functionality
› Send/receive media
› Process media
› Transform media
• Exchange media through
› Sources
› Sinks
§ Media pipeline
• Chain of media elements
implementing the desired media
logic.
• The Media API provides the
capability of creating media
pipelines by joining media
elements of the toolbox
Media
Element
Sink
SRC
10. Media
API:
trivial
example
(Java)
MediaPipeline
mp
=
contentSession.getMediaPipelineFactory().create();
PlayerEndpoint
playerEndpoint
=
mp.newPlayerEndpoint(file:///myFile.webm).build();
H2pGetEndpoint
hepEndpoint
=
mp.newHepGetEndpoint().terminateOnEOS().build();
playerEndpoint.connect(hepEndpoint);
hepEndpoint.getUrl();
//URL
where
the
media
is
made
available
10
Media
Pipeline
HepGetEndpoint
Media
from
file
or
URI
HTTP
media
streaming
Sink
SRC
PlayerEndpoint
11. Is
that
enough?
Think
about
the
WWW
development
model
11
Process
WWW
request
-‐ DDBB
access
-‐ Authen$ca$on
-‐ XML
processing
-‐ Etc.
HTTP
request:
I
want
this
resource
HTTP
response:
The
resource
• Intui$on
behind
the
WWW
model
– Client
asks
what
it
wants
– Server
side
APIs
execute
the
associated
processing
12. We
need
an
equivalent
model:
the
role
of
the
Signaling
Plane
• The
API
must
provide
nego$a$on
capabili$es
– I
want
“this
media”
…
• Iden$fica$on
of
the
media
to
exchange
– File
in
hard-‐drive,
IP
camera,
user,
etc.
– in
“this
way”
…
• Iden$fica$on
of
the
processing
of
media
– Augmented,
analyzed,
etc.
– with
“this
format”
…
• Quality
– Codec,
screen-‐size,
frame-‐rate,
etc.
– at
“this
moment”
• Stream
control
– Play,
stop,
start,
pause,
etc.
12
13. Don’t
get
it?
think
about
WWW
development
again
…
13
Process
WWW
request
-‐ DDBB
access
-‐ Authen$ca$on
-‐ XML
processing
-‐ Etc.
HTTP
request:
I
want
this
resource
HTTP
response:
The
resource
Process
media
request
-‐ Media
API
-‐ DDBB
access
-‐ Authen$ca$on
-‐ XML
processing
-‐ Etc.
Signaling
request:
I
want
this
media
Signaling
response:
The
media
is
here
Intui$on
behind
tradi$onal
WWW
Applica$ons
(Servlets,
ASP,
PHP,
Rails,
etc.)
Intui$on
behind
Kurento
development
APIs:
Mul$media
RTC
is
just
another
feature
of
your
applica$on
14. Dealing
with
the
signaling:
The
Content
Handler
14
KMS
Sink
SRC
Sink
SRC
Sink
SRC
Sink
Media
API
REST
API
(Open
API
protocol)
The
Content
Handler
Equivalent
to
a
Servlet/ASP/PHP
script
-‐ When
receiving
“this
request”…
-‐ execute
“this
logic”
Developer
can
use
the
media
API
Code
building
the
media
pipeline
and
execu$ng
the
applica$on
logic
the
developer
wants
15. Kurento
Architecture
15
Kurento
Media
Server
(KMS)
Receive
Video
Augmented
Reality
Send
Video
Computer
Vision
Video
Playing
and
Recording
Java
EE
compaJble
container
HTTP
Servlet
SIP
Servlet
Web
services
Kurento
REST
API
Specific
handler
implementa$ons
Signaling
and
WWW
traffic
Media
Media
Signaling
and
WWW
traffic
Media
API
DD.BB.
Kurento
ApplicaJon
Server
(KAS)
Other
java
APIs.
16. Applica$on
execu$on
flow
Client
Code
Applica$on
Server
(KAS)
Media
Server
(KMS)
I
want
this
media
in
this
way
…
(JSON)
Commands
reques$ng
the
crea$on
of
a
pipeline
What
you
want
is
here
…
(JSON)
Media
negoJaJon
phase
Media
exchange
phase
1
2
Specific
applica$on
logic
at
the
server-‐side
(Content
Handler)
Media
pipeline
creaJon
Media
exchange
between
client
and
server
17. Content
Handler:
trivial
example
@H2pPlayerService(path
=
"/player”)
public
class
MyPlayerHandler
extends
HepPlayerHandler
{
@Override
public
void
onContentRequest(HepPlayerSession
contentSession)
{
//Create
the
pipeline
for
providing
media
through
HTTP
}
@Override
public
void
onContentStarted(HepPlayerSession
contentSession)
{
//Media
started
flowing,
you
can
execute
addi$onal
ac$ons
}
@Override
Public
void
onSessionTerminated(HepPlayerSession
contentSenssion){
//Media
exchange
termianted,
you
can
collect
your
resources
}
18. Let’s
develop
with
Kurento
• What
you
need
– A
Kurento
instance
• You
can
install
your
own
Kurento
instance
• You
can
launch
a
Kurento
instance
at
the
FI-‐LAB
– hep://lab.fi-‐ware.org
• Geang
help
– FI-‐WARE
catalog
entry
• hep://catalogue.fi-‐ware.org/enablers/stream-‐oriented-‐kurento
– Installa$on
guide
• heps://forge.fi-‐ware.org/plugins/mediawiki/wiki/fiware/index.php/
StreamOriented_-‐_Installa$on_and_Administra$on_Guide
– Developer
guide
• heps://forge.fi-‐ware.org/plugins/mediawiki/wiki/fiware/index.php/
StreamOriented_-‐_User_and_Programmers_Guide
– Kurento
web
site
• hep://www.kurento.org
18
19. Kurento
Hello
World:
Playing
a
file
19
Media
Pipeline
HepGetEndpoint
Media
from
file
or
URI
HTTP
media
streaming
Sink
SRC
PlayerEndpoint
Media
API
REST
API
(Open
API
protocol)
Create
the
pipeline
connec$ng:
HepGetEndpoint
PlayerEndpoint
I
want
“this
media”
20. Playing
a
file:
Handler
code
@HepPlayerService(path
=
"/player”)
public
class
MyPlayerHandler
extends
HepPlayerHandler
{
@Override
public
void
onContentRequest(HepPlayerSession
contentSession)
throws
Excep$on
{
MediaPipeline
mp
=
contentSession.getMediaPipelineFactory().create();
contentSession.releaseOnTerminate(mp);
PlayerEndpoint
playerEndpoint
=
mp.newPlayerEndpoint(
"h2p://media.w3.org/2010/05/sintel/trailer.webm").build();
contentSession.setAeribute("player",
playerEndpoint);
H2pGetEndpoint
h2pEndpoint
=
mp.newH2pGetEndpoint().terminateOnEOS().build();
playerEndpoint.connect(h2pEndpoint);
contentSession.start(hepEndpoint);
}
@Override
public
void
onContentStarted(HepPlayerSession
contentSession)
{
PlayerEndpoint
playerEndpoint
=
(PlayerEndpoint)
contentSession.getAeribute("player");
playerEndpoint.play();
}
}
20
Source:
heps://github.com/Kurento/kmf-‐tutorial/blob/master/src/main/java/com/kurento/tutorial/MyPlayerHandler.java
22. Media
Pipeline
Adding
Computer
Vision
22
HepGetEndpoint
Media
from
file
or
URI
HTTP
media
streaming
Sink
SRC
PlayerEndpoint
SRC
Sink
JackVaderFilter
Media
API
REST
API
(Open
API
protocol)
Create
the
pipeline
connec$ng:
HepGetEndpoint,
Filter
and
PlayerEndpoint
I
want
“this
media”