Video Streaming in Go: HTTP Range Requests, HLS Segments, and FFmpeg

GET /video.mp4 HTTP/1.1
Range: bytes=0-1048575

HTTP/1.1 206 Partial Content
Content-Range: bytes 0-1048575/52428800
Accept-Ranges: bytes
Content-Length: 1048576

package main

import (
	"log"
	"net/http"
)

func main() {
	http.HandleFunc("/video/", func(w http.ResponseWriter, r *http.Request) {
		// ServeFile handles Range headers, 206 responses, ETags, and If-Modified-Since.
		// The path after /video/ maps to the file system.
		http.ServeFile(w, r, "videos/"+r.URL.Path[len("/video/"):])
	})

	log.Println("serving on :8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

package rangeserver

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strconv"
	"strings"
)

// ServeRange serves the file at path with full range request support.
func ServeRange(w http.ResponseWriter, r *http.Request, path string) {
	f, err := os.Open(path)
	if err != nil {
		http.Error(w, "not found", http.StatusNotFound)
		return
	}
	defer f.Close()

	info, err := f.Stat()
	if err != nil {
		http.Error(w, "stat error", http.StatusInternalServerError)
		return
	}

	totalSize := info.Size()
	w.Header().Set("Accept-Ranges", "bytes")
	w.Header().Set("Content-Type", "video/mp4")

	rangeHeader := r.Header.Get("Range")
	if rangeHeader == "" {
		w.Header().Set("Content-Length", strconv.FormatInt(totalSize, 10))
		w.WriteHeader(http.StatusOK)
		io.Copy(w, f)
		return
	}

	// Parse "bytes=start-end"
	start, end, err := parseRange(rangeHeader, totalSize)
	if err != nil {
		http.Error(w, "invalid range", http.StatusRequestedRangeNotSatisfiable)
		return
	}

	length := end - start + 1
	w.Header().Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", start, end, totalSize))
	w.Header().Set("Content-Length", strconv.FormatInt(length, 10))
	w.WriteHeader(http.StatusPartialContent)

	f.Seek(start, io.SeekStart)
	io.CopyN(w, f, length)
}

func parseRange(header string, total int64) (int64, int64, error) {
	if !strings.HasPrefix(header, "bytes=") {
		return 0, 0, fmt.Errorf("unsupported range unit")
	}
	parts := strings.Split(header[6:], "-")
	if len(parts) != 2 {
		return 0, 0, fmt.Errorf("malformed range")
	}
	start, err := strconv.ParseInt(parts[0], 10, 64)
	if err != nil {
		return 0, 0, err
	}
	end := total - 1
	if parts[1] != "" {
		end, err = strconv.ParseInt(parts[1], 10, 64)
		if err != nil {
			return 0, 0, err
		}
	}
	if start < 0 || end >= total || start > end {
		return 0, 0, fmt.Errorf("range out of bounds")
	}
	return start, end, nil
}

package hls

import (
	"fmt"
	"log"
	"os"
	"os/exec"
	"path/filepath"
)

// Segment transcodes inputPath into HLS segments in outputDir.
// It blocks until FFmpeg finishes (VOD use case).
func Segment(inputPath, outputDir string) error {
	if err := os.MkdirAll(outputDir, 0755); err != nil {
		return fmt.Errorf("create output dir: %w", err)
	}

	manifestPath := filepath.Join(outputDir, "index.m3u8")
	segmentPattern := filepath.Join(outputDir, "segment%03d.ts")

	cmd := exec.Command(
		"ffmpeg",
		"-i", inputPath,
		"-codec:", "copy",         // Copy streams without re-encoding (fast, no quality loss)
		"-start_number", "0",
		"-hls_time", "6",          // Target segment duration in seconds
		"-hls_list_size", "0",     // 0 = keep all segments in manifest (VOD)
		"-hls_segment_filename", segmentPattern,
		"-f", "hls",
		manifestPath,
	)

	// Capture stderr for debugging. FFmpeg writes its log there.
	cmd.Stderr = os.Stderr

	log.Printf("segmenting %s -> %s", inputPath, outputDir)
	if err := cmd.Run(); err != nil {
		return fmt.Errorf("ffmpeg: %w", err)
	}
	log.Printf("segmentation complete: %s", manifestPath)
	return nil
}

package hls

import (
	"net/http"
	"path/filepath"
	"strings"
)

// Handler serves HLS files from dir.
func Handler(dir string) http.Handler {
	fs := http.FileServer(http.Dir(dir))

	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// CORS headers are required for HLS playback from a different origin
		// (e.g., a video.js player on a different port).
		w.Header().Set("Access-Control-Allow-Origin", "*")
		w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
		w.Header().Set("Access-Control-Allow-Headers", "Range")

		if r.Method == http.MethodOptions {
			w.WriteHeader(http.StatusNoContent)
			return
		}

		// Set correct MIME types.
		ext := strings.ToLower(filepath.Ext(r.URL.Path))
		switch ext {
		case ".m3u8":
			w.Header().Set("Content-Type", "application/vnd.apple.mpegurl")
			w.Header().Set("Cache-Control", "no-cache") // Manifest changes during live
		case ".ts":
			w.Header().Set("Content-Type", "video/mp2t")
			w.Header().Set("Cache-Control", "public, max-age=3600") // Segments are immutable
		}

		fs.ServeHTTP(w, r)
	})
}

package main

import (
	"flag"
	"log"
	"net/http"

	"github.com/yourname/video/hls"
)

func main() {
	segDir := flag.String("dir", "./segments", "HLS segment directory")
	addr := flag.String("addr", ":8080", "listen address")
	flag.Parse()

	mux := http.NewServeMux()
	mux.Handle("/hls/", http.StripPrefix("/hls/", hls.Handler(*segDir)))

	log.Printf("HLS server on %s, serving from %s", *addr, *segDir)
	log.Fatal(http.ListenAndServe(*addr, mux))
}

package hls

import (
	"context"
	"fmt"
	"log"
	"os"
	"os/exec"
	"path/filepath"
)

// StartLive starts a live HLS stream from inputSource into outputDir.
// It respects ctx for graceful cancellation.
func StartLive(ctx context.Context, inputSource, outputDir string) error {
	if err := os.MkdirAll(outputDir, 0755); err != nil {
		return fmt.Errorf("create output dir: %w", err)
	}

	manifestPath := filepath.Join(outputDir, "live.m3u8")
	segmentPattern := filepath.Join(outputDir, "live%05d.ts")

	cmd := exec.CommandContext(ctx,
		"ffmpeg",
		"-re",                          // Read input at native frame rate (for file inputs)
		"-i", inputSource,              // e.g., "rtmp://localhost/live/stream" or "/dev/video0"
		"-c:v", "libx264",
		"-preset", "veryfast",          // Low CPU, low latency
		"-tune", "zerolatency",
		"-c:a", "aac",
		"-hls_time", "2",               // Short segments for low latency
		"-hls_list_size", "5",          // Keep 5 segments in manifest (sliding window)
		"-hls_flags", "delete_segments+append_list",
		"-hls_segment_filename", segmentPattern,
		"-f", "hls",
		manifestPath,
	)

	cmd.Stderr = os.Stderr

	log.Printf("starting live stream: %s -> %s", inputSource, outputDir)
	if err := cmd.Start(); err != nil {
		return fmt.Errorf("ffmpeg start: %w", err)
	}

	// Wait for FFmpeg to exit (context cancellation stops it via CommandContext).
	if err := cmd.Wait(); err != nil && ctx.Err() == nil {
		return fmt.Errorf("ffmpeg exited: %w", err)
	}
	return nil
}