Video hosted by Apple at devstreaming-cdn.apple.com

Configure player

Close

WWDC Index does not host video files

If you have access to video files, you can configure a URL pattern to be used in a video player.

URL pattern

preview

Use any of these variables in your URL pattern, the pattern is stored in your browsers' local storage.

$id
ID of session: meet-with-apple-283
$eventId
ID of event: meet-with-apple
$eventContentId
ID of session without event part: 283
$eventShortId
Shortened ID of event: meet-with-apple
$year
Year of session: 2026
$extension
Extension of original filename: mp4
$filenameAlmostEvery
Filename from "(Almost) Every..." gist: ...

Meet with Apple • Session 283

IETF HLS Interest Day

2026-10-07 • iOS, macOS, tvOS, visionOS • 3:22:33

Join us for an online broadcast designed for engineers and professionals working with HTTP Live Streaming (HLS) technologies. The event will feature presentations by Apple and other members of the HLS community, as well as a live Q&A with Apple engineers.

Speakers: Sergey Maliuk, Roger Pantos, Aparna Akella, Rob Walch, Sumayya Syeda, Eryk Vershen, Ted Hosmann, John Gainfort, Naiwei Zheng, David Hassoun, Rob Galluccio

Open in Apple Developer site

Transcript

Hello. Good morning everyone, and welcome here to Cupertino and those who are joining us online. Welcome to our live stream. My name is Sergey and I’m your host today. My colleagues and I are really excited to host HLS today here at the Apple Developer Center. This developer center is one of four developer centers around the world, and it’s part of Apple Park, and it’s an amazing venue for events like this.

This room is Big Sur. It’s designed for in-person presentations, studio recordings, and live broadcasts. There are also labs, briefing rooms, and conference rooms. You will be able to experience what these rooms have to offer in our afternoon activities later today And here is an overview of agenda. All the sessions start and end times are in Pacific Daylight Time. The focus today is HLS and everything related to it. There is a lot to cover.

First, Roger presents the latest updates to the HLS specification. Then Aparna will talk about updates to media streaming APIs in OS 27. Then Rob will share updates in the HLS open source library. Next, Sumayya will introduce four practical tips on scaling FairPlay key servers. At 10 a.m., Cupertino time will have 15 minute break, and after the break, Eryk will introduce the brand new version of Media Stream validator and present other HLS tools updates.

Then Ted will show how to deliver video to Apple Podcasts using HLS. And after, John will take us through a proposal to introduce playlist archives in HLS at 11 a.m. there will be another break for ten minutes and after the break. Regulatory requirements for loudness control and sign language by Naiwei.

Then concurrent media experience proposal by the SVTA presented by David Hassoun from CoLabs. And finally, Rob Galluccio from NBCUniversal will present his teams learning from deploying dynamic ad insertion at scale and low latency. At 12 p.m., lunch will be served in the coffee break area across the hall from the theater and upstairs.

I’m sure many of you will have questions for our presenters today. We’ll host a Q&A here in the Big Sur Theater at 1 p.m. right after lunch. We’ll ask as many questions as time permits. If you are joining us in person, please scan this QR code to submit questions or feedback you may have for presenters today. You can also find this QR code on the stands outside the theater.

For those watching us online on the Apple Developer platform, you can ask your questions directly in the app or web browser. There, you can also upvote questions asked by others. This will help us prioritize. I’ll give you a few seconds to scan this QR code. I can move for people over here.

All right. Next, community discussions are Moderated conversations held in roundtable format between industry experts. There are two community discussions today at 2 p.m. Evolution of HLS focused on potential future requirements for HLS and a three story media production and delivery focused on deployment of new features such as low latency interstitials, etc. They will take place in the meeting rooms of the. On the other side of the lobby. Please note that the capacity of these rooms is limited and access will be provided on a first come, first served basis for all of the signs outside to join these activities.

Another activity we are pleased to offer today is hands on workshops. It will cover practical aspects of using the newly released version of mediastreamvalidator, whether you use it before or not. This session will provide useful information on how to check your streams. Conformity with the HLS specification. I highly encourage you all to take the chance to join this activity.

You can join to listen or bring your laptop to follow along. This session will run three times at 2 p.m., 3 p.m. and 4 p.m., and will be offered on a first come, first serve basis as well. It will be hosted in the High Sierra Classroom with an overflow available in Mavericks. You can find signs outside of the theater with directions.

Another activity you can benefit from today is one on one appointments. At one on one appointments. You can connect directly with Apple engineers for guidance on your apps and projects. Some of you have already booked these appointments before coming here. We also have several more available. Stop by a concierge, stand near the coffee break area to book your appointment. There are 30 minutes each and you can select one of the available topics from the list.

Once booked, please come to concierge. Thanks again. A few minutes before your appointment and someone from the events team will help you to the meeting room. And finally, at 5 p.m., there will be a mixer at the coffee break area and lobby. This is a perfect opportunity to network or chat with your colleagues from the industry in a relaxed environment. Light refreshments and beverage will be served.

A quick note to everyone here in person. There is an open WiFi network that you can use to stay connected throughout the day. No password is required. in front of your armrest. They are located there now. Rest. They are located there now. These presentations are meant to be a special experience just for you, both online and in person.

So I ask you all to refrain from recording video or live streaming during the presentations. We’ve got that covered for you. You are welcome to take photos throughout the event so you won’t miss a thing. And with this small request out of the way, I would like to welcome our first presenter on stage. Roger. Take it away. Thank you. Sergey.

HLS specification updates

Hello. Good morning. Welcome to this year’s summit. In this session, I’m going to give you a quick retrospective of what changed in the HLS specs since the fall of 2025. I’m going to talk about the Rfc’s that we are publishing this year in 2026. The changes we made to the specs as part of that publication process. And finally, a number of new features in the specs.

So first, let’s talk about Rfc’s. The last time the IETF published an HLS RFC was back in 2017 with RFC 8216, the OG. Since then, there have been a number of iterative updates as internet drafts. But two years ago, right here, there was a request to extract content steering from the HLS spec and publish it separately so that other standards like Mpeg-dash could use it too. That kicked off an effort to replace RFC 8216 with new Rfc’s to bring it up to date with the last nine years of HLS development. Well, I’m happy to announce that it’s now nearly there.

The HLS team at Apple has two new Rfc’s ready to publish. The first will be content steering and the second an update to the HLS spec. Both rfc’s have passed through the IETF Publication review and are now waiting in the publishing queue. I expect them to emerge any week now.

In fact, I wrote this slide earlier hoping that I’d be able to fill in these numbers before this presentation, but they’re not out yet. So when they do come out, I will send out an email. In the meantime, let me take you through the changes we made during the iATf review.

There were a number of small draft updates along the way to address different points of feedback. For the first RFC, the most significant change was renaming it from just content steering to pathway based content steering. That happened because it turns out there are other groups in the IETF working on different kinds of content steering, not necessarily all for media content. And they quite reasonably pointed out that naming a new RFC, just content steering no qualification. Might cause some confusion down the line. So now it’s a bit more descriptive. Otherwise, the changes were mainly fixing various typos and adding qualifications. Where reviewers found possible ambiguity.

The HLS spec was a bit more involved. It covered four revisions with some significant changes that included in response to your feedback. Some clarifications to how the preload date range period should be determined. There’s also a new and hopefully helpful diagram for how custom media selection schema works. Glossary. A new encryption mode, which I’ll get to in a second. And of course, a bunch of clarifications and typo fixes.

The more consequential thing for most of you is that from 2025 to 2026, some significant features were added to HLS. This included authenticating encrypted segments, preloading content, keys, and live streams when joining a rather decisioning. Upcoming adds in advance when joining a live stream, decisioning add breaks as a mix of different interstitials and a way to mark up certain custom media selections with characteristics.

So the first new feature is Authenticated Segments. This was driven by privacy first use cases such as security camera feeds. Content like that often includes not only video but also metadata such as time and date and location that the owners would like to keep private as well. AES-256-GCM is a new encryption mode is defined for full segment encryption only.

It includes an authentication tag that enables clients to detect if a segment has been replaced or tampered with, including. It aligns HLS with the new matter spec for video cameras. Of all the features I’m discussing today, this one is the only one that made it into the upcoming RFC. The rest of what I’ll talk about today are in the WWDC26 draft draft update.

Once we have a new HLS RFC, those changes will be published in a new Internet-draft series. Next. Preloading keys. This is designed to help Provider scale DRM key rotation in live streams. It takes the existing preload hint tag and adds a key type to it, along with a date of first use.

This allows live streams to drop a preload hint tag early in the stream, before the expected first use of the key, and for clients to evenly spread requests for that key over that period, which lowers the peak demand on the key server. Sumayya will go into more detail about this in her talk later this morning.

The next feature is also focused on live streams, but this one is more about scaling your ad decisioning. The scenario is that normally clients will hit an ad server at the time. It is to, you know, at the right time to buffer the ad. And for live streams, that tends to be all at once.

Last year, HLS defined the preload date range, which is a mechanism for clients already in the stream, to spread out the ad decisioning in advance. This year, that class got a new attribute duration at Join that extends the preload mechanism to clients who join the live stream at some later point after the original preload period has expired. And later today, Rob Galluccio from Peacock is going to talk about dynamic ad insertion at scale, and he’ll dive into preloading ads in more detail.

Rounding out the new interstitial features is heterogeneous ad decisioning, or a way to late bind an ad break with multiple interstitials of different types. This all started at last year’s summit, where some of you said that while you love the ability to late bind ad requests using interstitial asset lists, you want to include assets of different types with different skip treatments like a network banner and an ad and then a show preview. So HLS introduced a new class, the date range schedule.

It is ordered and loaded like an interstitial. The difference is that its URL points to an array of more date ranges that get dynamically added to the player’s timeline. The syntax for the date range schedule allows it to contain any class of date range. That being said, today AVPlayer supports just two, which are interstitials and nested schedules. And again, you’ll hear more about date range schedules in Rob Galluccio talk later this morning.

The final feature is the language decoration object, which was added to custom media selections in appendix G of the HLS spec. It was introduced to give content vendors a way to annotate certain selections in the custom media selection scheme. For example, a provider could mark certain translations as pending review by a human expert.

The way this works is that the custom media selection. Jason can specify characteristics that identify renditions to be annotated. The player UI will use that information to display the annotation appropriately in the selection user interface. The system player may also support its own annotation or badging of certain well-known characteristics, such as public dot translation and public dot machine generated for subtitles and audio renditions.

So in the near future. There are a couple of things you should do. The first. Familiarize yourself with the latest spec changes, particularly if you’re working in one of the areas that I mentioned. The latest internet drafts are on ietf.org, where there’s even a tool to see the difference between each version on the Data Tracker page.

The WWDC26 preliminary draft of the HLS spec is on developer.apple.com/streaming. Finally, keep an eye out for those new RFCs. Once they are published by the IETF. They will form a new baseline for spec compliance for both HLS and content steering, so you’ll want to update any developer documentation that you maintain to point to them.

Okay, so that’s all our spec updates for today. Please remember that if you’d like to ask something about what I just covered, You can scan this QR code to submit a question to our panel discussion later this afternoon, or you can find me in a breakout. Thank you. Now I’m going to pass it off to Aparna. Thanks, Roger. Hi, everyone.

What’s new in HLS on Apple platforms

I’m Aparna. I’m a software engineer on the streaming team. The HLS player on Apple platforms has recently received several updates. I’ll go over what’s new and what these features mean for your app. I’ll talk about changes starting with live activities for offline downloads, generated subtitles, extracting audio samples for processing, modifying rendered audio, AVMetrics, support for AirPlay and HDR updates.

First live activities for offline downloads starting in iOS 27 for better transparency. Background HLS downloads via AVAssetDownloadTask show as a live activity. This appears on both the lock screen and the Dynamic Island and shows real time progress. The downloads can also be canceled directly from the live activity without having to reopen the app.

The live activity appears as a full width card, your app’s icon, the download title, a progress indicator, and a stop button on the Trailing edge app initiated, smart and opportunistic download features are becoming increasingly popular. It’s worth calling out that people may be surprised if To achieve opportunistic downloads, set NSURLSessionConfiguration’s discretionary property to yes, Discretionary property to yes, tasks with this configuration are exempt from displaying the live activity. However, they’re also scheduled at a lower priority. The system makes the decision of when to download based on factors like thermals, battery levels, and network connectivity. If you have any questions or feedback in this area, sign up for a one on one lab with engineers from AVFoundation and storage team for later today.

That’s Live Activities for downloads. Next generated subtitles. Nowadays, many people rely on subtitles in cases where they’re not provided or not available in the desired language. Apple operating systems can now generate subtitles. There are two sources for generated subtitles. They can be generated by transcribing audio in the asset with the speech to text model, or by translating authored subtitles into other languages.

In both cases, this is done on the device generated subtitles are made available automatically during video playback. Availability varies by platform, so in iOS 27 and macOS 27, English subtitles can be generated from English audio. The same works on tvOS 27 and visionOS 27. Translation into multiple subtitle languages, starting with English subtitles, is available on iOS and macOS.

For much more on this, watch discover generated subtitles and subtitle styles from Wwdc 26 that’s generated subtitles. Next, extracting audio for processing ahead of playback during playback. You can now access decoded audio data ahead of the current playhead position. An example use case for this is building a live transcript of audio as it plays, or for rendering a waveform representing the audio. This is available on macOS today and will be added to other platforms soon. The API hands you decoded PCM audio. It works for all audio content except for FairPlay encrypted content.

To use this, first create an audio configuration and set its requested audio format to the format you want the samples delivered in. Second, create an AVPlayerItemSampleBufferOutput with that configuration. It delivers the decoded audio as CMSampleBuffers. These are buffers carrying audio samples, plus their timing information. Third, attach the output to your AVPlayerItem by calling Add Output and from then on, audio arrives in the format that you asked for.

Next, modifying rendered audio. This similar API for retrieving audio in real time: MTAudioProcessingTap. It lets you insert your own processing into the audio path, allowing you to apply effects to the audio before it reaches the speakers. MTAudioProcessingTap has been really popular for processing file based content and great news. Now it works with HLS content as well as with sample buffer output. All audio is supported except for FairPlay encrypted content. To use this, make sure to create AVAudioMixInputParameters using AVAudioMixInputParameters. Track mix ID that identifier targets the players final mixed output rather than any single track.

These two APIs sound similar. Both operate on the timeline of the object of the item, so here’s how to choose between them. MTAudioProcessingTap lets you change the audio people actually hear. It runs close to real time, which means their tight timing constraints on whatever you do inside the callback AVPlayerItemSampleBufferOutput gives you the source audio decoded to linear PCM, but it can’t alter what the player renders. In exchange, it can deliver audio much further ahead of the current playback time. So to change the sound, use the tap to read ahead. Use sample buffer output. That’s extracting and modifying audio. Now onto AVMetrics support for AirPlay.

AVMetrics lets you monitor how the player performs with HLS assets. It reports discrete events during playback session, like how long the startup took when the player switched variants. Playback events such as seeks, rate changes and stalls, error events, summary events at the end of the session, and so on. Starting in iOS 27 during AirPlay, video playback AVMetrics works. Whether you’re playing to an Apple TV, 4K, or an AirPlay enabled smart TV.

This means you get the same playback metrics whether the content plays locally or streams over AirPlay. Video. The event classes are identical, so you don’t have to change any code to receive these events. There’s also a new event introduced in OS 27: AVMetricPlaybackModeSwitchEvent. It fires whenever playback changes mode.

A mode is either local or AirPlay video, so this event tells you exactly when playback moves from the device to an AirPlay destination and back. For the full set of AV metric events, watch Discover Media Performance metrics in AVFoundation from Wwdc 24. There’s also a documentation on AV metrics on developer.apple.com. In 2025, we presented an in-depth session on AV metrics at HLS Interest Day. It is also available on the Apple Developer website.

That’s AV metrics. Finally, HDR updates OS version 27 brings Dolby Vision 8.1 to macOS iOS iPadOS, and visionOS. With Dolby 8.1. You can now create content that plays on both Dolby Vision and HDR10 capable devices, and you can even add HDR10+ per frame metadata to that bitstream for the best experience across almost every HDR display in visionOS 27, HDR10, and HDR10+ are now supported for two more formats MV-HEVC that carries 3D Video and Apple Projected Media Profile, or Apmppe.

That covers all the updates I wanted to share. Here are some next steps for you to take for your app. That’s your offline downloads with Live Activities, and try out generated subtitles for content that doesn’t have authored subtitles. If your app supports AirPlay Video, adopt AV metrics, you’ll receive the same events like Startup Times stalls, pairing switch information for AirPlay session that you get for local playback. That’s it for me. Thank you. Next is Rob. Thank you.

State of HLS.js 2026

Hello everyone. My name is Rob. I maintain hls.js an open source JavaScript library for HLS playback and web browsers and smart TV platforms that support media source extensions or MSE. In this talk, I’ll cover an overview of HLS. JS 1.7, then iframe navigation. The headline feature of this release. After that, other contributions to the project. And last, the roadmap.

So now an overview of hls.js 1.7. Here’s what’s changed since the last update. HLS interstitials let you schedule content like ads into a primary program. Interstitial playback over live content has been improved to ensure proper timing of scheduled content. At join. Long standing playback and compatibility issues were closed so that maintainers can focus on new features and enhancements.

The project also took in more contributions from developers outside Apple, including first time contributors, and HLS. JS now supports iFrame navigation. So before acknowledging those other contributions and talking about the roadmap, let’s dive into iframes, an iframe or intra coded frame contains a complete picture that can be decoded on its own iframe. Navigation has been around for a long time. You can see it working in Apple HLS clients like QuickTime player shown on screen. Here. Playback is paused on big Buck Bunny mid reaction.

Now you’ve seen that before, right? Okay, so this screen capture, this is a screen capture of me scrubbing through big buck bunny iframes in QuickTime player. As I drag the playhead across the timeline, the picture updates. These iframes look close to or exactly the same quality and bitrate as regular playback. All those frames come from one place the iFrame playlist. Here’s an example of an HLS iframes only playlist. The EXT-X-I-FRAMES-ONLY tag marks it as one.

Its EXT-X-TARGETDURATION, about two seconds is the time until the next keyframe. Its EXT-X-BYTERANGE tag gives the frame’s length the next keyframe. It’s EXT-X-BYTERANGE tag gives the frames length and offset in bytes inside a segment file. The first three entries all point to the same file file sequence one dot M4S is a single six second segment from the regular video playlist, and while that segment is roughly 1.5MB, each iframe is only about 100kB, a fraction of the size.

Here’s an example of hls.js iframe player API usage. Step by step, the code on screen runs in a handler for the manifest parsed event. Once hls.js parses the multivariate playlist, it lists every supported iFrame variant found. This list can include image iframe variants, so if you only want video iframes, filter the list by video codec to load and render iframes call create iframe player. It returns null when there are no supported video iframe variants to drive navigation. when there are call attached media with a video element. This element will be used to decode and render iframes.

Then, whenever you need a frame call load media at with a program time in seconds. This example asks for a frame at 30s. The video element fires its seeked event once the frame renders. Now hls js does not provide a player UI, so how you display the attached video element is up to you.

Here’s that API in action. Matt Norton, an engineering lead at PBS digital, built this demo with an hls.js prerelease during the beta test period. It’s running in Safari, displaying a thumbnail preview over Muxes media Chrome controls. In fact, earlier this week, he published an even newer hls.js iframes demo using video JS ten. So pretty cool.

To get these frames on screen. hls.js feeds video into the browser through MSI, which expects complete fragments in the ISO base media file format or ISOBMFF. hls.js sorry. HLS, however, allows an iframes only playlist to omit the portion of an mdat that does not include an. The intro coded frame data.

This lets an HLS packager byte range address portions of full segments in iframes only playlists, even segments containing audio tracks and. MC doesn’t like that. So much so HLS pulls video samples or the video sample. Out of every segment that HLS supports every segment format, HLS supports and remixes them into complete video only MP4 fragments.

Mpeg two transport iFrame segments two. Now for debugging hls.js can also load and play X iframes only playlist directly. That way you can check the repackaging yourself. Still, I recommend the iFrame player API. What it does is it signals end of stream for every single frame appended, which flushes the rendering pipeline with the last loaded frame. You don’t just get that from seeking. It’s needed for instantaneous decoder refresh or IDR frames, or for platforms that would otherwise wait to render video until some threshold of available seconds or frames is met.

All of this means hls.js supports iframe navigation across a large back catalog of HLS content, whatever the segment format. Now there is an alternative to video iframes. I mentioned before, hls.js also supports image iframes. Some platforms can’t decode and render the same video codec in two video elements at once. If your app is running in one of these contexts, use image iframes.

iFrame content can be encoded as Jpeg images in MP4 using the MJPEG codec. The playlist excerpt on screen shows one such variant. It’s an iframe streaming tag with codecs set to MJPEG. Images let you show iframes without matching the player’s variants encoding settings. That’s usually required on smart TVs and set top boxes. It’s also required for AirPlay to third party non-Apple devices.

The hls.js Image iFrame API works much like the one for video. It uses an HTML image element instead of video. Here are the steps. To find image iframe variants, filter the iFrame variants list for entries within Image codec value. Call create image iFrame player to get a player just for these variants.

Call. Attach image with an image element. That element decodes and renders the Jpeg iframes. Then, like before, call load media at with a program time in seconds. Once the image element has decoded the image’s intrinsic width and height, hls.js fires the frag buffered event. Listen for it on the image player.

Again. hls.js does not include any player UI, so falling back from video to image iframes or how the attached element is displayed is up to you. And that wraps up iframe navigation. Next, I’ll cover other contributions to land in hls.js 1.7. First from hls.js team at Apple. Then from the community.

The team at Apple contributed three things I want to call out. First. An opt in feature for looped video. It ejects the lower quality video selected at startup, so you have a high quality loop playing over and over. Second, an opt in for live streams that stops playlist refresh requests and raises an error after a number of stale responses where the playlist hasn’t changed. So if you have a live stream that sort of stopped or ended, HLS, JS won’t keep pulling it.

And third, several protected playback fixes and improvements. These include key status error handling, Widevine multi key handling. They also include some community fixes for encrypted partial segments with low latency HLS. Speaking of community, more than 80 people contributed across hundreds of issues and pull requests. Many of them are from outside Apple. Together, we did incredible work and I can’t overstate how much that matters.

So here are just some of those contributions I’m especially grateful for. Especially grateful for the iFrame remixing I mentioned earlier was a collaboration deferred audio switching for changing audio alternates during live playback without increasing playback latency. Common Media Client Data version two or Cmcd v2 for analytics contributed by the folks at SRV to encrypted low latency. Partial segment playback and fixes.

And performance and build improvements covering playlist parsing, module build output and continuous integration or CI. I could stop here, but there’s more work ahead. So to close, here’s the roadmap. These are some highlights from HLS. JS 1.8 roadmap schedule date ranges will unlock new advanced ways of programing interstitials, which you’ll hear about today. A client side interstitial API will allow the same even more dynamically on the client.

Preloading date ranges for interstitials because no one likes a thundering herd. And preload hints for low latency HLS and keys. And finally, clear to encrypted transitions across discontinuity boundaries, specifically for legacy platforms that require additional signaling in the byte stream or a media source reset as a last resort.

The maintainers way the roadmap against open issues and pull requests, so file some. Here are a few items that have not been formalized there yet. One is soft deprecating leftover parts of the API and the HLS parser that no longer serve a clear purpose that would improve performance. Another is a mid-size build. That means you could embed a version of the library that, say, drops Mpeg two transport stream support, all to improve your application’s page load time or playback start time.

I’d love to hear what you want us to work on next, including the HLS features and topics covered today. Here are your next steps. Upgrade to hls.js 1.7. Try the new iFrame API or build on top of one of Matt’s open demos. If you publish HLS playlists without iframes, consider adding them. Playback on HLS clients will benefit and you can now use them with hls.js.

The 1.8 roadmap focuses on interstitials, low latency, HLS, and content protection. But many of those other features that we talked about before. So to join in file issues on GitHub in hls.js project under the video dev organization and find the maintainers on the video-dev.org Slack in the hls.js channel. Discord two, I think. Anyway, thanks everyone. Next is Sumayya. Good morning everyone.

Reduce peak FairPlay key server load

My name is Sumayya and I’m an engineer on the streaming media team here at Apple. I’m excited to be here today and share some strategies for reducing peak load on your FairPlay key servers, so you can scale them more easily. I will start with a quick review of the FairPlay key exchange process. Then I’ll dig in to the main problem covered in this presentation the Thundering Herd key service experience during live key rotation.

From there, I’ll walk you through four mitigation strategies that will help reduce and smooth out key server load. Then I will cover APIs that are necessary for one of the mitigation strategies, namely advisory keys. Let’s start with the FairPlay key exchange process. It’s important to first understand how a content key gets to a device. There are three actors here on the right. FairPlay runs on device in the middle. Your app and on the left, your FairPlay key server.

When your app needs a key for playback, it asks FairPlay for the key request data, also known as the Server Playback context, or SPC. FairPlay creates one and hands it back so your app can send it to your key server. and returns the content key response containing the key. the content key response containing the key.

Your app forwards that response to FairPlay for processing, and the key becomes ready for playback. With that review in mind, let me talk about a concern many of you have raised. Specifically, what happens to your server during live key rotation when a large number of viewers are tuned in at the same time? This is a thundering herd problem. Imagine for clients watching the same live stream, they join a slightly different times, so their very first key requests are naturally spread out, as shown in the small cluster of hits at the start.

But over time they align at the live edge when the next key rotation shows up in the playlist, all four clients request the same key at the same moment, and that’s the tall spike in key server hits under key two, and it doesn’t go away. Every future rotation produces the same spike because everyone’s aligned at scale. Key rotation turns millions of independent clients into one synchronized burst, resulting in a thundering herd. The key server falls behind keys arrive late, and playback stalls for everyone.

Let me now talk about how this problem can be solved through four different strategies. The first strategy is the preload hint key. This is not a new idea. Roger covered preload hints for keys at the 2025 summit, so this will be a refresher for many of you. A preload hint tells the player about an upcoming key rotation. That’s the preload hint tag on the right.

It points at the upcoming key and gives a date of first use, which is a moment that key actually goes into effect. The player then picks a random moment between the hint timestamp and the date of first use to go fetch the key. So instead of everyone requesting at the same instant, each client spreads its request across that window, reducing the thundering herd.

Here is a strategy in action. The playlist contains the new preload hint tag. This is a line on your left. The line on your right is when key one is actually needed, indicated by the EXT-X-KEY tag in the playlist. Every client now picks its own moment between these two times to request the key, and you’ll notice they land at different times.

So instead of one tall spike, there are four smaller requests spread across the window and the peak is gone. And this keeps working. Here’s the next rotation. It’s the same pattern where each client requests at its own random time in the window, and the load stays flat and spread out.

Preload, preload, hint keys, distribute requests over time. But what if you also want to cut down the total number of requests each client makes? This leads me to talk about the next strategy. Advisory keys. Advisory keys reduce the. The overall number of requests sent out to the server for each client.

In this strategy, your key server returns more keys than the client actually asked for FairPlay caches, those extra advice keys on the device so they’re ready for future rotations. Servers also benefit because keys are batched into a single response. You amortize the cryptographic cost across multiple keys in one operation, saving compute and this is a benefit for any advisory key strategy.

Now back to the four clients. They join and request key one because they joined at different times. These requests are naturally spread out and there is no thundering herd. The first synchronized rotation arrives and all four clients request key two at the same time. And there’s a spike again.

Here’s where advisory keys change things. When the server responds with key two, it also pushes key three along with it in the same key response. FairPlay process is key two and caches key three. when key three shows up in the playlist. Every client already has it specifically in their FairPlay cache.

So nobody goes back to the server for key three. That rotation is completely flattened. Now you might ask, okay, what about the thundering herd on the next non advisory key. Good question. And this is a great segue into the next strategy. Advisory keys staggered to review without staggering. You might notice a thundering herd on every non advisory key request as shown in the box on highlighting the Thundering Herd on key two.

But with this strategy, instead of pushing the same advisory key to everyone, the server staggers them. When clients one and two request key one. The server also sends them key two and key four. But when clients three and four request key one, the server sends back key three as advisory instead. That splits the clients into two groups that will need the server at different times. Clients one and two have key two and key four cached, while clients three and four have key three cached.

When key two arrives, clients one and two already have it, so there is no new request. Only clients three and four go to the server. There’s still a key server hit, but notice it’s half the height of the spike on key two from earlier. Key three is a mirror image. Now clients three and four already have this key and there is no new request. Only clients one and two go to the server.

You keep this pattern going by mapping each future advisory key onto a non advisory one, and you can choose how to stagger the keys. The more you stagger the flatter your server load will be. Now here are a few guidelines for using advisory keys. First, advisory keys are managed entirely by your FairPlay key server and by FairPlay on device.

This is not the client requesting multiple keys. The client only finds out that the key was fulfilled by an advisory key after it’s requested. Second, your server should push advisory keys at the same security level as the key they ride along with. Also, advisory keys are supported on iOS, iPadOS, and tvOS 27 with your key server on the FairPlay streaming SDK version 27, which releases today.

Finally, as I recommended earlier, stagger advisory keys to avoid creating new Thundering Herd on future key rotations. So that’s two tools preloading keys and advisory keys. The natural question is what happens if you use both together? That’s the combined approach. Combining them gives you the best of both. You spread key requests over time, and you also lower the total number of requests, which further reduces the chances of a thundering herd.

Here’s how it looks. Start with preload hints. A hint appears for key two, and each client requests that key at its own random time in the window. Spreading out the server load. Now layer advisory keys on top. When the server responds with key two, it also pushes additional advisory keys. I can stagger the advisory key for each client.

For clients one and two, the server pushes key three as advisory and for clients three and four, it’s key four as before. FairPlay on device caches these advisory keys. When key three comes around, clients that got this key as advisory already have it as shown on the far right. Clients three and four still request key three from the server.

Similarly, when key four is needed, only clients one and two request it. The playlist even hints key four using preload hints so that these requests are spread out. Of course, for clients three and four there is a cache hit and there is no server round trip. With this strategy, the requests that were made are spread out and the ones that were needed are eliminated entirely.

To use advisory keys, clients need to implement a few additional APIs in their key loading logic. First, opt in to the feature on your AV content key session by setting Support Advisory Keys to true in your key request delegate callback. Use the optional variant of the Key Request Data method. Make optional streaming content key request data instead of the standard one.

The optional variant can return without request data, which indicates the request was likely fulfilled with an advisory key. Do an explicit check by inspecting the can be fulfilled with advisory key property on the AV content key request. If it’s true, the key is already cached by FairPlay and you can simply return early. If there is no cache advisory key. You fall through to the standard key loading path. Send the request data to the key server. Get the response back and then process it.

These strategies will reduce the load on your FairPlay key servers, which in turn allow you to save costs when scaling your server infrastructure. As for next steps to use preload keys, author your playlist to use to include the preload hint tag for content. Keys to use advisory keys. Adoption is on two fronts. Your FairPlay key server must adopt the SDK version 27. As a reminder, this release is available starting today.

Your app implementation must be on iOS or tvOS 27 to utilize the advisory key APIs in a V Content Key session. Beyond these steps, we would love to hear more about the challenges you face in the DRM space. The better the real bottlenecks are understood, the better Apple can help shape what comes next. So please share your feedback and let’s have a conversation. As a reminder, this is the QR code for your questions and feedback. With that said, thank you so much. And over to Sergey. Thank you. So much.

It’s great. All right. And next we’ll have a short break and sessions will resume at 1015. And don’t forget to make your one on one appointments. See you in a bit. All right. Welcome back. Just a reminder, here’s a QR code for questions. And Eryk is next to present HLS tool updates. Eryk. All right. Welcome back. Just oh that’s right. He didn’t advance the slide.

Media Stream Validator 2.0 and HLS Tools updates

There we go. Okay. Hello. My name is Eryk. I’m an engineer on the HLS tools team. Our topic today is mediastreamvalidator 2.0 and HLS tools update. I’ll walk you through mediastreamvalidator 2.0 and what you can do with it. Plus a few other changes worth knowing about. Here’s what I’ll cover. First, a quick introduction to HLS tools. then mediastreamvalidator 2.0, what it checks and how you control it. After that, changes to packaging and platform support, then documentation and examples.

I’ll start with an introduction. This is a quick review for anyone who hasn’t used the HLS tools before, what the tools are, and how validation data moves through them. HLS tools are command line tools for macOS and Linux. They author that is, create HTTP live streaming content and they validate content against the specifications. The slide lists the main tools mediastreamvalidator, HLS report, the Segmenters, and the supporting tools for the Segmenters. Now I won’t be discussing the Segmenters in detail. Today I’ll be focused on mediastreamvalidator, HLS report and the validation data flow.

Here’s how the validation data flows. Two stages and the second one is optional. mediastreamvalidator or Msrv, takes a playlist URL. It outputs a validation data file plus some command line output. Optionally, HLS report takes that validation data file, does some additional validation, and produces an HTML report. A little more background.

mediastreamvalidator checked only the HLS application. HLS specification rules. It wrote version one Json files for simple playlists and version two Json. If a stream used interstitials or content steering. HLS report checked the HLS authoring specification rules and wrote an HTML report. But neither tool had any way to customize rules.

mediastreamvalidator two merges all this. It checks HLS specification rules, authoring specification rules, and additional rules beyond those. Now, not every rule has moved over from HLS report yet. That work is ongoing. This merge also introduces a single, consistent, unified Json format. This is consistent across every kind of validation. It’s called version three. That’s the background. Now let’s dive into mediastreamvalidator 2.0 itself. What it does differently and the control it gives you.

mediastreamvalidator two is a more flexible, customizable way to validate HLS streams. It supports workflows the earlier version couldn’t. It can also check rules that live outside the HLS specification and authoring guidelines. Now, version 2.0 is a beta and adoption is optional. mediastreamvalidator two gives you four layers of control over what gets checked and what gets reported. You control which parts of the stream get examined, you control which rules get checked, you control which errors get reported, and you control how the results reach you. I’ll take each one in turn.

You’ve always had some control over which parts of the stream get examined. Version two adds more of this. You can tell MSV to skip interstitials. You can tell to skip content steering manifests. You can skip segments. That’s another name for the existing parse playlist. Playlist only option. It skips both segments and in low latency HLS streams, partial segments, and you can skip only partial segments if you prefer.

You can also bound how much work gets done. You can cap how long the validation runs, and you can cap the duration of the media playlist. Content that gets checked based on the media type. Now these limits apply to the duration of the media examined, not how long MSV runs.

Version two gives you much more control over which checks runs. Now individual checks rules are grouped into rule sets. For example, every check about segment duration belongs to one rule. Set the segment duration rule set. Now, MSV defines these groupings. You can’t create your own grouping, and you can’t move rules from one grouping to another.

MSV ships with a number of rule sets, and this slide lists them alongside their identifiers. Each rule set works independently of the others, so checking bit rates. Validating codec strings, and so on. Every rule has a numeric identifier. You use that number to turn it on, turn it off or configure it.

Now each rule set is controlled on its own. Most are on by default, as shown on the slide, and you can turn any of them on or off. Some go further. They have configuration to configure a rule set. MSV needs the ID. The ID of the segment duration rule set is 35024 as shown on the slide.

Now, once you name that rule, set the command line. There we go. Once you name that rule, set the command on the command line. Its own options become available. These options only apply inside that rule set. Now this particular rule set ships with defaults. You can override them. But of course you don’t have to. Other rule sets do nothing at all until you configure them.

Now error reporting. When a rule fails, the failure includes an error code MSV2 uses a six digit positive number for each error. These error codes to an extent describe themselves. The slide shows the structure. There’s one digit for severity, two for category, and three for unique index. Now every error MSV produces has this form.

Severity is a linear scale shown here. Running from highest to lowest. Authoring errors are kept clearly separate from HLS specification errors. I’ve highlighted the authoring severity levels that severity level carries through to HLS report, so reports can group errors by severity. Category, on the other hand, divides up the error code space and tells you what kind of error you’re looking at. The slide shows some of the categories in order advisories, then syntax errors, then higher level errors. This is a partial list. The full set is in the in the documentation.

Now you may want only some of the errors in a rule set reported. You can ignore a single error number or a whole range of them. For example, you can drop everything advisory or keep only the must fix errors and above. You can also add specific errors or range of errors back in the list of ignored errors travels in the validation Json file.

So HLS report has access to that as well. And HLS report uses a separate non-overlapping range of error numbers. This means you can use MSV to tell HLS report to skip reporting certain errors, and that all the reports print each error number, so you don’t need to look it up.

Now there are three ways that you receive results. First, single file output in the original format. This matches what you got from earlier versions and HLS report can read it. Second single file output in the version three Json format. Now this is the default style. It’s more cleanly structured and it’s well documented. But HLS report can’t read it. A separate tool. MSV summary works with this format. Third continuous output that’s in Json format. A sequence of Json objects one per line. It opens up workflows the other formats can’t support.

In continuous mode, the output is a sequence of Json dictionaries. Json line format. Some dictionaries describe structure. Some Report validation errors. The slide shows one of the structure messages in a pretty printed form. Each structural object, a media playlist or a segment, for example, carries a unique hierarchical identifier. That identifier stays the same across runs. The simple, regular structure of the messages allows machine processing of this output. Now, at the moment, no tools can consume the continuous output, but several samples are installed that show what’s possible. And every output format is documented.

All of these capabilities are set through command line options, and there are quite a few of them on screen. I’m showing a command line that configures continuous output. Half a dozen options wrapped across several lines. You don’t need to save long command lines like this by hand. You can add the export settings option to any command line and M.s.v. Writes the whole thing to a settings Json file.

Any command line option can live in one of these files. Once you have a settings Json file, you can pass it into another command line with the Include settings option, which can be shortened to dash capital I, and these files allow Json five a relaxed form of Json, which allows comments like the ones seen on screen here. And in addition, one settings file can pull in other settings files.

All right, that covered mediastreamvalidator two what it checks how you control it, how results come back. Next we’re going to have some shorter topics. Packaging and platform support. Historically, HLS tools has been distributed as a single package. That’s changing starting today with version 1.27, the tools split into two packages shown side by side. Here the validation tools are MSV and HLS report. The authoring tools are the Segmenters and their supporting tools.

Now this split applies whether or not you use MSV 2.0, the version of MSV 2.0 of MSV supplied in the validation tools. 1.27 is not the 2.0 version MSV 2.0 ships in the Validation Tools 2.0 package. That package replaces Validation Tools 1.27 but coexists with the authoring tools. Now the two validation releases are mutually exclusive. By default, installing one removes the other. If you need both at once, you can, of course relocate one installation by hand.

Now platform support. The latest macOS is supported. As always, Red Hat Enterprise Linux has been available for several years. Two more Linux distributions joined this year, ubuntu 2404 for LTS long term support and Debian 13.2. All of the packages are available on every one of these platforms. A few other changes worth knowing about. Documentation. Samples. The examples page.

All right. MSV 2.0 ships with a set of markdown documentation pages. These document everything rule sets, output formats, options, error codes, and continuous output messages. Any markdown viewer will open them. So will plain text editor. And because so many people work with AI agents now, there’s a markdown file written specifically for the agents. It explains to the agent what MSV does, and it points it to the user guide to obtain more information.

We’ve made the HLS authoring specification now a single document with its appendices folded in. I mentioned that there are samples showing what the continuous output makes possible. The simple web pages. We provide a small WebSocket script that relays Msvs output to the page. I want to emphasize that these are just samples and not finished tools. They’re included in the installation, and the workshop later today goes into more detail.

The examples page has had a couple of additions. One using the AV one video codec and one using interstitials. Now, some of the examples dating from the earliest days of HLS have been removed. They no longer really reflect how streams should be built. All right, that’s mediastreamvalidator two zero packaging split platform additions and updates to the documentation and examples. The downloads are available today on the HLS tools page. Please give the beta a try and come to the workshop this afternoon to experience it. Hands on. Thanks very much for your attention. And now over to Ted to tell you how they use HLS to deliver podcasts. Thank you Eryk.

Deliver podcasts with HTTP Live Streaming

Hello, I’m Ted Hosmann and I’m a product manager on Apple Podcasts. Apple is the home of podcasting. And at Apple, we believe podcasts deserves a dedicated global platform that is focused on providing the best experiences for audiences and the tools to help podcasters grow. One of the tools that I’m really excited about sharing with you today is video podcasts. Earlier this year, Apple Podcasts introduced a new video experience. We partnered with the industry to support episode delivery with HLS. There are thousands of shows that are live with video in Apple podcasts and more that are joining every day.

Podcasters are finding success after launching support for video podcasts. Top shows are seeing that their audience grew on average by more than 20%. More people are discovering these shows, and this is new audience for podcasters. Shows increased their net new followers by more than 130%. Followers are the people that are opting in to be notified of a new episode when it’s released, and download it and download it when it’s released. This is a podcasters core audience and overall podcasters. Podcasters are seeing an increase in plays by more than 10%. Plays are engagement, and this means video episodes are drawing people back in to keep watching.

And we’re continuing to add new platforms for video podcast playback. In fact, it was just last month that Apple podcast app on Apple TV was updated to include video podcasts. And it looks incredible. Now people can start playing an episode on their commute with iPhone and resume at home on their Apple TV.

I invite you to join us in building support for video podcasts using HLS. The Apple Podcasters Guide to HLS in a reference Multivariant playlist is now available on our website. In this presentation, I want to talk to you about how to author your video episodes so you can reach new audiences. Next, I’ll cover how to use interstitials to place ads in your podcasts. And finally, I’ll show you how to make sure that your HLS streams work in Apple Podcasts.

Let’s start with how you author your video episodes for Apple Podcasts. You may already have a show with a fan base that listens, and adding video shouldn’t break the routines that those fans have already established. When you author your media files, include an audio only track and to do this, create an audio rendition group in the multivariate playlist. Each of your video variants will reference this audio group.

Next, include an audio only variant. Typically, these are encoded as M4A using AAC, which works great on iOS devices. This is the media that will be automatically downloaded for people that are following your show. And when a listener presses play, the audio on their device is played. There’s no change in the experience for that established fan base. If they open the player, the video is streamed. The player keeps the audio and video in sync.

Next, audio advertising and podcasts is mature and the dynamic insertion of ads is well understood. Using interstitials and HLS is how you dynamically sell and insert video ads. It’s important that the ads are served dynamically sourced by third party services, and that the experience is not disruptive to the audience. The ads are part of the timeline, but you won’t see them included. We also don’t allow for skip restrictions to be set on the ads. The podcast app still allows the viewer to skip forward 30s in back 15 seconds.

The media playlist includes the interstitials, pre-roll, Mid-roll, and Post-roll. Ads are supported, but there are some attributes that must be provided in order to maintain the desired user experience. asset. URI or asset list are supported in Apple podcasts. This gives you the flexibility of how you work with your ad networks. The interstitial authoring requires that you set X timeline occupies to range and X timeline style to primary, so that the player includes the ads in the timeline but doesn’t display the ad markers.

And use Q equals post. The q equals post attribute to play ads after an episode is completed. Using Q means that you don’t have to do the math to precisely pinpoint the end of an episode and insert the ads. I mentioned using Asset List because it offers networks the ability to late bind the ad decisions closer to when the ad might be impressed. But there are other advantages to.

Asset list is a simple Json response. You provide a URI for the ad media and a duration for that ad. But think for a moment about the last time you listened to a podcast and you heard that familiar ad intro jingle, and almost immediately you heard an ad outro jingle, and the episode resumed. That’s because there was an ad break, but there were no ads that were inserted. Those bumpers are burned into the main media. If you use interstitials, you don’t have to disrupt the flow of the show.

Asset List accepts multiple assets to be played, and this is where you want to add the intro and outro bumpers along with your ad. You can even stack multiple ads here, and the player handles playback in sequence. And when there aren’t any ads to be filled, the player will skip right over the interstitial. Continue playing the episode.

Now you have your video, audio, and your ads ready, and the final step is to validate that everything is working as expected. The Apple Podcast team is making a new settings file available today that you can include with Mediastream validator 2.0. There are many rules in the settings file, and I’d like to focus on a few of them that are really important.

Apple podcasts is supporting delivery of video on demand. The media is complete. It’s packaged. It’s ready for distribution. The Apple Podcast app does not support live streaming media URLs. Video podcast episodes require an audio track and video tracks. Distributing video only media does not allow for the app to download the audio in the background and stream the video on demand. Video only is prohibited.

In the Interstitials have strict requirements. As I mentioned before, attributes like X timeline occupies range and X timeline style is primary are the only values that are permitted. This keeps the ads as part of the timeline without any indication of where they’ll play. An X restrict for interstitials is forbidden. Now you’ve seen these ads before. They limit if you can skip over them, and sometimes they even have a countdown timer until you can skip. That’s not supported in Apple Podcasts.

These validations ensure that podcast episodes, no matter where they’re distributed from, will play the same on Apple Podcasts across all devices. The podcast team has already integrated. HLS support with more than 20 hosting platforms. We published documentation and support articles on Apple Podcasts for creators, and you can visit podcasts.apple.com to learn more.

The Apple Podcast team is ready for you to get started developing tools for podcasters. Start by implementing the Apple Podcast HLS specification. You can reach out to us through our support site and share your progress. And join us today in the mediastreamvalidator workshop this afternoon and learn how to use the validation tools. Our team is available for one on one meetings if you have specific questions and don’t forget to sign up. Thank you so much. Next on the program is John with a proposal to add playlist archives to the HLS specification. Thanks, Ted.

Proposal: Optimize live HLS with Playlist Archives

Hi, I’m John, and today I’d like to share a proposal for an addition to HLS specification. It’s called Playlist Archives. I’ll start with the challenges that devices with limited memory and processing power face on long running live streams. Next, I’ll show a proposal of how playlist archives can solve these problems. And finally, I’ll discuss the possibility of extending this feature to VOD playlists. The challenges to consider and ask a few questions to you for its feasibility. Let’s start with the problems low powered devices run into.

Consider this scenario. A live stream has been running for 12 hours with five second media segments. On the right is a shortened version of its playlist. It starts with a standard HLS header tags, followed by five second segments from 8 a.m. to 8 p.m. That single playlist now contains 8640 segments along the way. It accumulates several encryption key changes, metadata tags, and discontinuity markers.

A viewer joins the stream on their top of the line. Smart TV from 2015. The HLS player fetches this massive playlist and buffers the raw text. Then it parses that text into a structured object model before discarding the payload. And it repeats all of that for the audio playlist.

This playlist is now more than 17,000 lines long, often with long parameterized segment URIs. Your team’s startup target is under five seconds. But parsing this one file takes 15 or worse. The TV’s app sandbox limits kick in and the app shuts down with an out of memory error.

The most common workaround is to aggressively limit the length of the sliding window, the number of segments kept in the playlist. For example, shrinking the playlist from 12 hours to 200 seconds cuts it from thousands of segments to a few dozen. The trade off is immediate. Viewers can no longer seek back to anything outside the window, depending upon the content. That’s a real loss for them.

There’s a business cost to a shorter window, can conflict with contractual obligations for the content, and can rule your app out of streaming high profile events. Another option is HLS Playlist Delta updates, which send only the changes to the playlist that helps with later playlist reloads, but it gives no relief at start up or when switching renditions for adaptive bitrate.

Variable substitution replaces long repeated text with a short placeholder, which shrinks the playlist payload, but it doesn’t reduce the number of parsed segment objects or the memory they take up. Existing workarounds either introduce unwanted trade offs or address only symptoms. Disney faced these challenges in their apps and encouraged us to solve it in the HLS specification. Since then, we’ve been working with Cooper Pope at Disney to define this new proposal. Playlist archives.

First, I’ll walk through the tag itself. The archive tag points to a playlist archive. A client can load it to extend the presentation with more media behind the live edge. The tag has four attributes, starting with first MSN. That’s the media sequence number of the first available segment in the archive. Duration is the total duration of the archives segments from first MSN to the end of the archive. Pick an archive duration that your most constrained clients can work with. Next, a URI that tells a client where to find the archive.

Finally, there’s an optional start program date. It gives the program date and time of the archive’s first segment. That helps the client find the right archive with. When a viewer seeks to. A specific time. Archive tags must appear at the top of the playlist and. Just like media segments, order matters. Choose the number of archives to fit your playback needs.

A playlist archive replaces a set of media segments with a single URL. The client loads that URL only when someone seeks into that part of the stream. Once it’s loaded, the client can discard the archive’s data and rebuild it later so memory stays bounded. The example on the right shows the 12 hour stream again. Now it’s a one hour sliding window playlist with 11 archive tags at the top, each covering one hour. The player keeps the full presentation with far fewer segments and a much smaller playlist.

Playlist archives are backward compatible clients that haven’t adopted them. Ignore the archives and treat the playlist exactly as they do today. Clients that support archives use them to work out the total sliding window duration that lets viewers seek back further than they could before. Combined with Playlist Delta updates, this proposal shrinks the payload at startup and on every later reload. Now I’ll cover how an archive changes over time. Once all of its segments are available, an archive can be added to the playlist.

At first, all or most of the archive segments overlap with the segments already in the playlist. The duration of archive is the number of archive segments still in the presentation, and not duplicated at the live edge of the playlist. Then as segments roll out of the playlist, they stay in the archive and the duration grows.

Once the stream reaches its total sliding window, segments start rolling out of the first archive. Its first end goes up and its duration goes down. Next, the archive playlist itself on the right is an example. It’s made up of six five second media segments for 30s in total.

Only media segment tags and a subset of playlist tags may be present in an archive playlist. All metadata must remain only in the playlist, including date ranges. This ensures all information remains available up front to the client without having to download an archive. And any tags that apply to the archive’s first segment must come before it. That includes media sequence, discontinuity, sequence key, and map tags.

Once published, an archive can change in only one way. Segments can be removed from the front in presentation order. When that happens, tags like media sequence, discontinuity sequence, and program datetime update to match the first segment that’s left. This works the same way as live playlists. Alternatively, the archive playlist may remain static, and the attributes of the archive tag can be adjusted to reflect the changing dynamics, such as segments leaving the trailing edge of the live stream.

Now I’ll walk through the lifecycle at the live edge with a few diagrams, then show the same steps in a real playlist. In this diagram, time runs from left to right, and the playlist is a bar going from the left. As the stream starts, the playlist grows until it reaches its sliding window duration. At this point, you can create the first archive. It holds exactly the same segments as the playlist, so the two overlap completely. In the diagram archive, one sits directly above the playlist bar.

As new segments join the playlist, old ones roll off the trailing edge to keep the window fixed, but those segments still exist on archive one, so now the archive and playlist only partly overlap. The playlist bar has shifted, right? Eventually, archive one and the playlist don’t overlap, and that doubles the total sliding window.

Now a second archive can be created fully overlapping the playlist. Again, new segments join the playlist and old ones roll off, so archive two now only partly overlaps with the playlist. Eventually, archive two and the playlist don’t overlap at all, and a third archive can be created. This repeats until the stream reaches its total sliding window duration.

Now I’ll show this in an actual HLS playlist. To keep it simple, I’ll swap the 12 hour stream for one that started 60s ago. The window is 30s and each archive is 30s two. At the top is one archive tag, followed by the playlists six seconds six segments 60s in total with no overlap. Let’s walk through how this playlist changes as new segments arrive.

As the next segment arrives. A second archive tag appears beneath the first. It overlaps the playlist by all but one segment, so its duration is five seconds. You could also advertise it one segment earlier, with a full overlap and a duration of zero seconds. Either approach works. Another segment arrives and one rolls off. The new archive’s duration grows to 10s and to 15 seconds To 20s. To 25 seconds until the archive in the playlist no longer overlap. And the archive advertises its full 32nd duration.

Now back to the diagram to see what happens as segments roll off the trailing edge of the oldest archive. As more segments arrive, the oldest segments in archive one roll out of the total sliding window. In the diagram, the left edge of archive one shrinks so its duration goes down. Archive three only partly overlaps the playlist. Once all the segments in archive one have rolled off, the entire archive can be removed from the playlist. Archive three no longer overlaps the playlist in archive four is added, fully overlapping the playlist.

Now this is the HLS plays. This is the HLS playlist. Picking up from our last example. The playlist sliding window is 30s and there are two 32nd archives for 90s in total. The next segment arrives and a third archive tag appears. Meanwhile, the first archives first message goes from 1 to 2 and its duration drops to 25 seconds.

Another new segment arrives. First, MSM goes up by 1 to 3 and duration drops by another five seconds to 20. Then first MSM goes up to four. Duration drops to 15 seconds. First MSM goes to five, duration drops to 10s. First MSM goes up again and duration drops to five seconds.

Finally, once all the segments have rolled out of the sliding window, the first archive is removed from the playlist. Now that I’ve described the proposal for playlist archives and how they work for live streams, here are some considerations and extensions and how they may work for VOD streams.

So far, archive tags have only appeared at the top of a playlist. We could also let archives sit between media segments with segments before and after them. That would extend this proposal to VOD and event playlists, not just live ones. VOD playlists can get equally as large as live streams and have the same challenges. However, to reduce startup times, a client should not have to load a playlist and an archive in order for playback to begin, no matter the initial start position. While the benefit could be great, the trade off is complexity.

First, it isn’t backward compatible. It would need a new EXT-X-VERSION. In practice, that means serving different playlists to clients that support it and clients that don’t. Second, it needs more rules in signaling. For example, archives would need a new attribute called discontinuity count. It lets clients compute discontinuity sequence numbers across an archive. And because archives could appear anywhere, packagers and clients would have to handle every possible placement and how each one affects playback.

So some questions for you. Is the extra complexity worth it? Would you use this? Are there other problems with large playlists that this could help solve? Would you change anything in this proposal? The HLS team would love your feedback. Please read the proposal posted on the HLS interest mailing list sent out on Friday, and reply with your thoughts. The subject line was Early Proposal Playlist Archives for HLS. If you’re not on that list yet, anyone here can help you join to reach out just to Apple and not a public list. You can also write to the HTTP live streaming review list instead.

Or open an issue or join in on an existing discussion in the GitHub repo. Thank you. And back to Sergey. Thank you so much, John. That’s great. And you have another break. We’ll resume presentations in about ten minutes or 1110 Pacific Daylight Time. See you guys. Welcome back. Next is Naiwei with a talk on handling regulatory requirements. Take it away. Thank you.

Regulatory requirements: loudness control and sign language availability

Hello, everyone. My name is Naiwei. In this session, I will talk through some regulatory requirements emerging in several jurisdictions that affect content providers. This session is the start of a conversation, not a set of answers. we are genuinely. Want to hear your perspectives on these topics I will cover in this session. So please treat everything here as a draft and look for the holes in it at the end. I will share several ways for you to reach us.

Here’s the agenda for this talk. I’ll work through some examples of recent legislative activity. Then I will cover meeting loudness control requirements regarding these regulations and also the requirements for providing sign languages for each one. I will share where we think HLS might help, and I will direct your attention to some areas of considerations regarding these topics.

This talk touches on the law. So it starts with some disclaimers. First, I’m not a lawyer. I’m an engineer. I’m not here to offer legal advice. Second, this session doesn’t offer Apple’s legal interpretation of any regulation. If you are seeking legal advice, consult a lawyer. Also, this session doesn’t disclose unannounced features. On the contrary, we would like to hear your feedback to shape what we do next. Now the disclaimers are out of my way. I will talk about recent legislation activity.

The first is California Senate Bill 576, which took effect in July 2026. Quoting the California Assembly side, the commercial. Advertisement. Loudness Mitigation Act. The Calm act is a United States federal law. It was enacted before streaming platforms become a dominant force in the media landscape. Senate Bill 576 closes the loophole that exempts streaming services from compliance with the calm act, end quote. So this bill is about loudness in advertisements. I will get to the details shortly.

The second is the United Kingdom Media Act of 2024. Quoting new media law.biz, linear TV now operates in a market dominated by streaming services. The UK Media Act 2024 responds to this shift by updating regulations to ensure the UK media Framework It reflects modernized viewing habits. End quote. UK law already covered broadcast content. The 2024 act extends that regulation to streaming. I’ll come back to what it means for sign languages later on.

Here’s a quote from the United Nations. The year 2026 marks the 20th anniversary of the adoption of the United Nations Convention on the Rights of Persons with disabilities. The central challenge has shifted from norm setting to implementation. End quote. If you don’t know article 30 of the UN, cRPD advocates to make content available to more people. We are seeing more UN signatories following through with regulatory changes.

So here is my layman’s observations of these regulatory activities. I’m merely reading the trend and is not Apple’s legal interpretation. Originally legal frameworks were built to govern broadcast television. Now they are being reformulated to cover streaming tool. So it is possible other jurisdictions where you provide content may bring similar regulations. If you are already seeing that somewhere we haven’t mentioned, we would really like to hear about it. That’s a quick look of the current legislative landscape. Now let’s start with California Senate Bill 576 and loudness Control.

The California bill mirrors the Federal Commerce Act, Which states that commercial ads cannot be louder than the main program content. The bill makes the content provider responsible for compliance, but responsibility doesn’t have to mean acting alone. A streaming player implementation can help. Here, I’m going to present three different HLS proposals to help make sure commercials are not louder than the main program.

Option one is to provide an API so apps can set the loudness target for any given time. Content apps can set the desired target level by the content type. However, if different apps don’t agree on the same target level for the same content type, it can lead to inconsistent experience from one app to another. Our instinct at Apple is that users want consistency across similar apps.

So we considered a second option utilize built in normalization feature in modern audio codecs and normalize everything to a fixed target level. This codec feature is available to extended high efficiency AAC or AAC, the Dolby Codecs and Apple Positional Audio codec, or APAC normalizing to a fixed target level can maintain cross app consistency, but it sits awkwardly with how people experience different content today. Music, for example, is typically mastered louder than film and television soundtracks. We are wary of overriding established industry practice of mastering target level.

So we have a third option which is automatic loudness control based on content type for content marked as music. The target target level could match established mastering practice for music. Movies and TV shows would get their own target. Switching apps of the same content type would provide a consistent experience, but to achieve this, it requires content type signaling. This last option is where our thinking is heading at the moment at Apple. Let us know what you think.

For automatic loudness control to work, there are some areas of considerations I would like to raise your awareness. First, your catalog should be ready with loudness measurements. Without it, content cannot be normalized to any target. The HLS authoring guideline already recommends ways to convey loudness measurements. There’s the loudness user data box for fragmented MP4. Some codecs carry the measurement in the encoded bitstream, including xHE-AAC, and Dolby codecs.

APAC includes it in the decoder configuration information, so it is important for you to understand how much of your catalog already carries loudness measurement today, and it is also useful for our team to hear from you. In order for loudness control to work, how much content are ready today and how much requires re-encoding?

The second required information is an indication of the content type. Apple has proposed in June 2026 a user data box that carries content type in track user data. It sits alongside the loudness box. But we also acknowledge that it would be more convenient to convey content type in his session data. Because updating multivariate playlists is easier and faster than updating many fragmented MP4 initialization segments. If neither of these options works for you, there’s also API for setting content type on player assets.

But if you are in the middle of updating your content library for automatic loudness control and not all your content provide both loudness measurement and content type, then automatic language control would not be able to work consistently across your catalog. So here is the default behavior that I think makes sense.

Only apply automatic loudness control. If both the loudness measurement and the content type indication are provided, and there should be an optional player setting for you to opt out of automatic loudness control. So you can explicitly opt in. Once your content library is fully ready, let us know if this default behavior and opt out setting fits your needs.

There’s also the consideration of web deployment. If content type travels in session data, then an extension to the Media Source Extensions API or MCE will be required for the client to specify the content type to the underlying loudness control. If you are a browser vendor or work with them, please reach out to our HR team to discuss further. That concludes the topic of loudness control. Now let’s turn to sign language support.

Here’s a closer look at the UK Media Act 2024. The act works in two stages. First, specific content providers are designated tier one providers against criteria set by Ofcom, the UK regulator. Second, once those designations are made, a target is set for how much tier one content must carry sign language. The expectation is a quota of 5% of all content from tier one providers.

So let me give you three ideas for delivering sign languages in his. Though they are not mutually exclusive and we would like to know if you have other suggestions. As a baseline, you can deliver sign languages in SRS today by burning them into video renditions. This works on every existing service client, but at the cost of back end storage and encoding processing, that cost multiplies with each additional sign language encoding variant or viewing angle.

One way to reduce that cost is overlays. Rather than burning sign language into the main program, encode the interpretation separately and display it over the main video application level. Implementations can do this today. The incremental storage cost is far smaller. However, the device must run two simultaneous video decoding sessions one for the main program and one for the overlay. Some smart TVs support only one concurrent decoder. Moreover, better platform integration like native language selection, UI, and AirPlay support would require standardizing the carriage of overlay videos in his.

So a third idea is to use optional tiles or layers supported by some recent video codecs. A single encoded bitstream carries the main program, plus one or more tiles or layers Holding sign language interpretations. The decoder configuration determines which layer to display over the main program. This option needs recent codec support, and we haven’t yet verified how well. Decoder implementations handle optional tiles and layers.

Moreover, to continue, support older devices and not transmitting extra layers for users not using it, you may have to store this new encoded bitstream separately, resulting in no eventual savings in back end cost. If any of you have tried it, we would love to hear how you went. None of these solutions are ideal and each of them has compromises. And again, regarding these options, I would like to raise the awareness of some areas of considerations.

There are two things that need a signal. One is the sign language itself American Sign Language, British Sign Language, or any of the many others established worldwide, though not often used. You can use the existing language attribute on video renditions to specify the sign language. However, there is a distinction between programs that are themselves scripted in sign language and renditions that carry sign language. Interpretation of the main program that introduced the need of a second signal, which carries the intent of the language usage, such as transcription of the dialog. Our team is leaning toward using the characteristics attribute to carry the intent.

Another consideration, as we mentioned earlier, is the trade off between back end cost and compatibility. It has real effect on the reach of your sign language content. And there’s the consideration of web deployment. Browsers can display multiple synchronized HTML5 media elements. So the overlay option should be already possible there without new APIs. But let us know if you disagree.

We are at an early stage in meeting these regulatory requirements. So if I missed anything that matters to you or if you have any feedback after this talk, please reach out through the following venues. First, there’s a Q&A session this afternoon where you can raise questions. It covers topics from the whole summit, so there won’t be time for everything.

There’s also the interest mailing list open for ongoing discussion. And there’s Apple Developer Relationships channel. You can email Apple’s Media Technologies evangelist Sergey Maliuk directly. And finally, here is the survey for his summit participants. This survey works through these topics raised here and can help organize your thinking. Please scan the QR code to participate. I’ll give you a few seconds to do so.

One reminder these venues are meant for technical discussion. So if you have questions regarding the legislations specifically, please talk to your lawyers instead. And also please make sure any suggestions you share in these venues are open for adoption and implementation. Do not reveal anything considered proprietary. What helps us most is suggestions that make HLS work better for everyone, both to meet these regulations and to deliver the best experience to put people using your apps. That’s everything from me. I’m happy to pick this up this afternoon and continue on the mailing list. Thank you. And next I’m going to hand off to David. Thank you.

Concurrent media experiences

Hello. My name is David Hassoun. I’m the co chair of the advertising workgroup at the Streaming Video Technical Alliance or Svta. I’m also the chief solution architect at Colabs. This presentation is going to explore some of the work being done at the Svta and Colabs around client side concurrent non-linear advertising and editorial multi-view experiences.

In this presentation, I will first express what the big idea is regarding concurrent media experiences, then discuss challenges of fragmentation and device capabilities, how we intend to address those challenges with specification documents and tooling. Then understand what the progress and status of this work is within the VTA, and wrapping it up with a call to action on how to get involved. So let’s begin with the big idea that concurrent non-linear experiences is the natural evolution of consuming streaming media, and that the future resides in the player capabilities.

Media players have evolved significantly. Features that once required custom application code now run natively, including server guided ad insertion or SDI and interstitials using date range tags. The natural next step is concurrent media experiences. Concurrent or non-linear media experiences retain the linear context of content without interruption, while also rendering additional content or advertisements concurrently.

Standardizing concurrent playback in the player gives the ecosystem a single foundation instead of many incompatible implementations. The Svta addresses this opportunity in the form of specification documents and usable code for both ad supported and editorial content. HLS can deliver these enhancements concurrently through the existing interstitial and asset less machinery by defining a layout object in the asset list Json and implementing a concurrent interstitial class in the date range tag.

Next, let’s discuss the biggest challenges we face. There are two main problems that remain at the forefront of any proposed solution. The first is avoiding Fragmentation through standardization and industry alignment. The second is clearly detailing what should be done across different device capabilities and hardware support. Nonlinear or concurrent adds have been around for years. They are quickly becoming an industry baseline. The Interactive Advertising Bureau, or IAB, finalized its connected TV specification for formats like pause ads, Squeezebox, Double Box Overlay, and Lower thirds.

Without standards, each player ad server and create. A vendor invents custom signaling and layout controls, leading to fragmentation. Solving this requirement requires aligning across IAB formats. Player developers across HLS and Dash and ad tech platforms. The Svta has collaborated with the IAB and has also shared this proposed architecture with the Dash industry Forum to align across standards groups while multi-format alignment progresses in parallel. Our focus today is HTTP live streaming.

While basic playback is straightforward, edge cases and device constraints require careful design. Concurrency involves four key dimensions decoder count, secure path limits, audio channels, and viewport geometry. Because many platforms lack public APIs to query hardware limits, this can create some challenges. Finding the balance of how much the SVT solution should attempt to identify and control in regards to device capabilities is a key topic that we’re working towards.

For fallback devices that cannot support, secondary decoders can optionally use other static based assets provided in the asset list. They can fall back to the linear interstitial or skip the ad break altogether. This is in addition to standard failure scenarios such as no fill issues within the ad responses themselves. the same layout primitives also power editorial features like quad view and multi-camera streams.

Only one ad experience can run at a time, but there’s a requirement to have the ability to mix concurrent and linear ads within an ad break. One use case that this can be addressed is adding concurrent ads before or after an ad break, with linear ads to extend the overall break ad opportunity without stepping on content.

Now let’s understand what the solution entails and what the specification and tools provide. The solution is delivering specification documents and toolings to implement and validate these enhanced user experiences. The specification delivers three additive components that build upon the ratified Svta 2053 data model without breaking existing HLS clients.

First, an interstitial class identifier on the standard X date range tag that players can opt into. Second, a layout model in the asset list Json that uses percentage based viewport offsets inspired by CSS, making placement independent of screen resolution and aspect ratio. Third mandatory. Graceful degradation if a player does not support concurrent playback or cannot parse the layout data, it falls back to standard sequential interstitial behavior. Open source client implementations are currently underway for web based and native device player SDKs. We have actionable code available. There’s also web based tool to interactively create and visualize layout data for both HLS and Dash today.

Here is how the end to end architecture operates for non-linear advertising. It’s going to be illustrated for the system flow diagram that’s going to be progressively shown on the screen. First, the packager receives a SCTE 35 cue marker inserts a standard date range tag into the HLS playlist, just as they do today. It has an updated class value. That’s the only change.

Second, the player is going to load the playlist when it encounters the date range tag. It requests an interstitial payload from the ad presentation server, or APS. The APS is responsible for making any ad decisioning requests and providing the asset list Json in response. The client can supply query parameters detailing its hardware capabilities, such as the number of available decoders, if desired, the ad presentation server queries, the AD decisioning server, or ads for vast XML, and translates the response into an asset list Json. The APS also injects the layout data. Then it returns the enhanced asset list Json to the player for coordinated rendering.

This slide initially displays a code block of an HLS media playlist on the left. The signaling builds directly on Apple’s interstitial design for date range tags. The tag declares the new concurrent interstitial class and passes query parameters to the to indicate capabilities of the client to the apps. This can include details such as decoder count. It can then be used by the apps when requesting data from the ads, to get content in the format that would be properly supported by the client. Now the corresponding asset list Json payload is on the right.

The payload supplies the layout structure. The viewport object defines coordinates for top right, bottom left as percentages, and defines the area in which the asset should be scaled to fit within. This is illustrated with the graphic on the right. Type is used to define the Mime type of the current asset as and the URI within the layout data defines the current asset itself. There are optional parameters for volume and z-depth stacking as well. Core metadata like timing and tracking are all part of the standard Svta 2053 formatting that’s already been published in the past.

This slide displays another code block of a slightly more complex layout object that would be contained in an asset list Json response. It’s an example where the layout of the primary content is affected to create a double box pullback experience. The end result illustrated in the graphic to the right once again, where the primary content is squeezed back and rendered alongside the ad asset in opposite corners. The primary content in this example is rendered in the lower right quadrant, and the ad asset is rendered in the upper left quadrant.

During playback, the client evaluates both the class attribute and the asset list payload. When the player supports concurrency and valid layout data is present. It renders primary video and secondary assets simultaneously in their assigned viewports. If the device lacks capabilities for concurrent media or layout data is missing, the player gracefully falls back to standard sequential interstitial playback without errors or interruption. A use case raised by a major streaming provider requires a solution that can fall back to server composited streams for hardware limited devices.

But even when using the composited stream, they need the extended stay data and layout details to handle interactions and tracking beyond commercial breaks. This exact layout model supports editorial workflows. For example, a quad view or multi-camera sports stream using four viewport definitions in the same asset list envelope handled entirely native by the player logic without any ad semantics.

Next, let’s understand what’s the status of this proposed solution is. Implementation of the core specification is well underway. Additive without the new playlist architecture. Sorry. Without any new playlist architecture and compatible with the existing interstitials. By design, the edge cases of the real remaining work. The largest remaining item is finalizing device capabilities. What management we need to take control on within that and the implications for fallback and layout decisioning.

There are still decisions needing to be made on if support for anchor positions within the viewport is necessary. IAB only outlines using 16 by nine content, but there are real use cases, such as banners or pillars, and dealing with things like lower third that need to be considered. Dash support needs further implementation as well. The final step of the project will be submitting the. The documentation and the libraries to the CTA member companies for review, feedback and final approval.

The reference implementation work is well underway. The Svta Nonlinear Edge Generator, a visualization tool for constructing and previewing these asset list based layouts, exist today. On the client side, reference software development kits are available for native Swift on iOS and tvOS, as well as players via HLS, JS, and JS as coming soon. Common Media Library integration discussions have also started as well, but plenty of work still to be done there.

So this is a recording of a working build and demo. I’m going to narrate over it. Anyone wants to see some more of this stuff? Come see me later on. I have some other really cool demos, but let’s get this started. To set the stage, there’s two players. They’re playing both the same content. The only difference is they have a different X date range class defined the standard one on the left and the concurrent one on the right.

The one player on the left is a standard stock HLS player, and the one on the right is a standard stock HLS player. But with our library loaded in, you can see we have decoder set. We’ll come back to that later. Here we have the interstitial class and the concurrent interstitial class, which are in those X date range tags I mentioned.

First off, you might notice on the bottom there’s a missing an ad break on the one on the left. That’s because there’s no default linear ad defined in that asset list. Whereas on the right we have a new concurrent ad showing a squeeze back double box. As you can see there. Now the ad is done.

If we go to the second ad break now, we’ll have a traditional linear interstitial on the left and a concurrent ad experience on the right. Because we have a default experience defined for that asset list Json that’s being loaded in on the one on the right, we’re showing an Lbox pull back. And of course, as I mentioned on the left we have the traditional linear one. Now if we go to the third ad break, we can see another example of the concurrent ad on the right. I believe this one’s going to be a lower third video banner overlay.

and then our traditional linear on the right. Now if you see also that I’m highlighting the capabilities here. We’ve said we have two decoders and one image and we support images. I’ve switched it to only show one decoder. So now if we’ve defined options for alternate layouts, in this case a static image for our pullback L box it will render that.

And if we go to another one we can see another alternative option. So in this case it’s going to do a double box. But with a static image where we have the linear on the left. So if there’s only one video decoder we can then have alternative fallback experiences. If we turn off and say no, we can’t do image compositing as well. You now notice we’ve dropped that first ad break and we now have parity. Now it’s this fallback to traditional linear ads in totality.

Same thing if we go to the second ad break or technically the third one, we’ll have that. So here’s another demo. This one dives a little bit deeper into actually the pieces and parts. You can see the data that’s actually going on. So we started off our library loaded in. We have two decoders and image allowed.

Playback has begin. Same contents for first panel will actually show us our X date range tag. And you can see here we’re using the concurrent interstitial class as defined panel two. This is actually going to show the request to the asset list. And you can see we’re passing on optional parameters to indicate if we want to affect our ads. Decisioning panel three we actually get the response. This is the asset list Json that gets returned back.

Here. We can see we’re doing a squeeze back affecting our primary content. Then below it the actual additional asset that we’re going to show with that. So the content on the right hand side, and if we scroll down a little bit further as well, we can even see this is alternative content that we’ll take a peek at later. If we couldn’t support that primary one.

On the fourth panel to the left, you can see the actual options that are broken out from there and defined, as well as which option was selected. Now, if I switch it to only have one decoder and limit this, we still have three ad breaks. That’s great. But you can look on panel for option one of the squeeze back video is no longer allowed because it requires two video decoders. So now it’s going to pull the asset list Json additional option based off the Mime type for an image.

If I switch it to. Also, image compositing isn’t going to be supported on this device in panel four. You can still see, great, we have our options, but both of them have been discarded. And now it’s saying like, okay, hey, listen, we have to go to linear. If that is defined. In this case, it was defined for the second and third ad break. And therefore we’re able to go from there.

The best solutions are not developed in a vacuum. Of course they involve the industry. This is where the call to action comes in. So let’s talk about how to get involved. If you are not an Svta member, you can still check out and try the reference code and demos Colabs has prepared. For now, the repo is still outside of the Svta, but it will be moved over once we get things a little bit more polished. It’s public and available.

Try the Svta nonlinear ad generator. Give any feedback. You can email me directly if you have any thoughts, use cases, or questions. You can hit me at [email protected] or David at dot org. And of course, if you’re not part of the Svta and your company isn’t an existing member, you can look at joining. I highly recommend it.

If you are a member of the Svta, you can join our ads workgroup meetings. We meet 1 to 2 times per month on Wednesdays. The next meeting is October 4th. It’s going to be a big one. We have a lot of really good stuff to cover. Review the Svta 2053 draft specification document. This has all this new capabilities in logic within there. If you need access content me or requested from the document link, I’m going to be provided on the next slide.

So I prepared a document with all the pertinent links to the resources that can be found, including the demos and so forth. I also prepared a sign up for people in the industry that want to provide their opinions on key topics. If you’re interested in being involved, please fill out the form at bitly slash state dash survey or just email me and I’ll contact you. Thank you, and I really look forward to your questions and involvement. Next up, we got the real Rob G, who’s going to be talking about some advanced ad solutions as well. Seem to have lost the slide.

Dynamic Ad Insertion at large scale and low latency

Hey, I’m Rob, I work at NBCUniversal and I’m going to talk about date, range, schedule and preload and how that helps us achieve a dynamic ad insertion at massive scale and at low latency. So first I want to outline why DAI for live events can be challenging. I’ll quickly outline what we’ve done to date using traditional discontinuity based server side stitching, because it serves for good precedent. We’ll interlude into what is enticing about interstitials, then follow our journey in working with the HLS team until we get to an end result that we and I hope others using HLS will be happy with.

Okay. The challenge. So first things first scale live streaming is the norm and it is massive. Peacock’s legendary February earlier this year serves as a good example of this. The Milan Olympics delivered 16.7 billion minutes, streamed in 850 live events over 17 days. At the same time, Peacock delivered on Super Bowl 60, the NBA all star game, and much, much more. All those viewers expect playback and no degradation in quality, even if so many people are watching at the same time. Achieving this takes a giant team effort, but also a lot of thoughtful design far in advance of delivery.

We also need to think about monetization, and key to our operation is dynamic ad insertion. To achieve best results, we give all users their own personal ad experience. The problem we run into is that the ads in live events sit at well-established places on the content timeline. What I mean is that your live content will be progressing at some stage. We know the ad queue, so cut the segment short for frame accurate placement. The signal is then delivered at the same time for all users. This is the dreaded thundering herd, and each user needs a personal ad decision to fill the planned duration of the break at that moment.

Low latency only makes things more difficult. Our ad server has even less time to react, as players are generally more synchronized and have less time to wait before running into a stall. As we all know, playback stalls are unacceptable, so we have massive concurrent viewership and a complex ad decision that happens just in time for everyone. We need to tackle one of these. I’m sure my bosses wouldn’t be too happy about me suggesting to reduce viewership, so we looked into the just in time decisioning instead.

The general principle is basic. We want to spread out the ad decision, but as we’ll see, the repercussions are more complex. To start, it is unclear what duration of ad load to request, since we do not know in advance how long the next break will be. If we resolve two larger decision, we may overfill the break opportunity and drop impressions. Too little. And it’s not an effective preload.

30s seems just enough to cover what we would normally consider the smallest possible break duration. When the ad signal arrives, the Stitcher can insert the cached segment references into the playlist without making any new just in time request. The rest of ad break requests is then also spread out to reduce server load. Unfortunately, it’s not just as simple as that. We now have two isolated decisions being made by the AD decisioning server. Essentially two separate aggregate break requests with potentially varying durations.

Keeping the requests with no knowledge of each other may lead to bad experiences. For example, we may serve the same ad twice, or we may serve two competitor ads within the same break, which is also undesirable. To solve this, the preload response includes a transaction context that is then passed into the rest of break request. This provides the ad decisioning server the context necessary to treat the second request as part of an overall single break experience.

But things are yet still more complicated. As said, these live events are regularly major sporting broadcasts. There may be several sponsored partners that receive special mention or placement in the live production. An example scenario is an announcer queuing up the coming break, as brought to you by company A, and in that case it must be that company A is AD appears first.

Well far in advance of the break. We don’t yet know if it will be sponsored and if so, which sponsor, as these can be decided quite reactively to in-game events to account for this. We receive a dynamic ad as well as the set of sponsored options for the event. Think of it as a buffet of ad options alongside the transaction context. Only when the ad signal is inserted into the stream do we know which option to use. But importantly, we don’t need to make any new just in time requests to do so.

We call this solution multi request sequence or MRS for short. Quickly summarizing it all again. The server preloads a 32nd ad break decision on user entry to the stream. The response includes a buffet of options to choose from, as well as a transaction context to define the response.

Once the ad opportunity signal is known in the stream, we insert the preloaded segment references for the correct option without needing to get a new decision. The rest of the break requests uses the transaction context to create a cohesive break experience, and is spread over the duration of the initially inserted ad duration. The process repeats at the end of the break, with the next preload, similarly getting spread across the active viewer population.

The bottom line is MRS. allows us to spread out the load of ad decisions without sacrificing personalization or overfilling spots, while also accounting for our ad sale requirements for cohesive break experiences. Awesome. That’s SSI. So what’s so great about HLS interstitials anyway? Fundamentally, HLS interstitials allows us to decouple delivery of the video stream from personalized ad decisions. This means the stream can scale as regular HLS does. By which I mean exceptionally well and is unaffected by AD system failures, which gets us closer to that flawless delivery target. So here’s how that can work.

Section 4.3 on variable substitution is our friend here. It’s only a small section but very powerful. So if you haven’t already you should check it out. High level. It allows you to use an HLS tag to define variables, and then later use the variable name rather than the value in places like URI lines or quoted string attribute values. Using this concept, we can create all the personalization contexts we need and save it in the client via the Multivariant playlist response. Remember, the MVP is requested once by the player, while media playlists are requested frequently in a live stream. So putting personalization here is ideal.

In the media playlist, we just need to import the variables that we’ve defined, and the client knows that the previously received values are now in scope. When an interstitial is inserted, we can define the asset list URL using the variable rather than the personalized value. The client becomes our infinitely scalable database of user personalization parameters, and since interstitial delegates resolving adds to the player, concentrating instead on guiding the player on how content should be replaced. The primary content delivery system doesn’t actually need to know anything about the personalized ad response. The same exact media playlists are delivered to all users, yet each may receive a different personalized experience.

This is so important it deserves another statement slide. The concept of decoupled stream delivery from ads delivery must be accounted for in any interstitial solution. I believe that this is especially important as we look for new ways to bring latency even lower. So about time. Let’s talk interstitial solution.

We’re confident MRS. works as it’s proven well for us so far. We implemented it for SSI but believe it’s valuable regardless of how ads are stitched into the timeline. Interstitials are how we believe we unlock the next level of potential scalability. Remember, we have a personal ad session for all users, so even with MRS., it can get quite tricky generating the discontinuity based manifest for each user. Happily, there exists a concept in HLS that allows for Pre-loading of date range resources before the start date is fully known. However, it is a relatively new concept, so I’ll provide a quick refresher.

The concept of preloading was added in August 2025 as appendix F. The preload tag defines the resource that is to be preloaded. It also defines a methodology for associating the preload with some future date range. The target class is what defines the action that the client should take when the preload comes into scope.

And for interstitials. The player picks a random point within the defined range to request the specified resource. This can then be used to serve a future X asset URI or X asset list request. Avoiding just in time decisions. Overall, the concept seems very close to what we are doing with EMRs, so we started investigation on how the concept could be applied within the existing specification.

Limitations were soon discovered that seemed insurmountable with the way the specification was defined. We decided the best course of action was to reach out to the HLS team to discuss our use cases. We identified several issues, and solving those raised several more issues, but we worked through each together to a satisfactory conclusion. I’ll go through each of these in detail now. The first I call the split break problem, but can equally be called the early return problem.

As stated in EMRs. We want to spread out the request for part of the break. We therefore must split the break into two interstitials when inserted, but we must consider early return to explain. An early return is when there is an unscheduled interruption of the advert, and the user must be brought back early for the primary content.

For example, the action restarted sooner than anticipated for a single interstitial. This is handled via the addition of the X-PLAYOUT-LIMIT attribute limit attribute when the earlier return is known to limit the ad playback to the specified duration, but with two interstitials describing one break. We ran into a problem.

Remember, the packager cannot know anything about the ad response as it is personalized per user. We may be tempted to guess that the first interstitial will have a duration of 30s, as that is what we hope for from the ad server. However, we cannot rely on that. Indeed, there are cases where it may respond with 60s.

If. In that case, we set the limit to 30s, the first advert would cut short halfway and begin the second advert early. Clearly that’s not a good user experience the alternative direction. Setting a high or no limit on the first leaves us in the scenario that an aggressive early return would be missed as the first interstitial overruns. We were quite stuck at this stage.

Happily, the HLS team were already working on something useful. Date. Range. Schedule. A schedule allows the server to respond with an array of date ranges that the player can then place on the primary timeline. It allows for much more control in where interstitials are placed, which provides several benefits in terms of ad experience possibilities.

For us, this was a great opportunity as the schedule is itself a date range. We made the request that child interstitials should be clipped by the parent range, and the HLS team agreed that this seems reasonable enough for us. This solved the problem as we can now set an end date to be a shared absolute point across both scheduled ads and as with regular interstitials, those placed at the same start time play sequentially. Importantly, the packager doesn’t need to know anything about the ad responses to write these instructions. Happy days. But the solution to use date range schedule brings us to a new problem.

Date ranges must have a start date. But now we’re stuck again. Because how can we preload a date range schedule if we need to know the exact start date of it in advance? Preload is crucial to our MREs design, so we need to get this right. The HLS team, again, was understanding and helpful.

The idea of X schedule offset was proposed such that date ranges delivered via schedule response could use a schedule offset instead of a start date. Then, the player determines the final start date by adding the offset to the start date of the parent schedule. Our problems are solved again and we can preload happily.

I’ll note that this is also a nice ergonomic improvement for joining a stream midway through ads. In this case, we have a reduce. We can. We can have a reduced decision for just what is left of the break, and then easily offset the ads to start at the point indicated by the player.

Previously, with interstitials to achieve something similar, we would have to pad the start of the assets array in the List response with a dynamically sized slate asset, which is non-trivial to create and so fairly awkward to implement. Schedule makes this much easier. So we’ve covered what we’re preloading, but now we need to discuss when we’re preloading. The definition of preload at the time only allowed for a static range of time in the media playlist where preload could occur.

This means that users entering the stream after the end of the range will not receive any preload. Well, step one of MRS. was loading content on entry. It’s very important for us as we could receive a spike of users joining the stream and they would all hit the ad server at the same time on the first break. And for low latency, it’s even more important as each user is at a much greater risk of stalling on their first ad break. Without preloaded content.

After some back and forth, the addition of X duration at join to preload was agreed on. The value is the duration in seconds to spread the preload after joining. This gives extra flexibility to decide on how to fuzz out spikes in users joining the stream. Again, another win and we’re feeling confident.

But now X duration of join throws up a new and awkward issue. Remember, MRS. provides a buffet of options in the first response, but preload provides the exact response for one date range. There is no mechanism for preloading a buffet menu of date range responses that would require some quite unique variable substitution syntax, and a whole new precedent on option selection logic. This would all be far too niche. And so the result is we have to achieve this with several preload tags.

Now consider we have tens of ad breaks in window, each with several associated preload tags and all marked as expiration at join. If only one from each of this set was eventually matched, users on entry could be hit with a storm of perhaps even hundreds of network requests for content they will never even use.

The solution here required a nuanced interpretation of the existing specification. Appendix F preload states that if the URI of the preload date range does not match that of the target date range tag, then the client should discard the preload result. We propose that this implies that you may choose to have several Preloads with the same target ID, but with different URIs, and that in such a case the player will preload all of them and discard all but the one that matches the inserted date range.

This interpretation resolves our issue as unmatched preloads are discarded. However, it was an exact use case. Once again, the HLS team was very understanding, willing to work through implementation examples, and eventually we came to an agreement that the Multi-period single target ID approach was permitted, and so players should implement handling for such scenarios. We now have almost all the pieces. However, one of the most crucial components of solution still stands is unsolved. Remember the rest of break interstitial signal and the preload break signal are separate URIs in the media playlist.

We don’t have any way directly defined in HLS to parse context from the response of one HTTP request to the next. That doesn’t involve writing something in the playlist. But we can’t write this information in the playlist as it’s personalized. All is not lost. The ad Schedule server is a viable place for add session state to live. However, throughout this exercise, we were doing everything possible to keep things as stateless as possible. To help with scalability and it felt unsatisfactory to not have a way out here.

This interaction turned out to be one of my favorite exchanges with the team, just because I was working so within the box of HLS specification. But the HLS team thought outside of that box. A reminder to everyone that HLS that HLS stands for HTTP Live Streaming. The format is built on top of HTTP and therefore all HTTP semantics apply, and we can leverage tools from that specification.

Specifically, HTTP cookies have existed for a long time, and they were introduced for pretty much exactly this use case, the sharing of state across multiple requests. With the right cookie value format, we could ensure that the required data is transferred from the chosen preload to the rest of break requests, and therefore guarantee a cohesive ad break experience.

We still have more experimentation to do to understand how universal this approach could be. Since cookies have got a pretty bad rep over the years, but it worked on the devices we were targeting, which was a very happy result. Ultimately, we may still fall back to Server-side managed state here, but this idea serves as an important reminder to everyone. So why I wanted to include it. There isn’t just one toolbox you can go to for fixing your problems.

And with that, we have all that we need. Quickly summarizing the actual HLS changes, we got X duration at join. Add it into appendix F, an entirely new appendix H for date range schedule was added And schedule offset is part of that new appendix H. As are the end date clipping semantics with specifics added to appendix D for interstitials.

Ultimately, we showed it possible to achieve our goals for EMRs using purely HLS defined semantics. You can find that the necessary API for hooking into date range schedule events exists in AVFoundation, so that is supported in native DRM protected playback on Apple platforms. Importantly, a working solution without relying on custom extensions gives us confidence that it can be extended to other players as they become compliant with the updates. This is very important for the viability of this as we extend to other native platforms with large user bases.

Finally, I want to emphasize that this story isn’t special. The HLS team is willing to work with those that bring real product use cases for change. You can reach out in the HLS mailing list. The HLS interest mailing list. I can share that my experience through this was fun and fruitful. Yours could be too. And thanks, everyone for listening. Back to Sergey.

Thank you so much. And thank you to your team for scaling your service. Oops. Wrong button. And thank you so much to your team for scaling your service for Legendary February. Next, we’ll have a lunch break. There are directions outside the theater to the lunch area, and I’ll see you here. Back again at 1 p.m. for the live Q&A. Thank you. All right. And here we are again, this time to answer the questions that you have submitted. And thank you so much for such a great participation on discussion platform today.

Q&A

Let me invite our amazing presenters on stage so we can begin this Q&A. All right. A few minutes to get into the theater. Questions. Q&A is still open, so if anyone has more questions, maybe specifically on the content that we presented today or, you know, last presentations, feel free to add we we are here for you.

And I’ll a start with some questions that are actually, you know, beneficial for my own knowledge, probably it wasn’t asked in a discussion. So the first question I have is about a playlist archives. Can playlist archives contain a data range? And you know if know why. Sure. I can take that as as John said in the presentation today, playlists contain only segment URLs and media segment tags. Date ranges are media metadata tags, I think. So they’re not in playlist archives. And so that’s the technical answer.

But let me sort of talk a little bit about date range and particular one of the benefits of date range tags and HLS playlists is they provide the player with a global view of all the metadata. As soon as it loads the playlist, and that global view is updated constantly in a live playlist.

And we want to retain that with playlist archives. If a date range ends up getting buried, were to be buried in a playlist archive, that could have some detrimental impact on the player. And let me give a quick example. Interstitials, as most of you know, are carried as date range tags and interstitials can carry navigation restrictions. So they can say I’m an ad. You’re not allowed to skip over me without playing the ad first.

If we were to bury that kind of thing in a, in a playlist archive and you were playing, the viewer was playing, you know, way back in, you know, eight hours from live and wanted to jump forward to live. We would, as a client, need to load every single archive between the jump point and the destination seek in order just to check if there was an interstitial that had a jump restriction.

And we don’t want that. And so we made a very conscious design choice with playlist archives to. Keep them as sort of pure List of segments, which is where the bulk of the of the playlist is. And retain date ranges in the live playlist itself, which the player will continue to update during playback even when it’s playing back at an archive. So the player will continue to have the most recent contacts and be up to date with the live presentation itself.

Makes sense. Okay, thank you for answering that. And while we’re on a playlist archive topic, there is a question from audience when playing within a playlist archive in live, should the player periodically update it or rely on the information of the regular playlist? Yeah. So I guess I think I must have anticipated that question to say again. Yes, the expectation is that if you have a live playlist with archives, even when the player is playing way back in the seventh last archive or what have you, you know, hours and hours from Live edge, the player will still continue to update the live playlist partially so that it can give the user an accurate. Picture of the expanse of the playlist.

For example, you might be playing three hours back and the live event could end, and so you would want to be able to reflect that in your player UI that you know, the bar is no longer growing. It’s now fixed and now the playhead is traveling toward the end. And so we do expect, excuse me, that during archive playlists, the live playlist will continue to update. Okay, good. Thank you. I have a question for Eryk. Is it possible to configure MSV 2.0 with a config file instead of many command line options?

Oh yeah. You know, we made a conscious decision that in MSV 2.0, anything that’s in a that you can express on the command line can be in one of the settings files and vice versa. Now they won’t necessarily have the same structure. The settings file obviously is, is a Json has a little bit more structure, but with the export settings you can get everything you want.

And you actually allowed like, I think including. Oh yeah, you could actually you. So in the settings file, you have to use the full name of the option. So you have to say include settings. But yeah, you can nest it, you can nest it to several levels. But so we do have a check to make sure you don’t get recursive. Okay, so if, if I had like a, a set of rules from my, my, my downstream service, whatever, but then I want to layer my own rules on top. I could create my own like settings, Json and then include theirs and get.

Yeah, absolutely. Absolutely. That way with the only limitations being if you’re using an option that’s not allowed to be repeated, right? You don’t have have an issue, but by and large, Options are either options that are allowed to be repeated. You can repeat as many times as you want. Okay, awesome. And I believe we’re going to go over this in depth in the workshop today, right? Yeah. Yeah. So if you attend one of the workshops this afternoon, we’ll go into more detail. Great. Next question. Maybe Rob can you can take this.

I believe it’s related to interstitials. And you know, Ted’s presentation on podcast, how, you know, how you can install multiple, like, you know, intro and outro in the interstitial block. So the question is, if you don’t burn your bumper transitions in and use interstitial assets, List do you lose the ability to crossfade in and out of your bumpers? Well, crossfade, how exactly MSK is what I would say like. You know.

Either the bumpers crossfade from your audio already or they don’t. And I don’t think that we have a way of crossfading with interstitial content in general, other than like some very, very like small crossfades just so you don’t hear pops or anything like that, that occur with audio and MSc and overlapping of pens, there isn’t a crossfade support for single timeline MC playback as far as I know.

Yeah. I mean, if, if, because I remember hearing Ted talking about that. And I think that, you know, what he was saying was that with interstitials, like in podcasts today, with the way they do insertion with, with MP3 is that you could have the sort of the outro jingle. Bum bum bum. Now time for an ad and then immediately. And now we’re back to our our thing. And that you could, by putting those into the interstitial, you could sort of like if you didn’t fill the ad, you could go right through.

And this doesn’t. And so if the question like if part of your production of a podcast is you’re talking through the first part of your outro, then it’s not even a question of like interstitial technology, right? It’s really a question of authorial intent because if you don’t fill that ad, but you’ve got some crosstalk during your outro, then you don’t really have great choices because either you could suppress that entire outro, but then the audience doesn’t hear the last part of what you said, the host and the podcast, or you could keep it in, but then if you don’t fill the ad, you’re going to hear the outro.

And so. You know, that isn’t really something that we can solve easily with dynamic ad insertion. And so it’s really, you know, for someone in that position, you really have to make a choice. Are you going to talk over your outro? If you are, then I think you probably have to have the outro. And if you don’t fill the ad, then you’re going to hear the outro regardless.

Great. Okay. Makes sense. I have a question that it’s not in our discussion forum, but someone has asked me in a hallway and it’s probably for, is there any similar, like you talked about loudness control and sign language? Is there similar regulations around subtitles or closed captions? Yeah. So there are like mentions of like about European accessibility activity and but whether or not you should follow those regulations, it’s not Apple’s advisement advice to, to take on, but I think all those regulations are going to be supported by HLS existing features. So if you have other like demands that you think we should implement, just let us know, okay.

And you can use feedback assistant, you know, you can log in to your developer account and submit a go to feedback assistant.apple.com and submit a request if you have any about the, you know, particular. In the United States, for a long time, we’ve had the FCC requirements that any content that is broadcast needs to carry captions.

Right. And, and we have, you know, we’ve, we’ve largely in the streaming industry adhered to that. Even in cases where the content wasn’t necessarily broadcast, but we still treated with that FCC mandate. And so, yeah, I think that it’s not. Certainly captions are not exempt in some ways. They’re like the, the original accessibility ask.

But I think we’re in the fortunate position of having good solutions for, for subtitles and captions. Whereas you as, as you were saying, you know, some of these other ones are still kind of nascent, right? We don’t, you know, we have some ideas, but we’re also not necessarily the most experienced among you guys. I mean, remember last year, BT actually came and showed us that first demo of the British Sign Language. And so we’re definitely interested in hearing about your experiences and your, you know, your run ins with regulation and, and tell us about how H laws can help.

Yeah. And we have showed that QR code for survey and encourage you all to, you know, fill out and we’ll send it again over email after this show. You know, please, please, please fill out. It’s very important for us. Next question is for Roger. What are the fundamental differences between preload and data range preload class when to use which or are data range preload tags only valid for range tags?

Good question. The difference is really that well. So at a very basic level the preload hint tag is defined to preload a very specific set of, of things, right. Specifically initialization segments otherwise known as map tags, content keys now and partial segments. Those. Those are the three that are in the spec. And those are the only things that the. That the player is, is, is going to support. And all three of those things are very sort of integrated into the segment flow.

In contrast, the preload date range class is a date range class and is applies to other date range classes and date ranges are a little bit funny because they don’t necessarily have to sit at any particular place in the segment timeline, and they don’t need to be produced with the same cadence as the segments that they apply to you.

You can throw a date range tag way in advance of where you actually have segments. You can say, hey, I want to schedule an upcoming ad a minute from now. You might not even have segments in your playlist at that time. And so date ranges and segments are a little bit disconnected.

And so that’s why we have one mechanism for preloading date ranges and another for preloading hints. And as Rob mentioned in his talk, the date range tag is actually a little more flexible than the preload hints because it has this two level match of target ID and also URL.

And so that enables you to do something like what Rob was describing, where you can actually create a buffet of possibilities that you might want to use in your eventual, you know, interstitial or schedule that you haven’t added to your, to your playlist. Yet, because the outbreak hasn’t actually been determined, you don’t actually know how, how long it’s going to be or whether it’s going to be sponsored or all that stuff. And so you want to be prepared for those 3 or 4 eventualities.

And so the date range preload has that additional level of flexibility because again, preloads can happen at, you know, at different times on different time frames. And date ranges have to be the same across all playlists. The same ideas, the same URIs, preload hints are different, and that they are most likely going to be different for the content in. That. Playlist. Tend to be. They tend to be associated with that. That’s another great point.

Okay. Super helpful. Next question is on iframes maybe for Europe. What image formats aside from MJPEG, are acceptable in iframe playlists? We’ve talked about that a little bit before, but so far we’ve we’ve only worked with Jpeg and Jpeg. Like whether we might want to add something with HDR support.

And what formats those might be, but I haven’t seen any other formats yet. I haven’t seen. This. Yeah, I and clearly, you know, some of this is like the spec, the HLS, the core spec doesn’t tell you which codecs you have to support or you can’t support. And so a lot of this is player dependent.

I can say that for AVPlayer on Apple platforms, the only image format, the only Non-video format that we support in AVPlayer for iframes is motion Jpeg. And so if you want compatibility with AVPlayer, then you’re looking at motion JPEG or of course AVC, HEVC, AV1, etc. If that’s not an issue for you and you know, and you’re using hls.js. Then it’s open source.

And I think you could jack in a different image format. Right. If that worked. You sure could. You sure could. You know, the world is your oyster. Okay. It’s clear. Thank you. Next question, I believe. Anyway. How should we encode and package interstitial content containing ads that typically are purposely very loud to be normalized on Apple devices?

Interstitial. Oh yeah. So the idea is that how you encode in packaging systems that are, you know, very loud purposely, like, is there any. Well, actually, I don’t recommend you do that first. Like. Because like, if you encode something really loud, you can affect the user experience. And we want to have a consistent loudness level for all the contents, especially for like between your segments and things like that. So. But eventually, if you want to encode that, you can do it without like, like enabling loudness control or anything like that. It’s up to your app’s policy to determine what kind of policy to apply.

But essentially what you want is to sort of annotate that this is an ad and like. Yes, as long as you annotate like what kind of content it is. Like with music, we have some like content type already proposed in our content type content box. Okay. Yeah. So.

So so in other words, there’s no special signaling for like extra loud adds, right? It’s just, you know, the do the two things that, that, that you described, which is measure your loudness and signal it like a loudness box or something and annotate the content, which in this case would be an ad. And when we presumably in the player, if we were to make use of that, we would take into account what sort of content the primary was.

So whether it was a television show or a music, you know, you know, streaming music or whatever, and then we would apply loudness. And of course, you know, a stream can have a particular loudness level, an average loudness level, and parts of that stream can be louder, right? And it’s the same thing in an ad. The I think personally that the spirit of a regulation is to.

make sure that something that if someone’s shouting or someone’s whispering in an ad that’s played for you at the same volume as someone who’s shouting or whispering in the primary content, because you’ve got your volume control on your TV. Right. Or maybe you got your remotes or whatever. You guys don’t have knobs on your TVs anymore.

But so you set that up to be comfortable for you for, for your primary content. And I feel like the thing that my impression is that the thing that really got people riled up about ads was that they were watching Happy Days or whatever it is. You guys watch now on on the TV.

And then there’d be an ad break, and suddenly it allows me to so much louder and be like, what the. And now I’ve got to scramble for my my knob in my case and, you know, to turn it down. So, you know, it’s don’t be stupid is sort of the, you know, the, the, the, you know, the, the bottom line here. All right. Cool. Thank you. That’s a great answer. Let’s switch gears a little bit.

I have a question on advisory keys. So you know actually not so much advisory. It’s more like a, you know, extension advisory keys. You know, keys are helpful, but is it possible to serve multiple keys via a single request? You know, this could be useful for like a multi-variant, you know, switching.

Yeah. Great question. And as I mentioned earlier in my talk right now with advisory keys, the security level of each key must be the same. So if you want to have advisory keys across different variants, if the security level is different, you will not be able to do that.

But if they are the same, for example, you might want to load all your keys or all your keys, then yes, you can have multiple keys in that response. As far as the client requesting multiple keys, that’s not what advisory keys the use case of advisory keys you want to. It’s a server and FairPlay on device contract.

Okay. Do you think that in you know is is is there a possible world where we could someday add more options to getting keys? And maybe. I mean, if we want to hear from you guys and what your use cases are. So if there is a real use case for batching keys across different variants or across, you know, the client, please let us know. We’d be very interested in having more discussions.

Yeah. Those Feedback Assistant requests are being read for you. Great. Thank you. I have a question about HTTP/3. Maybe you can address it. Does HLS run over quick? Yes. And just for those of you who you know, some of the terminology so quick was is a alternative to TCP for reliable bulk data transmission.

And it was pioneered by Google about four years ago now and since then was adopted by the IETF as a standard. And so now we have IETF QuIC standard quick. And alongside that. So as you know, we started with HTTP/1.1 and then we had HTTP/2, which was HTTP over TLS plus some additional stuff, stream control, etc., etc. Or we now have HTTP three and HTTP/3. Again, from a very high level is essentially HTTP/2, but over QuIC.

And so that is what we believe to be the most performant and the most responsive implementation of HTTP that is currently widely available today. HLS absolutely runs over HTTP/3. And in fact, we recommend it, particularly where responsiveness is an issue. And I’m thinking like low latency streams, for example, where the ability to quickly change your mind about what you’re downloading and go download something else has an impact on user experience. But even even without that, H three is great. We recommend you use it. You get all the benefits of quick and it’s we like it. It’s good.

Okay. Very useful. Next question. We have taught here, Ted here to answer that question. But what HLS future should a podcast use to authenticate play count from real viewers for the purpose of defeating fake play through spam? And you guys want to take that? Anyone? All right, let me let me channel Ted for a second. Ted’s not here. Okay. So.

In podcasts, we have a situation. It’s a healthy situation. It’s actually a really good situation where we have these players that play a common format and they play everybody’s content, right? This is actually kind of unusual. Most of our players are focused on our own catalog. Podcasts are pretty amazing because if I’m an author, I don’t need to have a player. I don’t need you to, to, to download my app on the App Store to play my content.

And in fact, I’m hosting my own content. I have control over that. I have control over, you know, hosting fees and quality of service. And now ads with HLS video with interstitials. I can now control my entire ad flow and my inventory and stuff like that. And that’s great. That also means that now I kind of own the fraud problem, right?

Because I’m the one who’s serving the content and now I’m the one, if I’ve got some bought in some, you know, country that is just hitting my thing over and over and over because they also have a partner who’s, you know, who’s got selling ads to. And they want me to pay for the same ad that is supposedly being watched over and over.

Right now, I own that problem because I’m I own the content distribution. So it’s a real problem. It’s. That being said, in order to really get what they’re asking for, which is some, some, some level of trust, right? That when a play count is reported, that it is actually a real play count by a real user on that application.

There’s nothing in HLS specifically that can do that for you. It’s really, at this point, something that is going to be on the individual podcast app. And Apple, of course, has a podcast app. It’s one of the most popular podcast apps. And I know the podcast team is extremely interested in keeping that the entire podcast ecosystem healthy, which means people can get paid as well.

And so I think that it really turns into a discussion between podcast providers and teams like the podcast team to come up with a solution because it’s the app at the end of the day that knows that a real user has signed in, they’ve watched the content, they watched it for five minutes or whatever. Maybe they saw an ad. I mean, the app ultimately has that level of authority.

And so I would encourage people concerned, you know, with that extremely legitimate concern to reach out to the podcast team. And I think you will find a hospitable reception to that discussion because I know that it is something that they think about as well. And so that’s, that’s kind of how I would, you know, I would answer that. Okay. I think it’s a healthy answer. Let me see. Roger. From talking for too long and answer all the questions. Let’s talk about keys again. How often do keys needs to be rotated?

Good question. Again. Well it depends. If we step back and try to understand why we want to have key rotation in the first place, many of you might say it’s for protecting against attackers. The more you have more key rotations you have, maybe it will increase the chance, decrease the chance of your entire content being leaked.

But there’s another argument where if an attacker can get one key, what stopping them from getting more keys. So the other aspect of this might be you have a business contract where you do need to have more robustness and have more key rotations as far as the security perspective goes.

I would say about an hour or two every hour or two would be sufficient. But if you would like to have faster key rotation, we do support that. And with preload hints and advisory keys, you can avoid thundering herd issues with fast key rotation. So we do offer both approaches.

Okay. So so you would say do rotate your keys sometimes, but you don’t have to go crazy with it. You don’t have to go crazy. You just make it easier on yourself. Makes sense. One more question on please archive proposal interstitials already led HLS reference external playlist and integrate them into the timeline with X resume offset and X timeline.

So this looks represented table as interstitial content occupying in the history range, plus a relaxation to the 6.2.1 update rules. Sorry, sorry, I think I missed the question. I guess they’re asking if playlists archives is sort of redundant, given that there are interstitials. And I see, I see, so I think.

No I’m not. So all right. Let me let me because I’m not quite sure I understand. Let me just sort of say a bunch of things. You can certainly have a live stream. Where is it is completely covered in interstitials, right. You can certainly build that so that every, every part of that timeline is occupied by one interstitial or another, and the player will handle that.

That being said, you still have to have a live stream underneath it. You know, even if it’s a single variant stream, even if it has 22nd segments, right? You still need a live stream to support the presentation of, of that sort of fake linear kind of experience of interstitial, interstitial, interstitial. So you can do that.

But that’s, I mean, you know, again, if we look at the, what the problem of playlist archives addresses, it’s that you can have these incredibly large playlists, you can have an eight hour playlist, you can have a, in some cases, I’ve heard of like one week playlists. And these playlists are so large that they break the ability of certain devices, not Apple devices, but but certain devices. Some devices Apple content actually plays on from from handling them correctly.

And so that’s, that’s what and so if you can get around that situation, if you can avoid that situation using interstitials and that works for your, you know, for your production back end and everything else, you know, by all means, but there are the, the folks who’ve come to us and been like, wow, this is a problem.

You know, people like Cooper from Disney, they do not structure their streams. This, these, this way. Their live streams are traditional. You know, I’m streaming a cricket match and it’s going to go on for a day, right? And we want people to be able to jump back to the previous.

Over. What over the previous over. They say that. Yeah. Okay. Good or innings. The innings something yes to the previous over. And and or two overs back. Right. Three overs back. Multiple overs. Lots of overs. And and so they have a live stream. They have like ends. They have like a thousand segments or whatever it is.

And so playlist archives are there to address folks like that. And there are a lot of folks in that situation. I mean not, you know, obviously there’s more VOD than than long form, long, long form live, but there’s enough that it’s come up to us multiple times from multiple people. And multiple people have come up to me today and said, wow, I’m really interested in playlist archives because I have, you know, customers or whoever who are in this scenario.

So in principle, maybe they could solve that by switching all their stuff to interstitials, but we’re not going to recommend that. That’s not, you know, we’re not going to tell people that, oh yeah, you know what? You should be using interstitials for that, because that’d be so much easier.

You know, we want you to break your cricket match up into different programs and make those different interstitials just so you can overcome the limitations of this kind of crappy TV that you bought in 2015. It’s not. It’s not a good solution. And so we think they both have their place. But archives, you know, we, we think there’s a, there’s a use case for archives. And a lot of you who’ve I’ve talked to this week seem seem to agree. So yeah.

Yeah. You wouldn’t be able to do the same kind of roll off like you can’t move play out limit in an interstitial to sort of roll the interstitial in to replace the part that’s rolling off of the live playlist. And as John, I think pointed out, we want archives to be supportable through like a, a proxy at the edge. It takes that big playlist and delivers something smaller to. Write.

Yeah. I mean, remember one of the great things about the playlist archive proposal is that it actually has a backward compatible guys, right? You can have, you can keep your, you can keep all your old clients on your one hour DVR window. And everybody who updates gets an eight hour DVR window.

That same stream, right? You don’t have to, you know, sniff the user age or anything. And so that’s, that’s actually pretty nice. Yeah. So that question before, right, like, yes, the live playlist keeps getting reloaded, but the archive does not. You load an archive once you have it, maybe you unload it to load a different one and keep memory usage down, but that’s not something that gets pulled. Again, you’re not doing two things. Yeah, that’s a good point. We want to make sure that if a client loads a playlist archive, they can hold on to it. They don’t have to reload it. And so it’s a, it’s a one time cost per per variant.

Makes sense. And I think I would add the playlist archives at this point is a proposal. We don’t feel that we’ve thought through all the edge cases necessarily. So we encourage you to take a look at it and see if you think there’s something wrong with it. Yeah. Or, or as Eryk said, if you’ve got a use case that it doesn’t seem like we’ve addressed, you know, let us know because we’re not this isn’t stone yet. Right. I mean, I, I haven’t started implementing it. I’ve done like, we’ve done a little bit of prototyping on it to make sure we think it was going to work. But, you know, there’s still time to change it. So yeah.

All right. Next question. It’s about a presentation, but maybe we can answer that here. What happens if the user joins during the ad break in their system? Well fine. I was just channeling Ted Hosmann from podcast. Now I’m going to do my best to channel Rob, who I’m sure is here somewhere, but he’s right there. Okay, Rob, you’re going to wave at me if I get this wrong.

Okay, so you’ve got a live, you’ve got a live event. You’re populating it with date range schedules to announce your ad breaks. Okay. And so I’m watching the live event. You’re also pre-loading these things. And so like that’s for scale, as Rob said, that’s, that’s really important is that you don’t overload the ad server.

And so in the normalness of, of use, what happens is everyone’s already tuned in. They’re all watching. They, you know, at one moment they see a preload for an ad spot or maybe four preloads. Thanks, Rob. And so we load like all three of those or four of those or whatever. And so now we’ve done the ad decisioning for that one break or maybe four different flavors of that one break.

And then once, you know, maybe 10s or whatever before the actual break when production says, okay, they’re, they just, you know, went out, they just walked off or whatever. And so now there’s a new over whatever we’re going to, you know, we have, we got a 92nd break at that point. Then they. And it’s happening, it’s going to start in 7.3 seconds from now. Right at that point, the packager puts you in the actual date, range, schedule, interstitial date or date range tag with a particular date. Okay, right. 7.3 seconds from now it’s starting right.

And we’ve already done all the decisioning. So. Right. Yep. We got this. We’re going to, you know, we’ve already done our decisioning. We can just immediately start buffering that first ad. And then during that ad, you know, we’re going to then buffer the rest the other 60s of the break. Right. So that’s. MRS.. And the question is so okay, but what happens if maybe 10s into that first ad, I, Johnny come lately joined the stream. Right. What happens with me?

Well, first of all, we don’t think that is as critical of a scaling problem because it’s less likely that you’re going to get a thundering herd during an ad and I can I can go back and talk about, you know, maybe you could anyway. And then what happens? But by and large that, you know, one Z, two Z people joining your stream are not a scaling problem.

And so the question becomes, okay, well, let’s, let’s, let’s imagine your ad server is responsible. What happens? Well, just as with any interstitial, when you join a live stream, what’s going to happen is the client’s going to load the live playlist. It’s going to figure out where it’s join point is where it would normally start playing the primary content.

And then it would say, oh, wait, but there’s a date range schedule covering this range before I start playing my primary content, which, by the way, is probably slate at this point because we’re in a break. I’m going to go see, oh, look, I’ve actually already got it resolved because, well, actually, no, I don’t because I just joined. So I don’t have it resolved.

So I didn’t see the preload I didn’t get. So I’m just going to go off and load the URI for that date range schedule. I’m going to wait. Yum yum yum yum. But the answer is not overloaded. Comes back right away. Says, here you go. You’ve got two interstitials, the first 32nd AD and the. And then the other third 60s, which I’ve just. Decision for you. And so the player will say, okay, I know I’m 10s into this first thing. And so I’m going to load the first guy and then I’m going to play out the rest of it.

Or potentially maybe I joined a minute in. Right. And Rob mentioned this as well, this case of, okay, I’ve joined, you know, at the beginning of the third ad in the ad break, as it turns out, the way things are, because I joined a little bit later. At that point, the ad decision server, because the client will tell the server when it makes the. When it tries to resolve the schedule, how far in to that date range?

The client’s playhead currently is. The same HLS params that we send for interstitial data. Yeah. And so the server, the decisioning server then is able to say, okay, I, you know, I can see that you’ve skipped the first two ads and, and I’ve only have 30s left to decision. You know, the remainder. And so I’m just going to give you one ad and I’m going to use the like the schedule offset to, to put that at the 62nd mark.

And then that comes back, the player is going to say, oh, okay, thank you very much. And it’ll load that and it’ll start playing. So that is did I get that right? Yeah. Fantastic. Okay. That’s how MRS. works when. You. When you join midstream. Right? Big thumbs up. Give myself a Marcos or something for that.

All right. A plus. Rob gives me a thumbs up. Yep. Like it? Awesome. I think we have time for two more questions. The first one is probably quick. It’s probably a yes or no question. Is Dolby Vision Profile 10.1 going to be supported alongside 8.1 on all those devices. And by those devices I mean probably Apple platforms. Yes.

So you know my way. Do you know. No. Okay. I thought someone was telling me about this earlier, but I can, you know, if you guys don’t remember those. It must have been. I was having a discussion with someone today, but the answer is it good news? It’s already there.

So for those of you who are not up on HDR trivia and Dolby Vision, the difference between Dolby Vision Profile 8.1 and Dolby Vision Profile 10.1 is the base codec 8.1 uses HDR10 on Hevc as a baseline, whereas 10.1, I believe uses a V one with HDR10 as the baseline. And so for Apple, excuse me, Apple devices, all Apple devices that support eight v one already support Dolby Vision Profile 10.1. So it’s it’s there today. Awesome. Great news.

And the last question is much broader. What is the biggest limit. Actually sorry I should say, and also support HDR because we might have I don’t I don’t remember if we have a device out there that does a V one but doesn’t do HDR. I don’t think so. have iPads. I don’t remember. We have so many devices. All right. So okay, let’s just move to the last question, which is what is the biggest limitation in HLS today that Apple would like the IETF community to solve over the next few years? It’s a very big open question. Okay. All right.

First, thank you for the question. I, you know, I, you know, it’s great to hear that you’re interested in getting involved and helping out because, you know, we can all always use help. I would say that there’s no single biggest missing thing or gap in what we are constantly. And hopefully that’s clear. You know, as we do these things, as we’re on the list and stuff like that, is that our goal is to be constantly, Ideally ahead of things in terms of understanding where the pain points are in the streaming space.

I mean, for you guys, for us content providers, you know, vendors, networking, privacy, you know, all these different, you know, accessibility, regulatory, you know, we would like to ensure that HLS works for all you guys and allows you to create the experiences you want to create for your users. That’s, that’s our goal.

And we know the size of your company. Like, you know, we are happy to work with Peacock or you know. Yeah. For sure. Yeah, yeah, yeah. There was a conversation I just had in a hallway with some folks saying, you know, it’s great that, you know, NBC support NBC, but you know, we hope you support everyone like that and we actually do.

Right. Yeah. We try. But but this brings me to my second point, which is that there are a lot of different things that, that, you know, a lot of different features. We could add a lot of different pain points, and some of them are more important than others. And so alongside that continual search for, for, for the things to, to, to address, there’s that triage or prioritization thing of what’s the most, you know, and we try to address things as best we can in that order. It’s like, what’s the most pain for the most people?

And so we’ve been doing that for, you know, HLS 15 years now, right? And so if there was a big single thing where it was like, oh my God, I, you know, I wish HLS supported subtitles, that’d be so awesome. Not so much. The that being said, there are some things you could help with. One of the great things about HLS is the ecosystem, right? And how broad the reach is.

And there’s lots of, you know, there are open source implementations of both tools and players. You know, we, we, we like HLS, JS, we think it’s a great open source player. There are other HLS players like Shaka, for instance, that are also open source. And some of them, you know, we think AVPlayer does a pretty good job of, of, of implementing the latest specs and things like that. Some of the other players are a little bit further behind, but if you can jump on board and implement something like date range schedules or preload hints or something like that for players that don’t already have them, that can be a big win.

And it’s not, you know, it’s not the necessarily the, the biggest thing holding back HLS. But if you can, you know, you can add, can nail one of those or two of those or three of those, those things add up and eventually it turns into real change. The other thing that really helps HLS, I think, is, again, because we are always on the lookout for, you know, where the pain points are, where the new opportunities are, where things are, where things are heading. But we don’t see everything.

We like to think we see a lot, but we don’t know everything. And so and we don’t have a chance to talk to everyone. And so anything that can help raise the visibility of problems that sort of have a wide base within, you know, our, our industry here, I think helps everyone because it helps us focus on what’s important.

And so, you know, I know that there are some companies who, who do like annual surveys and it’s always interesting to read them. I mean, if you’ve got time, you’re not an engineer. You don’t want to spend your time working on chocolate or whatever, but you’d like to contribute.

I mean, maybe start your own, maybe start your start an HLS focused annual survey, right? Send out your link to HLS interest and say, hey, I’m doing a survey and I want to hear, what do you use HLS? What features do you use? What features are you planning on using? What do you wish was, you know, blah, blah, blah, and just, you know, anything that can. Help the help us all understand where the industry is moving and, and where we can help. I think is an opportunity to benefit HLS as a whole.

So that’s, that’s kind of what I got. Yeah. That’s great. The one thing I’d add is even if it’s an issue you brought up before, and maybe we weren’t receptive the first time, keep asking. It makes a difference. Like things change year over year and yeah. And, and as I, as I often say, when, when Rob brings up this point or not, I’m not going to.

But I forgot to. Dunk on Rob. It’s always more it always is a higher impact if like you can come to us and say, hey, I gosh darn, I wish HLS has supported iframes, which now it does, but it’s always higher impact to say, I would love to be able to have a scrubbing experience just like, like for my content.

I want to be able to scrub just like QuickTime player does, or just like the, you know, whatever or I, what I’m saying is if you tell us why you want something in addition to what you want, that is going to be that’s going to have a bigger impact.

And it allows us to sort of understand, oh, yeah, because someone else asked for the same thing, or pretty close enough to the to the same thing, and allows us to judge not only what you’re asking for, but a better sense of how broad that request is across, you know?

And so we can spend the time working and benefit as much as many of you as we can for that, you know, that release cycle or whatever, because we always have more work to do than we have time. I mean, you guys are in the same position, right? And so we have to make choices.

And so our goal is to make smart choices that benefit that, that produce as much benefit as we can. So help us do that. And inspirational answer. That’s great. Doug on it. All right. So this is all the questions that we can answer today. Let’s give a big round of applause to our presenters.

And thank you so much for all the questions you asked. And remember, there’s more we have we have round tables. We have. Ones. Yeah. I’m going to talk about that. Okay. So we have the activities as just mentioned. As you exit the theater, there will be, you know, there will be signs where you can go. There are multiple options.

We have community discussions. We have one of our appointments. I’ve seen many of you have already scheduled those, which is great. It makes me happy. And we have workshops, you know, make sure you go to one of those. We have limited seats, but I hope, you know, because we run it three times. All of you will be able to attend them and look forward to see you at the mixer at 5 p.m. Thank you everyone. See you around.