 I'm going to hand it over now to the rock stars. Thank you. Thank you very much. First of all, thanks for having me here and thank you all for choosing to be here tonight instead of enjoying this beautiful city outside with so many things to do. So I'm Lorenzo Miniero. I come from Napoli. I took my PhD at the University of Napoli a few years ago. I'm currently the chairman of Miteco, a small company in Naples. I really do believe in open source. As you can see, I should probably cut my hair because I'm way too old for that. And Miteco or Miteco, however you want to call it, I've heard it's called in a thousand different ways, was born as an academic spin-off. So I told you I got my PhD at the University of Napoli and so did my colleagues at the time. So we started working a lot in research at the university and eventually we came up with the idea of building a company out of all these. And at first we were focused on conferencing and stuff like this, but then we really tried to widen the scope to do multimedia applications in general, always with a strong perspective on standardization and open source, especially within the ITF and explain later why it is so important for us. And in general, we do several kind of activities as a small company. So the usual consulting services and stuff like this, commercial support, pretty much any kind of thing that small companies like ours do. But most importantly, we also do the streaming of services. We provide streaming services for live events, for instance, like the ITF. So I'm actually here in Singapore because I'm streaming the ITF that is happening right now. So my colleagues are actually not here because they are still streaming some events at the moment. Probably it ended a few minutes ago, not sure. And we were proudly brewed in Napoli. This is a nice picture of Napoli. I don't know if you have ever been, but it's actually quite nice as you can see. And both my house and the office are around somewhere in this picture, I'll let you guess where. And we actually have a cool partnership with Cosmo, the guys that you just saw a presentation from. We built this so-called WebRTC-ATM, you might say, because we have a great expertise in the service side of things, while they do have a great expertise in the client side of things. And so we found out that actually working together on some aspects really solve more issues that we could do on our own. And we actually already worked together on a couple of things that I mentioned in a minute. But let's talk about WebRTC in general first. I won't focus too much on these slides because I assume that most of you will be already familiar with those. But in general, the concept is that you have a couple of peers that can actually interact with each other, first establishing some kind of communication via a signaling and negotiation channel to observe, for instance, and eventually being able to communicate with each other, establishing a connectivity channel between each other and create a secure channel over which to exchange audio, video, data and whatever. It's actually quite interesting though when one of these two peers is actually not a real person, but actually an application because it allows you to do cool things that you could not do with just people in the picture. And ideally you might also, let's say, simplify this and assume that this virtual peer that is actually an application might actually also take care not only of the media side of things, but also of the signaling, which would allow you to do things like, I don't know, an MCU, some kind of a conference mixer that allows you to mix all the stuff together and allow people to communicate this way. Or an SF, sorry, an SFU where you actually have a different kind of approach where you just relay media instead of mixing it before actually sending it to the other participants or actually start involving other technologies that are not WebRTC-based. So you might, for instance, want to interact with the SIP infrastructure with, I don't know, with RTSP-based cameras that allow you to do video surveillance or stuff like this or interact with other technologies like RTMP, Silverlight and stuff like this. And of course, all these works only if this component is smart enough to take care of both this side of things and this side of things. So as long as this server is able to terminate the media over here, then there's no limit on what you can do on this other side of things. It's pretty much up to you. Which is what we talked about when we started writing Janus in the first place, which is the component that I'm going to talk about today, by the way. And the reason we chose the name Janus for this is that it comes from the Roman mythology. It's the name of a Roman god, the Roman gods of transitions. So it was a god with two different phases, one looking at the past and one looking at the future, which is incidentally why the Mont January is called like that, just a fun fact if you want. And in our idea, the concept was that Janus would be the same kind of approach. So the same component with two different phases, one looking at the future, which is WebRTC and one looking at the past that might be legacy technologies or whatever, like we saw in the other picture. Of course, while still be able to do everything just in the future if you wanted to. And Janus is completely open source you can find. This is the link to the repository. It's all on GitHub. There's a lot of demos and documentation available on that website over here. And we also have a pretty much active community as a Google group. And the idea was that when we start building Janus, we wanted to implement some kind of a general purpose kind of tool. So something that would allow us to implement pretty much whatever would come into our minds with respect to WebRTC without having to rewrite everything from scratch again over and over again any time that maybe a new idea came to mind. And of course to do that, we had to come up with some kind of a modular architecture where we basically would have a core that would implement the WebRTC stack. So all the protocols that you actually need to implement the WebRTC endpoint because as you remember from the previous slide, we are talking about a component that acts like a WebRTC peer and so must implement all the protocols that a WebRTC endpoint would implement. And so the core is responsible for all of that. So the establishment of the connectivity, ISDTLS, data channels and so on plus some additional stuff that might be some more advanced WebRTC related features. And then everything else is pretty much modular. So it's a module that you can load as a shared object. And first of all, starting from the transport because we defined the genus API so a way to communicate with Janus that is a JSON based protocol and you can actually transport this protocol over different protocols as transports basically. So you can use HTTP or WebSockets if you want to talk from a browser to Janus directly for instance but you might also use other protocols if you are using Janus as a purely server-side component that you control on your own like RabbitMQ, UnixSockets, MQTT or whatever else you might want to implement as an additional module without touching Janus itself. But most importantly, the real power of Janus resides in the fact that you can also implement the application logic itself as a different plug-in which means that conceptually and maybe this is more easier to understand in the next picture the idea is that as a user you connect to the to the core via one of the protocols that we've seen before and you start exchanging messages with Janus via the Janus API and then as part of this communication you attach to one or more plugins in the background. And by plugins I mean components that implement the application logic in a different way which means that actually handle the media in different ways. So one component might implement some kind of video conferencing functionality another component might talk to the SIP world another component might interact with RTSP or whatever these kind of things and so on. And so depending on which plug-in you talk with using this API over here the peer connections that you create, so the media channels that you create with Janus can actually carry different media according to the logic that these different plugins implemented. And so in this case for instance we have this browser that has created two different peer connections over here. This peer connection is actually associated with this green plug-in over here that might do some web conferencing or something like this. These other red peer connections is attached to that other plug-in over there that might actually forward or let's say handle incoming media from a completely different component that is not WebRTC compliant at all. And Janus takes care of making sure that whatever happens here is actually turned into something that is WebRTC on this other hand. That whatever you want the user to send or receive is actually taken care of by Janus itself. And this allows you to do some cool things like combining different plugins to create custom and nice applications. I'll show a couple of examples later on. Of course this only works if the plugins that we've seen before are actually able to also implement their own kind of messaging which is what we did implementing basically the Janus API as a transport for the communication of the plugins itself. Meaning that each plugin can implement its own API because of course conferencing kind of application has a completely different set of requirements from a CIP gateway application. They might have completely different messages that they want to exchange with each other and completely different requirements in terms of events to notify and stuff like this. And this is all made possible by this kind of approach that we chose for this. And just to give you a simple idea of how you could actually combine different plugins to implement a new application that goes beyond the functionality that is provided by each of the individual plugins you can think for instance about a simple webinar kind of application where you have a person speaking and presenting their own slides online and other people that are just watching and maybe they can chime in and make some questions later on. The idea is that you can combine let's say even three different plugins to do this so you might want to use the AudioMCU, the AudioMixer plugin to handle all the audio parts so that you can easily have people come in and make questions and so on or even use CIP for the purpose let's say. You might want to use the SFU plugin for the video parts so that you have the user that is contributing his own media sending his own media this way and all the other people just subscribe to this and then for text you might use some kind of a text room plugin functionality that allows you to do some instant messaging using data channels. Or you could do something cool or like a social TV kind of application where you have a TV broadcast that is still served via WebRTC let's say a football match or something like this and then you have all your friends that are watching the same thing as each one from their home and you can discuss together the match be happy together when someone scores and stuff like this and in this case you would use let's say the streaming plugin for the TV match and there's a few plugins for interacting with your friends and so on and I mean I won't go much beyond that if not presenting some real examples of people using this later on but this is just to give you an idea of how you can actually combine these different plugins as let's say bricks to implement some kind of a more complex application. We've worked a lot on some new features recently of course what I presented so far is basically the basis of how Janus works in general so the ability to do WebRTC, the ability to handle the application logic in different plugins and so on but of course there's much more to it when it comes to using more advanced WebRTC features or actually being able to do more things with what Janus provides and one of those things is actually quite interesting is the event ender's kind of approach that allows you to do some live monitoring and debugging of whatever is happening in Janus itself and basically this is an additional means to implement a different kind of plugins where you have events generated on the fly about whatever is happening inside Janus so the core generates events, the plugins themselves generate events all these events are sent somewhere so that another component can actually process them and aggregate them and handle them somehow and we have an example in this slide that is the hover application some of you may be familiar with it because it's quite popular in the devoid world and now they're working on a new version called HEPIC that is on RTC in general but the same mechanism is also exploited by colestats.io for their Janus interaction actually we recently implemented VP8 symbol casting which works with both Firefox and Chrome and here you can see just a simple example where I'm publishing my stream as a VP8 symbol cast stream and here I'm receiving the same stream but using different spatial layers and temporal layers in this case it's not a spatial layer, of course it's just a different sub stream but you get the idea we did the same thing about with VP9 scalable video coding and this is one of the things that we actually did in collaboration with Cosmo with Cendrogar's team in particular and we basically implemented the same kind of approach so something that allows you to send a video that is actually composed of several different layers which allows you as a server to strip some of these layers in order to allow people with problematic networks, problematic connectivity to just receive part of the streams and not hold of them if they are not capable of receiving everything and still be able to see something we implemented some support for Perklight as well Perklight is one of the new efforts that is actually going on in the ITF right now and allows you to implement some kind of a double encryption I won't go too much in detail about this but this is also available currently as a pull request and we also implemented this together with Cosmo and Dr Alex over there and another cool feature that we have actually started working on right now is the Janus Lua plugin because something that I probably forgot to mention up to now is that Janus is completely written in C so if you want to implement your own plugins or your own custom model that handles media in a new way you need to actually know how to code in C and so on which can be problematic at times so what we try to do is implementing a new Janus plugin that has all the media manipulation functionality available and implemented in C but also available via some hooks as a Lua scripting kind of thing so you can write your own application logic in Lua and this will drive the actual logic in the Janus Lua plugin itself which is already proving to be kind of useful in several different scenarios Of course this flexibility that Janus says about all these different plugins implementing different things, different applications and so on means that scaling Janus is actually not as easy as it would be for a general WebRTC kind of server mostly because different plugins have completely different requirements and so it's really, you cannot avoid taking the context into account whenever you want to actually scale Janus and say for instance I want to have a web conference with a thousand participants or a webinar with ten thousand viewers or whatever these have different requirements and these all have different impacts on different plugins which means that you have to always be a bit creative whenever you want to scale Janus in principle some general knows that you can take into account when you want to scale Janus so you might do some general load balancing kind of thing if the context allows for it but you might also do some kind of brokering and so on more in general though you might want to take advantage of one of the features that we implemented some time ago that are the RTP for WordPress and an easy way to understand how these works is actually taking the broadcasting scenario into account so if we wanted to implement some kind of a large scale kind of broadcasting application where you have one person streaming and I don't know a million people watching and so on of course you cannot do this with a single Janus instance you need to use one Janus instance to inject the media somehow and then this needs to be distributed somehow and then so that multiple servers can actually serve the amount of people that you actually want to serve and this only works if you are able to forward all the media around accordingly and a simple way to do that might be employing some kind of a tree-based infrastructure where you have one Janus instance here as a node and then whatever relaying infrastructure you want in the middle something that eventually feeds other nodes at the edge that implement, that take care of all the viewers that want to actually be able to watch something and this is one of the things that you might potentially do with Janus there's actually a company that is doing something like this in the world out there so it's actually something that might actually work but this slide is just meant to make you understand that this kind of functionality might actually be used also in other contexts so creating a large scale conference application or let's say even just a conference application where you want people to be able to geographically access their own region and then still join the same conference and so on you would need to have some kind of approach like this where you have different inject points that then exchange media with each other so that they can eventually join all the same kind of multimedia application so I'm almost done so I will just take a few minutes of your time now and these last slides are just meant to showcase a bit how people are actually using Janus in the wild right now and using different things so it's not going to be a complete list but it's mostly going to be different scenarios just to showcase how flexible Janus is to actually cover all these different kind of applications and of course we use these ourselves a lot and I'll actually start with these in a minute but there are actually people that are using Janus in tons of different kind of applications like social TV, video game streaming, surveillance systems using Raspberry Pi, drones or whatever so it's really kind of cool and people are actually also starting to contribute their own code their own plugins, their own means to access Janus and so on which is really interesting but one of the ways that we ourselves use Janus is to stream the IETF meeting so I was mentioning that I am actually here to stream the IETF meeting with my colleagues and this is actually a screenshot for the RTC web meeting that we streamed today it happened this afternoon here and what we do is basically use Janus as a way to distribute the media whether it comes from the venue here or whether it is injected from the other participants so in this slide you can see I was acting as a remote participant in the RTC web so I had the chat over here I was watching the slides which was basically a capture of the projector so pretty much as it is happening here and then we had the camera that was capturing the chairs in the room and then we had the remote participant that is calling Janus here and of course since this is web RTC we can play a bit with the layouts and change the way that this media is actually presented depending on the context, depending on where you are actually with the session at this specific moment so playing with the media the interesting thing is of course that you can actually involve multiple remote participants at the same time and this is for instance from an RMCAD session from some time ago where we had the remote presenter interacting with the person Randall Jessup that was making questions from Izum because he wasn't at the venue either and then interacting with the local people at the venue there of course all of this is recorded so that we can then at the end of each meeting we convert all of these recorded sessions in a single media file and we publish it over YouTube so that we can then synchronize it with the chat and so on this is actually a recording from this week so usually at the end of each day we process the recordings and then we upload them and this is actually very useful for us for another reason as well which is the fact that at the ITF we typically have to control and take care of eight sessions at the same time which can be quite problematic because we cannot be everywhere at the same time of course so we usually deploy all of our stuff in advance before the meeting starts and then we control everything from a single room using the same components so Janus we were able to subscribe to all of the streams all the cameras, all the screen sharing and all that kind of thing and we were able to detect if there is any issue we were able to follow the speaker when they move around and stuff like this which actually made our job much easier so this is really interesting and I'm not going to much into detail very much into details about how we actually implemented all this but if you're interested in knowing more there is a slide deck on slide share in my account over here and there is also a video that I made in an interview with the VUC team right now it's about one hour and a half or two hours just talking about how we implemented all this so how we took care of accessing all the audio mixer stuff how we deployed all of this how we actually used Janus to stream all of these things in real time and so on so if you're interested just have a look it's quite cool but of course you might be more interested in what other people are using this and one cool scenario is Skyway Skyway is a team inside the entity and they are actually using Janus for IoT purposes for the internet of things and the cool thing is that they implemented their own plug-in to actually take care of all the communications serving streams and data channels and so on which was quite interesting and it's also open source you can find it over here Slack is another interesting scenario they were one of the early adopters of Janus to implement all their video conferencing functionality one thing that you actually found out at Cranky Geek is that they are using a quite old fork right now so they forked Janus a couple of years ago so they are missing a lot of things but I mean I'm an idiot I know but I like these pictures so I put it here and I still have a very interesting use case because even though they are missing some of the new stuff that we have and they still are a good example of how you can actually scale Janus to cover and serve a lot of users at the same time for conferencing purposes which was quite interesting for us Mattermost is a kind of a Slack clone but open source and they are also using Janus as their back-end TokTV is a social network a sports social network application that was created by Italian people even though their company is in the US and they are quite popular in China they recently published their application there and it's basically an application that allows you to watch matches together with your friends and be happy together when your team scores and so on and they also provide official applications for Real Madrid, Barcelona so teams that are quite large this is quite recent the services team you probably know them for their turn servers are interested in building an actual RTC infrastructure in general and so they are playing a bit with different media servers and they are also starting to play with Janus they go in touch with us to discuss that and so on and so the idea is also to be able to deploy Janus as a service on the services infrastructure so that you can scale build really large scale applications using their infrastructure which for us is kind of cool because it allows us to play with the scaling that I was mentioning before using a real infrastructure Lenovo also has an e-learning application that uses Janus as its backend Voxbone uses it for their click-to-call functionality the click-to-box application Convoso is a remote contact sensor solution they also are using Janus for this which is quite cool Veting is a business conferencing solution that allows you to do white labelled web conferencing and it uses a mix of Janus and Asterisk in the backend this is another interesting application they are currently in beta but they ever cast works on media production so yet another use case that is actually quite interesting and we are also helping them build this which is challenging but interesting for us there are a couple of interesting open-source solutions as well like Django which is a name that I wish I had come up with myself because it's really cool it's a mix of Janus and Gao so they basically wanted to create their own clone of Hangouts using Janus Janus has the only backend so everything, audio, video, chat is built on top of Janus which was quite interesting for us there's Silk server as well which is a CPEX MPP application server and they have their own mobile applications deployed to these and so on and last but not least of course the video game streaming is something that is actually gaining a lot of traction recently and there are actually different video streaming providers that are actually using Janus right now in the wild one of them is Mixer.com the streaming service that Microsoft uses for the Xbox they actually acquired Beam.com sometime ago which was using us and so they continued to use us for this there's Bebo which is or Bebo I'm not exactly how it's pronounced which is an application that allows you to stream to Twitch using WebRTC which is kind of cool and of course most importantly we have the author here we have Ev Assist which is another video game streaming application of course I'm not going too much into the details because Jordan is here and is going to talk about this in just a few minutes so I don't want to say anything that might actually turn out to be false and so I'm basically done so just to say a few things about what we want to do next we've built pretty much everything with respect to WebRTC implementation but there are a couple of things that are still missing so one of these is improved renegotiation mechanisms like ICE restarts that we do have as a pre-request but it's not out there yet but most important in multi-stream so we don't implement neither Plan B nor Unified Plan at the moment and we want to implement Unified Plan as soon as possible it's kind of a priority for us I already mentioned the Janus Lua plugin that actually gave us the idea that if we make the life for developers easier by using Lua we might actually do the same for other programming languages so we might expose ways to control a Janus plugin via JavaScript equal Python or whatever else this might open a lot of doors for us in the future and as I was saying we want to keep on working on improving the scaling solutions for Janus so making sure that you can actually whatever kind of application you have in mind there are ways for you to use a lot of Janus instances together in order to build this and for this I'm pretty sure that our partnership also with Cosmo will help us do this Xerces is an interesting kind of solution and in general this will allow us also to let's say eventually come up with even some kind of a platform as a service solution that is Janus-based or something like this but most importantly and the main reason why I'm here is I was really interested in making people aware of Janus in the first place so if this is something that interested you with this spark of your interest just install it, play with it, play with the demos try to write your own applications I mean just play with it and let us know if it's actually helpful or not and I'm probably way over time but I'm done finally so if you have any questions or comments I'm here to take them thank you