• IETF - Janus - Meetecho - MoQ - QUIC - WebRTC

    Streaming the IETF MoQ sessions with MoQ… kinda!

    For quite some time, Meetecho has been the official tool for remote participation at IETF meetings. While this includes a plethora of different tools to support all the different features that are required in IETF meeting sessions (e.g., Zulip integration, slide sharing, queue management, polls, etc.), the core of the remote participation functionality is rooted in its WebRTC capabilities, which is powered by our open source Janus WebRTC Server. A few years ago I shared a high level overview (at the MBONED working group too) on how we use the different features Janus provides to scale all of this for…

  • IETF - Janus - Meetecho - MoQ - QUIC - WebRTC - WHIP

    Can MoQ and WebRTC be friends?

    I talked a lot about my QUIC, RTP Over QUIC (RoQ) and Media Over QUIC (MoQ) experiments, lately. This eventually led to the release of a dedicated open source library, called imquic, that could provide a testbed to play with them all. Just last week I made a presentation at CommCon to talk about my latest efforts in that sense: studying the parallels, if there are any, between MoQ and WebRTC, in order to try and figure out some common grounds for interoperability purposes. After all, the people behind these two worlds seem not to like each other very much,…

  • IETF - Janus - Meetecho - QUIC - RoQ - WebRTC

    Janus RoQs!

    While WebRTC obviously still has my undivided attention, I’ve been playing more and more with QUIC too, recently. On this very blog, I talked about me getting started with QUIC, my first experiments with RTP Over QUIC (RoQ) and Media Over QUIC (MoQ), and our imquic open source QUIC library, that I introduced at FOSDEM as well just a few months ago. Considering that I firmly believe WebRTC and real-time media on QUIC will co-exist for quite a while, I thought it was time to start sharing some of my efforts in that direction, and specifically about what I’ve done…

  • AI/ML - Janus - Juturna - Meetecho - WebRTC

    Real-time AI pipelines with Juturna!

    Working with real-time media has always been cool (it definitely never really felt like work to me!), but that has started to become even funnier in the past few years. The explosion of AI/ML really opened the doors to interesting new opportunities in the real-time multimedia space, especially when it comes to integrations in WebRTC-based workflows. As a research-oriented company, we were of course quite intrigued by the possibilities, and that eventually led us to start working on a new open source project called Juturna, which is what I’ll introduce in this blog post, and what my colleague Antonio Bevilacqua…

  • IETF - Janus - Meetecho - WebRTC - WHEP - WHIP

    Node.js WHIP/WHEP server libraries

    We’ve talked many times about WHIP and WHEP on this blog post. Since before WHIP was even a thing on the IETF’s radar, we prototyped it with CoSMo, as it seemed like a great first step towards my dream (and Ph.D thesis topic) of having a pure WebRTC based broadcasting solution. We then covered it even more after it was adopted in the IETF WISH Working Group, until it was time to address how to distribute a WHIP ingested stream using WHEP, and all the updates it then went through. WHIP also was a great opportunity for us nerds to…

  • Janus - Meetecho - SIP - WebRTC

    Dial-out and cascaded mixing with the AudioBridge

    A couple of years ago I wrote a blog post explaining how I used some existing features in the AudioBridge plugin to allow SIP endpoints to dial-in and join a conversation that would normally be limited to WebRTC participants alone. That worked nicely and, at the time, it also was an interesting opportunity to play a bit with Drachtio as the framework to mediate between the Janus API and SIP. That said, it also showed some limitations: in particular, it only allowed SIP endpoints to dial-in, but there was no way to have the conference bridge “dial-out” instead. As such,…

  • IETF - Janus - Meetecho - MoQ - QUIC - RoQ - WebRTC

    Introducing imquic!

    These past few months I’ve shared a lot of info on my experiments with QUIC as a new transport for real-time media. I detailed my efforts on writing a basic QUIC stack, followed by deeper dives in RTP Over QUIC (RoQ) and, most importantly, Media Over QUIC (MoQT), where I tried to sketch and prototype a potential interoperability between QUIC and WebRTC as well. I eventually ended up making a presentation on all this and more at RTC.On. In all of those blog posts (and in the presentation) I mentioned a library I was working on to prototype these new…

  • IETF - Meetecho - QUIC - RoQ - WebRTC

    RoQ ‘n’ roll! (Playing with RTP Over QUIC)

    A few weeks ago I shared my experience studying and implementing QUIC from scratch: in shortly less than a month, I went from not knowing anything about QUIC, to have a basic stack (with WebTransport support) I could use for interacting with other implemenentations on simple scenarios. Getting to that point was bumpy (QUIC is not an easy protocol to implement!) but exciting as well, and I really couldn’t wait to start looking into some of the media related protocols that people are using QUIC for. In this blog post I’ll share some details on the work I did on…

  • Events - Janus - Meetecho - SIP - WebRTC

    The return of JanusCon!

    After five long years from the first edition, our Janus conference was finally back, once again in our beautiful Naples! More precisely, we met RTC developers and aficionados from all over the world on the 29th and 30th of April 2024, for two days of fun and interesting presentations. Great food was eaten, amazing weather was enjoyed, and I think we all had a lot of fun! If you want to check the recordings or the slides of the talks, you can find them in the schedule section of the JanusCon website. This is something I was really looking forward…

  • IETF - Janus - Meetecho - WebRTC

    Bandwidth Estimation (BWE) and Janus

    A few weeks ago I attended the first edition of what turned out to be a great event, RTC.On, and I took that opportunity to submit a talk on something I wanted to work on for quite some time: bandwidth estimation in WebRTC and, more specifically, Janus. The main objective of that presentation was not only to “force” myself to work on this topic and share the results, but also to try and provide everyone with some more insight on what is ostensibly one of WebRTC’s best kept “secrets”: not out of malice (at least I don’t think so), but…