It seems pretty clear that using multiple CDNs to deliver media is a good thing; but it’s hard to do effectively. What is the best policy to use? How do you determine when to switch? How often do you switch? Do you switch based on client performance alone, consolidated user metrics, or something else? What happens when the CDN you switched to isn’t performing as good as you thought it would? Answering these questions (let alone designing a multi-CDN switching architecture) is enough to give anyone a headache. What if we throw out “switching” by downloading media from multiple CDNs at the same time? We could then realize the best performance by merging the performance of each. Seems simple enough until you start trying to do it efficiently. Do you race media from multiple CDNs at the same time, or do you try to perform sub-segment/byte-level scheduling? This seems even more complicated than before! This talk will focus on how to implement and deploy a switchless multi-source media delivery platform that is highly performant and efficient which avoids having to answer these difficult questions or solving massively complicated scheduling problems.

Enabling true multi-source delivery without all the fuss requires us to do something a little bit unique to the content we are streaming. We first create multiple “versions” (one for each source aka. CDN) of each and every HLS or MPEG-DASH segment. This is done by packaging these segments into something called the Coded Multisource Media Format (CMMF), which is currently being standardized in ETSI. CMMF is essentially a container that is used to communicate network encoded content (network coding is kind of like forward error correction (FEC), but not – we’ll expand upon this more during the talk). Each CMMF version is then cached on a different CDN. Now let’s say a media player wants to download a particular video segment. Instead of downloading the entire segment from one CDN or requesting bytes x1 through y1 of that segment from one CDN and x2 through y2 from another, the media player requests multiple CMMF versions of that segment from different CDNs at the same time. Once the player receives enough data (the amount required is very close to that of the original segment) from the collection of CDNs, it can stop the download and recover the segment it wanted. By doing it this way, we don’t have to worry about hiccups (like temporary congestion or slow response times) on one CDN because we will just download more from the others. During the talk, we will introduce CMMF, the core concepts behind it, as well as go over how we deployed it within a streaming service with 20+ million subscribers world-wide and streamed approximately one million hours of content using it. We will also provide performance data that shows how CMMF-enabled multi-CDN delivery stacks up against a popular multi-CDN switching approach (as you can guess, it stacked up well). We hope this talk provides the audience with a different perspective to an “age-old” problem and inspires them to explore multisource delivery in greater detail. This talk was presented at Demuxed 2024, a conference by and for engineers working in video. Every year we host a conference with lots of great new talks like this in San Francisco. Learn more at https://demuxed.com