Adaptive streaming is essential for delivering high-quality video content across various devices and network conditions. In this DevTip, we'll explore how to convert videos to HLS (HTTP Live Streaming) and MPEG-DASH (Dynamic Adaptive Streaming over HTTP) formats using Rust and FFmpeg.

Introduction to HLS and MPEG-DASH

HLS and MPEG-DASH are adaptive bitrate streaming protocols that allow video content to be delivered efficiently over HTTP. These formats break videos into smaller segments and provide multiple quality levels, enabling clients to switch between different bitrates based on network conditions.

Understanding adaptive streaming

Adaptive streaming works by:

  1. Encoding the video at multiple bitrates and resolutions.
  2. Segmenting each encoded version into small chunks.
  3. Creating manifest files that describe the available streams and segments.
  4. Allowing clients to request the most appropriate quality based on their current network conditions.

Setting up a Rust project

Let's start by creating a new Rust project:

cargo new video_converter
cd video_converter

Add the following dependencies to your Cargo.toml file:

[dependencies]
ffmpeg-next = "5.1.1"
thiserror = "1.0.40"
anyhow = "1.0.72"

Ensure that FFmpeg is installed on your system, as the ffmpeg-next crate provides bindings to the FFmpeg libraries.

Integrating FFmpeg with Rust

We'll use the ffmpeg-next crate to interact with FFmpeg. First, let's create a simple function to initialize FFmpeg:

use anyhow::Result;
use ffmpeg_next as ffmpeg;

fn init_ffmpeg() -> Result<()> {
    ffmpeg::init()?;
    Ok(())
}

fn main() -> Result<()> {
    init_ffmpeg()?;
    println!("FFmpeg initialized successfully");
    Ok(())
}

Implementing video conversion to HLS and MPEG-DASH

To convert videos to HLS and MPEG-DASH formats, we'll use FFmpeg command-line tools via Rust's Command module. While the ffmpeg-next crate provides powerful bindings, invoking FFmpeg directly can be simpler for certain tasks.

Converting to HLS

Here's a function to convert a video file to HLS format:

use std::process::Command;
use anyhow::Result;

fn convert_to_hls(input: &str, output_dir: &str) -> Result<()> {
    std::fs::create_dir_all(output_dir)?;
    let output_path = format!("{}/index.m3u8", output_dir);
    let status = Command::new("ffmpeg")
        .args(&[
            "-i", input,
            "-codec", "libx264",
            "-profile:v", "main",
            "-preset", "medium",
            "-crf", "23",
            "-sc_threshold", "0",
            "-g", "60",
            "-keyint_min", "60",
            "-hls_time", "6",
            "-hls_list_size", "0",
            "-f", "hls",
            &output_path,
        ])
        .status()?;
    if !status.success() {
        return Err(anyhow::anyhow!("FFmpeg process failed"));
    }
    Ok(())
}

Converting to MPEG-DASH

Similarly, to convert to MPEG-DASH format:

fn convert_to_mpeg_dash(input: &str, output_dir: &str) -> Result<()> {
    std::fs::create_dir_all(output_dir)?;
    let output_path = format!("{}/manifest.mpd", output_dir);
    let status = Command::new("ffmpeg")
        .args(&[
            "-i", input,
            "-map", "0",
            "-c:v", "libx264",
            "-c:a", "aac",
            "-b:v:0", "1M",
            "-b:v:1", "2M",
            "-s:v:1", "1280x720",
            "-profile:v", "main",
            "-use_timeline", "1",
            "-use_template", "1",
            "-init_seg_name", "init-$RepresentationID$.m4s",
            "-media_seg_name", "chunk-$RepresentationID$-$Number%05d$.m4s",
            "-seg_duration", "6",
            "-adaptation_sets", "id=0,streams=v id=1,streams=a",
            "-f", "dash",
            &output_path,
        ])
        .status()?;
    if !status.success() {
        return Err(anyhow::anyhow!("FFmpeg process failed"));
    }
    Ok(())
}

These functions use FFmpeg to convert the input video into HLS and MPEG-DASH formats by invoking the command-line interface. They create the necessary playlists and manifest files required for adaptive streaming.

Building a simple streaming server in Rust

To serve our HLS or MPEG-DASH content, we can create a basic HTTP server using the warp crate:

use warp::Filter;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let routes = warp::fs::dir("./output");

    println!("Starting server at http://127.0.0.1:3030/");
    warp::serve(routes)
        .run(([127, 0, 0, 1], 3030))
        .await;
    Ok(())
}

Make sure to include warp and tokio in your Cargo.toml:

[dependencies]
warp = "0.3"
tokio = { version = "1", features = ["full"] }

Testing the streaming setup

To test your streaming setup:

  1. Convert a video to HLS or MPEG-DASH format using the functions we defined:

    fn main() -> Result<()> {
    init_ffmpeg()?;
    convert_to_hls("input.mp4", "./output/hls")?;
    convert_to_mpeg_dash("input.mp4", "./output/dash")?;
    println!("Conversion complete. Starting server...");
    // Start the server
    Ok(())
}

  2. Start your streaming server:

    cargo run

  3. Use a compatible player (like VLC) or a web player library (like hls.js or dash.js) to play the stream from http://localhost:3030/hls/index.m3u8 or http://localhost:3030/dash/manifest.mpd.

Conclusion

In this DevTip, we've explored how to convert videos to HLS and MPEG-DASH formats using Rust and FFmpeg. We've demonstrated how to generate the necessary playlists and manifest files, and how to set up a basic streaming server in Rust. To further enhance your adaptive streaming solution, consider:

  • Encoding videos at multiple bitrates and resolutions for true adaptive streaming.
  • Implementing more advanced FFmpeg settings for better video quality.
  • Adding support for multiple audio tracks and subtitles.
  • Incorporating secure streaming with HTTPS and token-based authentication.

By leveraging Rust's performance and safety features, you can build robust and efficient video processing pipelines for adaptive streaming applications.

If you're looking for a managed solution for video encoding and adaptive streaming, Transloadit offers powerful video processing capabilities that can handle these tasks efficiently and at scale.