Video Streaming in Go: Range Request HTTP, Segmenti HLS e 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 gestisce header Range, risposte 206, ETag e If-Modified-Since.
		// Il path dopo /video/ mappa al filesystem.
		http.ServeFile(w, r, "videos/"+r.URL.Path[len("/video/"):])
	})

	log.Println("in ascolto su :8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

package rangeserver

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

// ServeRange serve il file in path con pieno supporto delle range request.
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
	}

	// Parsa "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 transcodifica inputPath in segmenti HLS in outputDir.
// Blocca finche FFmpeg non finisce (caso d'uso VOD).
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",         // Copia gli stream senza ri-encodare (veloce, nessuna perdita di qualita)
		"-start_number", "0",
		"-hls_time", "6",          // Durata target del segmento in secondi
		"-hls_list_size", "0",     // 0 = mantieni tutti i segmenti nel manifest (VOD)
		"-hls_segment_filename", segmentPattern,
		"-f", "hls",
		manifestPath,
	)

	// Cattura stderr per il debug. FFmpeg scrive il suo log li.
	cmd.Stderr = os.Stderr

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

package hls

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

// Handler serve file HLS da dir.
func Handler(dir string) http.Handler {
	fs := http.FileServer(http.Dir(dir))

	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// Gli header CORS sono necessari per la riproduzione HLS da un'origine diversa
		// (es. un player video.js su una porta diversa).
		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
		}

		// Imposta i tipi MIME corretti.
		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") // Il manifest cambia durante il live
		case ".ts":
			w.Header().Set("Content-Type", "video/mp2t")
			w.Header().Set("Cache-Control", "public, max-age=3600") // I segmenti sono immutabili
		}

		fs.ServeHTTP(w, r)
	})
}

package main

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

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

func main() {
	segDir := flag.String("dir", "./segments", "directory segmenti HLS")
	addr := flag.String("addr", ":8080", "indirizzo di ascolto")
	flag.Parse()

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

	log.Printf("HLS server su %s, servendo da %s", *addr, *segDir)
	log.Fatal(http.ListenAndServe(*addr, mux))
}

package hls

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

// StartLive avvia uno stream HLS live da inputSource in outputDir.
// Rispetta ctx per la cancellazione graceful.
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",                          // Leggi l'input al framerate nativo (per input da file)
		"-i", inputSource,              // es. "rtmp://localhost/live/stream" o "/dev/video0"
		"-c:v", "libx264",
		"-preset", "veryfast",          // Bassa CPU, bassa latenza
		"-tune", "zerolatency",
		"-c:a", "aac",
		"-hls_time", "2",               // Segmenti brevi per bassa latenza
		"-hls_list_size", "5",          // Mantieni 5 segmenti nel manifest (sliding window)
		"-hls_flags", "delete_segments+append_list",
		"-hls_segment_filename", segmentPattern,
		"-f", "hls",
		manifestPath,
	)

	cmd.Stderr = os.Stderr

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

	// Attendi che FFmpeg termini (la cancellazione del context lo ferma via CommandContext).
	if err := cmd.Wait(); err != nil && ctx.Err() == nil {
		return fmt.Errorf("ffmpeg exited: %w", err)
	}
	return nil
}