Skip to main content
Advanced Streaming

How to Dynamically Repackage M3U8 to MPEG-DASH On the Fly

Operating dual streaming formats (HLS for Apple ecosystem, MPEG-DASH for Android/Smart TVs) doubles your storage costs and complicates DRM integration. In this guide, we dive into the engineering principles and tooling required to dynamically repackage an HLS (M3U8) workflow into MPEG-DASH (.mpd) in real-time, known as Just-In-Time (JIT) packaging.

Updated September 8, 2026 Expert Engineering Series 8 minute read

Delivering high-quality video across a fragmented ecosystem requires supporting multiple adaptive bitrate (ABR) protocols. While HLS (HTTP Live Streaming) is universally supported by Apple devices, MPEG-DASH is the standard for Android, Windows, and Smart TVs, specifically when utilizing Widevine DRM. Storing static variants of both formats leads to enormous cloud storage costs. The modern solution is Just-In-Time (JIT) packaging.

Why Dynamic Repackaging?

By keeping only one mezzanine format (like raw MP4 or TS segments referenced in an M3U8) on your origin storage, you can use a packaging edge server to generate manifests and transmux media segments on the fly. This architecture provides several distinct advantages:

  • Storage Efficiency: Cut storage footprints by 50% by avoiding duplicated DASH and HLS segment generation.
  • DRM Flexibility: Encrypt the stream with FairPlay for HLS and Widevine/PlayReady for DASH dynamically, without storing multiple encrypted copies.
  • Operational Simplicity: You only encode your video once. The packager maps your ABR renditions seamlessly.

How JIT Packaging Works Under the Hood

When a client requests a DASH manifest (.mpd), the edge packager intercepts the request. It dynamically reads the corresponding HLS .m3u8 master playlist, determines the ABR ladder (resolutions, bitrates, codecs), and writes out an equivalent MPEG-DASH XML manifest.

As the player requests video segments (.m4s in DASH), the packager fetches the original HLS segments (typically MPEG-TS .ts), strips the transport stream container, and repackages the raw H264/AAC frames into fragmented MP4 (fMP4) ISOBMFF containers. Because this does not involve re-encoding (only re-muxing), it takes mere milliseconds.

Approach 1: Using Nginx-Vod-Module

One of the most robust and widely adopted open-source tools for this is Kaltura's nginx-vod-module. It is a highly optimized NGINX module designed for just-in-time video packaging.

To repackage an existing HLS asset, you can configure nginx-vod-module in "mapped" mode. Here is an example of a core NGINX configuration block:

location ^~ /hls-to-dash/ {
    # Enable the VOD module in mapped mode
    vod mapped;
    
    # Define how segments are handled
    vod_mode local;
    vod_fallback_upstream_location /origin-fetch;
    
    # Enable DASH packaging output
    vod_dash_manifest_format segmentlist;
    
    # Optional: Cache the dynamically generated manifest
    vod_metadata_cache metadata_cache 512m;
    vod_response_cache response_cache 512m;
    
    # Add CORS headers
    add_header Access-Control-Allow-Headers '*';
    add_header Access-Control-Allow-Origin '*';
    add_header Access-Control-Allow-Methods 'GET, HEAD, OPTIONS';
}

In this setup, when a player requests /hls-to-dash/video.mpd, NGINX reads the source JSON map (which can point to your M3U8 assets) and dynamically serves the DASH stream.

Performance Tip

Always enable vod_metadata_cache. Parsing MP4 headers or TS segment metadata on every single DASH request will overload your CPU. Caching the metadata ensures near-instantaneous manifest generation.

Approach 2: On-the-Fly Transmuxing with FFmpeg

If you prefer a microservice approach rather than an NGINX module, you can build a small Node.js or Go server that wraps FFmpeg to transmux segments on demand. FFmpeg can convert M3U8 playlists directly into DASH manifests without re-encoding the video frames.

To convert an HLS playlist to DASH statically or via a script pipe, the core FFmpeg command looks like this:

ffmpeg -i "https://origin.example.com/stream/index.m3u8" \
    -c copy \
    -f dash \
    -use_template 1 \
    -use_timeline 1 \
    -hls_playlist 0 \
    /var/www/html/output.mpd

The crucial argument here is -c copy. This tells FFmpeg to copy the bitstream exactly as it is, avoiding the massive CPU penalty of transcoding. The -f dash flag instructs FFmpeg to generate the fMP4 segments and the MPD manifest.

Handling DRM & Encryption On the Fly

One of the most complex parts of migrating from HLS to DASH is DRM. HLS commonly uses AES-128 or Apple FairPlay (Sample-AES). DASH relies on Common Encryption (CENC) utilizing Widevine or PlayReady.

If your source M3U8 is already encrypted with AES-128, a JIT packager cannot blindly transmux it. It must first decrypt the TS segment using the key provided in the `#EXT-X-KEY` tag, and then re-encrypt it using CENC before packaging it into fMP4.

When building an on-the-fly packaging architecture, always store your mezzanine master files unencrypted, and apply DRM signaling dynamically at the edge. Tools like Shaka Packager and Nginx-Vod-Module support dynamic fetching of DRM keys from a CPIX-compliant Key Management Server (KMS).

Troubleshooting Dynamic Repackaging

1. Segment Alignment Issues

MPEG-DASH requires strict alignment of IDR frames across multiple bitrates. If your original M3U8 variants were not encoded with exact GOP (Group of Pictures) alignment, the repackager will fail to create a compliant DASH manifest. Players will stall when attempting to switch quality levels. Verify your HLS segments using tools like ffprobe to ensure IDR frames align perfectly at the start of every segment.

2. Missing CORS Headers

Because dynamic packagers act as a proxy layer, it is very common to misconfigure CORS (Cross-Origin Resource Sharing). The DASH player (e.g., Shaka Player or Dash.js) operates via XHR/Fetch requests. If the dynamically generated .m4s segment does not return an Access-Control-Allow-Origin header, the browser will block the video.

3. Audio Codec Incompatibility

HLS supports ADTS AAC audio multiplexed directly into TS segments. DASH expects AAC to be encapsulated in an ISOBMFF container. A poorly configured JIT packager might fail to parse the ADTS headers properly, resulting in a video stream that plays flawlessly but produces no sound. Always verify that your packager is correctly stripping the ADTS headers and rewriting the MP4 moov/trak atoms.

Summary

Dynamically repackaging M3U8 streams into MPEG-DASH is a massive cost-saver for large-scale VOD and OTT platforms. By leveraging robust tools like nginx-vod-module or FFmpeg-based microservices, you can serve the entire fragmented device ecosystem from a single storage origin. As long as your source HLS streams maintain strict GOP alignment and you handle DRM at the edge, JIT packaging is the modern standard for video delivery.