Lorenzo Miniero's presentation discusses QUIC and its significance, detailing its specifications and implementations. It covers the complexity of developing a QUIC stack, including the integration of media over QUIC (MoQ) for low-latency media delivery, and highlights ongoing work and next steps for the QUIC and MoQ projects. The presentation emphasizes the importance of interop testing and open-source development to advance these technologies.

1. WebRTC and QUIC: how hard can it be?
Lorenzo Miniero RTC.ON @ Krakow September 12, 2024

2. Who am I?
Lorenzo Miniero
• Ph.D @ UniNA
• Chairman @ Meetecho
• Main author of Janus
Contacts and info
• lorenzo@meetecho.com
• https://fosstodon.org/@lminiero
• https://www.meetecho.com
• https://lminiero.it

3. Just a few words on Meetecho
• Co-founded in 2009 as an academic spin-off
• University research efforts brought to the market
• Completely independent from the University
• Focus on real-time multimedia applications
• Strong perspective on standardization and open source
• Several activities
• Consulting services
• Commercial support and Janus licenses
• Streaming of live events (IETF, ACM, etc.)
• Proudly brewed in sunny Napoli, Italy

4. Nice recent picture from Napoli...

5. ... with a few familiar faces!

6. QUIC has been on my mind for a while...

7. What’s QUIC and why does it matter?

8. What’s QUIC and why does it matter?

9. Learning about QUIC
• Spread over different RFCs
• https://datatracker.ietf.org/doc/html/rfc8999 (QUIC invariants)
• https://datatracker.ietf.org/doc/html/rfc9000 (QUIC v1 itself)
• https://datatracker.ietf.org/doc/html/rfc9001 (QUIC + TLS)
• https://datatracker.ietf.org/doc/html/rfc9002 (Congestion control)

10. Learning about QUIC
• Spread over different RFCs
• https://datatracker.ietf.org/doc/html/rfc8999 (QUIC invariants)
• https://datatracker.ietf.org/doc/html/rfc9000 (QUIC v1 itself)
• https://datatracker.ietf.org/doc/html/rfc9001 (QUIC + TLS)
• https://datatracker.ietf.org/doc/html/rfc9002 (Congestion control)
• Many related efforts
• https://datatracker.ietf.org/doc/html/rfc9114 (HTTP/3)
• https://datatracker.ietf.org/doc/html/rfc9204 (QPACK)
• https://datatracker.ietf.org/doc/html/rfc9221 (DATAGRAM)
• https://datatracker.ietf.org/doc/html/draft-ietf-webtrans-http3
(WebTransport)
• ...

11. Learning about QUIC
• Many existing implementations
• https://github.com/ngtcp2/ngtcp2 (C)
• https://github.com/private-octopus/picoquic (C)
• https://github.com/litespeedtech/lsquic (C)
• https://github.com/aiortc/aioquic (Python)
• https://github.com/google/quiche (C++)
• https://github.com/cloudflare/quiche (Rust)
• https://github.com/quic-go/quic-go (Go)
• ...

12. Learning about QUIC
• Many existing implementations
• https://github.com/ngtcp2/ngtcp2 (C)
• https://github.com/private-octopus/picoquic (C)
• https://github.com/litespeedtech/lsquic (C)
• https://github.com/aiortc/aioquic (Python)
• https://github.com/google/quiche (C++)
• https://github.com/cloudflare/quiche (Rust)
• https://github.com/quic-go/quic-go (Go)
• ...
• Incredibly useful blog posts!
• https://www.andy-pearce.com/blog/posts/2023/Mar/http3-in-practice-quic/
• https://www.andy-pearce.com/blog/posts/2023/Apr/http3-in-practice-http3/

13. Implementing a QUIC stack from scratch

14. Spoiler alert: not that easy...
https://www.meetecho.com/blog/quic-journey/

15. Starting from the basics
• Started with a basic parser
• Familiarize with varint, connection IDs, QUIC transport parameters, header
protection, ACK, message framing, etc.

16. Starting from the basics
• Started with a basic parser
• Familiarize with varint, connection IDs, QUIC transport parameters, header
protection, ACK, message framing, etc.
• Moved to a basic hardcoded server
• Figure out (levels of) encryption, new messages, STREAM, etc.
• Understanding the way buffering/chunking works for STREAM

17. Starting from the basics
• Started with a basic parser
• Familiarize with varint, connection IDs, QUIC transport parameters, header
protection, ACK, message framing, etc.
• Moved to a basic hardcoded server
• Figure out (levels of) encryption, new messages, STREAM, etc.
• Understanding the way buffering/chunking works for STREAM
• Generalized the server and started the client side
• Slightly different things clients and servers have to do

18. Starting from the basics
• Started with a basic parser
• Familiarize with varint, connection IDs, QUIC transport parameters, header
protection, ACK, message framing, etc.
• Moved to a basic hardcoded server
• Figure out (levels of) encryption, new messages, STREAM, etc.
• Understanding the way buffering/chunking works for STREAM
• Generalized the server and started the client side
• Slightly different things clients and servers have to do
• Super simple demos against aioquic
• DoQ (DNS over QUIC) demo apps very helpful

19. Adding support for WebTransport

20. A simple interop demo

21. A simple interop demo

22. Having a look at RTP Over QUIC (RoQ)
• IETF is defining how to transport RTP on top of QUIC
• https://datatracker.ietf.org/doc/draft-ietf-avtcore-rtp-over-quic/

23. Having a look at RTP Over QUIC (RoQ)
• IETF is defining how to transport RTP on top of QUIC
• https://datatracker.ietf.org/doc/draft-ietf-avtcore-rtp-over-quic/
• Using QUIC, there are things we can (or have to) do differently
• No need for SRTP, QUIC is already encrypted
• Some feedback RTCP provides QUIC can already give us
• QUIC has integrated BWE as well
• We need framing for RTP packets (as in TCP)

24. Having a look at RTP Over QUIC (RoQ)
• IETF is defining how to transport RTP on top of QUIC
• https://datatracker.ietf.org/doc/draft-ietf-avtcore-rtp-over-quic/
• Using QUIC, there are things we can (or have to) do differently
• No need for SRTP, QUIC is already encrypted
• Some feedback RTCP provides QUIC can already give us
• QUIC has integrated BWE as well
• We need framing for RTP packets (as in TCP)
• Multiplexing has interesting opportunities too
• Can multiplex multiple sessions over the same QUIC connection (Flow ID)
• Multiplexing can be done in different ways (DATAGRAM vs. STREAM(s))

25. RoQ multiplexing
https://www.meetecho.com/blog/roq-n-roll/

26. A basic client/server demo

27. Involving Janus (and WebRTC!)

28. Involving Janus (and WebRTC!)

29. Involving Janus (and WebRTC!)

30. Interop @ IETF 120 Hackathon

31. Interop @ IETF 120 Hackathon

32. A step further: Media Over QUIC (MoQ)
• Low-latency media delivery solution for ingest/distribution of media
• https://datatracker.ietf.org/group/moq/about/

33. A step further: Media Over QUIC (MoQ)
• Low-latency media delivery solution for ingest/distribution of media
• https://datatracker.ietf.org/group/moq/about/
• Publisher/Subscriber kind of approach
• Possible roles are Publisher, Subscriber and PubSub
• Not that far from a cascaded SFU, if you’re familiar with WebRTC

34. A step further: Media Over QUIC (MoQ)
• Low-latency media delivery solution for ingest/distribution of media
• https://datatracker.ietf.org/group/moq/about/
• Publisher/Subscriber kind of approach
• Possible roles are Publisher, Subscriber and PubSub
• Not that far from a cascaded SFU, if you’re familiar with WebRTC
• MoQ transport on top of QUIC or WebTransport
• Encryption via QUIC, but E2EE encryption possible too
• Independent of media formats (can transport anything media)
• Support for relays, caching and replication points

35. The simplest architecture diagram

36. Something a bit more complex

37. Objects, Groups and Tracks

38. Implementation status
• Different implementations (sometimes different MoQT versions)
• https://github.com/kixelated/moq-rs (pub/sub/relay)
• https://github.com/facebookexperimental/moxygen (relay)
• https://github.com/Quicr/libquicr (relay/pub/sub)
• https://github.com/facebookexperimental/moq-encoder-player (pub/sub)
• https://github.com/kota-yata/media-over-quic-experiment (pub/sub)
• https://github.com/mengelbart/gst-moq-app (pub/sub)

39. Implementation status
• Different implementations (sometimes different MoQT versions)
• https://github.com/kixelated/moq-rs (pub/sub/relay)
• https://github.com/facebookexperimental/moxygen (relay)
• https://github.com/Quicr/libquicr (relay/pub/sub)
• https://github.com/facebookexperimental/moq-encoder-player (pub/sub)
• https://github.com/kota-yata/media-over-quic-experiment (pub/sub)
• https://github.com/mengelbart/gst-moq-app (pub/sub)
• Regular interop tests as part of the MoQ WG
• Current interop matrix discussed at IETF 120
• No report sent for my implementation yet (hopefully soon!)

40. MoQ @ IETF 120

41. MoQ @ IETF 120

42. MoQ @ IETF 120

43. Prototyping MoQ
• Integrating MoQ (both -03 and -04) in my test library itself
• Leverages library core and events
• Exposes MoQ-specific APIs to end user

44. Prototyping MoQ
• Integrating MoQ (both -03 and -04) in my test library itself
• Leverages library core and events
• Exposes MoQ-specific APIs to end user
• Different demo applications for testing
• imquic-moq-pub: basic MoQ publisher (same as Luke’s moq-clock)
• imquic-moq-sub: basic MoQ subscriber (different formats)
• imquic-moq-relay: relay stub (doesn’t do anything meaningful yet)
• Janus QUIC plugin: gatewaying of MoQ pub/sub to WebRTC (using LOC)

45. Prototyping MoQ
• Integrating MoQ (both -03 and -04) in my test library itself
• Leverages library core and events
• Exposes MoQ-specific APIs to end user
• Different demo applications for testing
• imquic-moq-pub: basic MoQ publisher (same as Luke’s moq-clock)
• imquic-moq-sub: basic MoQ subscriber (different formats)
• imquic-moq-relay: relay stub (doesn’t do anything meaningful yet)
• Janus QUIC plugin: gatewaying of MoQ pub/sub to WebRTC (using LOC)
• A few interop tests for validation
• Luke’s moq-rs (clock, relay, subscribing to MP4 video)
• Meta’s implementations (using relay, translating encoder/sender)

46. moq-rs + imquic

47. moq-rs + imquic

48. moq-rs + imquic

49. moq-rs + imquic

50. moxygen + moq-encoder-player (Meta)

51. MoQ + WebRTC (via Janus/imquic)
https://www.meetecho.com/blog/moq-webrtc/

52. MoQ + WebRTC (via Janus/imquic)
https://www.meetecho.com/blog/moq-webrtc/

53. MoQ + WebRTC (via Janus/imquic)
https://www.meetecho.com/blog/moq-webrtc/

54. Next steps
• A LOT still to do
• QUIC stack itself is incomplete (took some shortcuts to get here)
• Retransmissions and flow/congestion control still missing

55. Next steps
• A LOT still to do
• QUIC stack itself is incomplete (took some shortcuts to get here)
• Retransmissions and flow/congestion control still missing
• Keep up to date with MoQ
• Working group is very active
• Specification changes often, thanks to feedback from implementations

56. Next steps
• A LOT still to do
• QUIC stack itself is incomplete (took some shortcuts to get here)
• Retransmissions and flow/congestion control still missing
• Keep up to date with MoQ
• Working group is very active
• Specification changes often, thanks to feedback from implementations
• Release all this as open source, of course
• The library needs improvement and documentation
• Hopefully we’ll get there soon, stay tuned for that!

57. Next steps
• A LOT still to do
• QUIC stack itself is incomplete (took some shortcuts to get here)
• Retransmissions and flow/congestion control still missing
• Keep up to date with MoQ
• Working group is very active
• Specification changes often, thanks to feedback from implementations
• Release all this as open source, of course
• The library needs improvement and documentation
• Hopefully we’ll get there soon, stay tuned for that!
• Testing testing testing!
• Interop (for everything, from QUIC to MoQ) will be fundamental

58. Thanks! Questions? Comments?
Contacts
• https://fosstodon.org/@lminiero
• https://x.com/elminiero
• https://x.com/meetecho
• https://www.meetecho.com/blog/