How Youtube generate video previews?

brew install ffmpeg
brew install ffprobe

package main

import (
	"bytes"
	"fmt"
	"image"
	"image/draw"
	"image/jpeg"
	"os"
	"os/exec"
	"strconv"
)

// generatePreviewStripWithInterval creates a preview strip by taking frames every N seconds
func generatePreviewStripWithInterval(videoPath string, outputPath string, intervalSeconds float64) error {
	if intervalSeconds <= 0 {
		return fmt.Errorf("interval must be greater than 0 seconds")
	}

	// Check if input file exists
	if _, err := os.Stat(videoPath); os.IsNotExist(err) {
		return fmt.Errorf("input video file does not exist: %s", videoPath)
	}

	// First get video duration using ffprobe
	cmd := exec.Command("ffprobe",
		"-v", "error",
		"-show_entries", "format=duration",
		"-of", "default=noprint_wrappers=1:nokey=1",
		videoPath)
	durationBytes, err := cmd.Output()
	if err != nil {
		return fmt.Errorf("error getting video duration: %v", err)
	}

	duration, err := strconv.ParseFloat(string(durationBytes[:len(durationBytes)-1]), 64) // Remove trailing newline
	if err != nil {
		return fmt.Errorf("error parsing duration: %v", err)
	}

	if duration <= 0 {
		return fmt.Errorf("invalid video duration: %f", duration)
	}

	// Calculate how many frames we'll extract
	frameCount := int(duration/intervalSeconds) + 1
	if frameCount <= 0 {
		frameCount = 1
	}

	fmt.Printf("Video duration: %.2f seconds, taking frames every %.2f seconds (approximately %d frames)\n",
		duration, intervalSeconds, frameCount)

	// Extract frames at the specified interval
	frames := []image.Image{}
	for timestamp := 0.0; timestamp < duration; timestamp += intervalSeconds {
		cmd = exec.Command("ffmpeg",
			"-v", "error", // Suppress verbose output
			"-ss", fmt.Sprintf("%.2f", timestamp),
			"-i", videoPath,
			"-vframes", "1",
			"-f", "image2pipe",
			"-vcodec", "mjpeg", // Use mjpeg instead of jpeg for better compatibility
			"-q:v", "2", // High quality
			"-")
		output, err := cmd.Output()
		if err != nil {
			// Get stderr for better error info
			if exitError, ok := err.(*exec.ExitError); ok {
				return fmt.Errorf("error extracting frame at %.2f seconds: %v, stderr: %s", timestamp, err, string(exitError.Stderr))
			}
			return fmt.Errorf("error extracting frame at %.2f seconds: %v", timestamp, err)
		}

		frame, err := jpeg.Decode(bytes.NewReader(output))
		if err != nil {
			return fmt.Errorf("error decoding frame at %.2f seconds: %v", timestamp, err)
		}
		frames = append(frames, frame)
	}

	// Create a new image to hold all frames horizontally
	if len(frames) == 0 {
		return fmt.Errorf("no frames extracted")
	}

	frameWidth := frames[0].Bounds().Dx()
	frameHeight := frames[0].Bounds().Dy()
	stripWidth := frameWidth * len(frames)
	strip := image.NewRGBA(image.Rect(0, 0, stripWidth, frameHeight))

	// Place each frame side by side
	for i, frame := range frames {
		draw.Draw(strip,
			image.Rect(i*frameWidth, 0, (i+1)*frameWidth, frameHeight),
			frame,
			image.Point{0, 0},
			draw.Src)
	}

	// Save the final image
	outFile, err := os.Create(outputPath)
	if err != nil {
		return fmt.Errorf("error creating output file: %v", err)
	}
	defer outFile.Close()

	if err := jpeg.Encode(outFile, strip, &jpeg.Options{Quality: 90}); err != nil {
		return fmt.Errorf("error encoding final image: %v", err)
	}

	fmt.Printf("Successfully extracted %d frames\n", len(frames))
	return nil
}

func main() {
	// Check if input file exists, provide helpful message if not
	inputFile := "input.mp4"
	if _, err := os.Stat(inputFile); os.IsNotExist(err) {
		fmt.Printf("Input file '%s' does not exist.\n", inputFile)
		fmt.Printf("Please place a video file named 'input.mp4' in the current directory, or modify the code to use a different path.\n")
		fmt.Printf("Usage: Place your MP4 video file as 'input.mp4' and run this program.\n")
		os.Exit(1)
	}

	// Generate preview strip taking a frame every 5 seconds
	intervalSeconds := 5.0
	outputFile := "preview-strip.jpg"

	fmt.Printf("Generating preview strip from '%s', taking frames every %.1f seconds...\n", inputFile, intervalSeconds)

	err := generatePreviewStripWithInterval(inputFile, outputFile, intervalSeconds)
	if err != nil {
		fmt.Printf("Error generating preview strip: %v\n", err)
		os.Exit(1)
	}

	fmt.Printf("Successfully generated preview strip: %s\n", outputFile)
}

go run main.go

package main

import (
	"bufio"
	"bytes"
	"fmt"
	"image"
	"image/draw"
	"image/jpeg"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"strconv"
	"strings"
)

// SegmentInfo holds information about an HLS video segment
type SegmentInfo struct {
	Index       int
	Filename    string
	Duration    float64
	StartTime   float64
	EndTime     float64
}

// HLSManifest represents the parsed m3u8 file
type HLSManifest struct {
	TargetDuration float64
	TotalDuration  float64
	Segments       []SegmentInfo
}

// generateHLSSegments creates HLS segments using ffmpeg
func generateHLSSegments(videoPath string, segmentDuration int, outputDir string) (*HLSManifest, error) {
	// Create output directory
	if err := os.MkdirAll(outputDir, 0755); err != nil {
		return nil, fmt.Errorf("error creating output directory: %v", err)
	}

	playlistPath := filepath.Join(outputDir, "playlist.m3u8")
	segmentPattern := filepath.Join(outputDir, "segment_%03d.ts")

	fmt.Printf("🎬 Creating HLS segments with ffmpeg...\n")
	fmt.Printf("   Segment duration: %d seconds\n", segmentDuration)
	fmt.Printf("   Output directory: %s\n", outputDir)

	// Use ffmpeg to create HLS segments
	cmd := exec.Command("ffmpeg",
		"-i", videoPath,
		"-c:v", "libx264",        // Video codec
		"-c:a", "aac",            // Audio codec
		"-f", "hls",              // HLS format
		"-hls_time", fmt.Sprintf("%d", segmentDuration), // Segment duration
		"-hls_list_size", "0",    // Keep all segments in playlist
		"-hls_segment_filename", segmentPattern, // Segment filename pattern
		"-y",                     // Overwrite output files
		playlistPath)

	fmt.Printf("Running: %s\n", strings.Join(cmd.Args, " "))

	output, err := cmd.CombinedOutput()
	if err != nil {
		return nil, fmt.Errorf("error creating HLS segments: %v\nOutput: %s", err, string(output))
	}

	fmt.Printf("✅ HLS segmentation complete\n")

	// Parse the generated m3u8 file
	manifest, err := parseM3U8(playlistPath)
	if err != nil {
		return nil, fmt.Errorf("error parsing m3u8 file: %v", err)
	}

	// Update segment paths to be relative to output directory
	for i := range manifest.Segments {
		manifest.Segments[i].Filename = filepath.Join(outputDir, manifest.Segments[i].Filename)
	}

	fmt.Printf("📄 Parsed manifest: %d segments, total duration: %.2fs\n",
		len(manifest.Segments), manifest.TotalDuration)

	return manifest, nil
}

// parseM3U8 parses an m3u8 playlist file
func parseM3U8(playlistPath string) (*HLSManifest, error) {
	file, err := os.Open(playlistPath)
	if err != nil {
		return nil, fmt.Errorf("error opening playlist file: %v", err)
	}
	defer file.Close()

	manifest := &HLSManifest{
		Segments: []SegmentInfo{},
	}

	scanner := bufio.NewScanner(file)
	var currentDuration float64
	var currentStartTime float64
	segmentIndex := 0

	// Regex to extract duration from #EXTINF line
	extinfoRegex := regexp.MustCompile(`#EXTINF:([\d.]+),`)

	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())

		if strings.HasPrefix(line, "#EXT-X-TARGETDURATION:") {
			durationStr := strings.TrimPrefix(line, "#EXT-X-TARGETDURATION:")
			manifest.TargetDuration, _ = strconv.ParseFloat(durationStr, 64)
		} else if strings.HasPrefix(line, "#EXTINF:") {
			// Extract duration from EXTINF line
			matches := extinfoRegex.FindStringSubmatch(line)
			if len(matches) > 1 {
				currentDuration, _ = strconv.ParseFloat(matches[1], 64)
			}
		} else if strings.HasSuffix(line, ".ts") && !strings.HasPrefix(line, "#") {
			// This is a segment file
			segment := SegmentInfo{
				Index:     segmentIndex,
				Filename:  line,
				Duration:  currentDuration,
				StartTime: currentStartTime,
				EndTime:   currentStartTime + currentDuration,
			}
			manifest.Segments = append(manifest.Segments, segment)
			manifest.TotalDuration += currentDuration
			currentStartTime += currentDuration
			segmentIndex++
		}
	}

	if err := scanner.Err(); err != nil {
		return nil, fmt.Errorf("error reading playlist file: %v", err)
	}

	return manifest, nil
}

// generateThumbnailStripFromSegment creates a thumbnail strip from an HLS segment
func generateThumbnailStripFromSegment(segmentPath string, segment SegmentInfo, outputPath string, frameInterval float64) error {
	if frameInterval <= 0 {
		return fmt.Errorf("frame interval must be greater than 0 seconds")
	}

	// Check if segment file exists
	if _, err := os.Stat(segmentPath); os.IsNotExist(err) {
		return fmt.Errorf("segment file does not exist: %s", segmentPath)
	}

	// Calculate how many frames we'll extract from this segment
	frameCount := int(segment.Duration/frameInterval) + 1
	if frameCount <= 0 {
		frameCount = 1
	}

	fmt.Printf("Processing segment %d (%s): %.2fs duration, ~%d frames every %.2fs\n",
		segment.Index, filepath.Base(segmentPath), segment.Duration, frameCount, frameInterval)

	// Extract frames at the specified interval from the segment
	frames := []image.Image{}
	maxTimestamp := segment.Duration - 1.0 // Leave 1 second buffer at the end

	for timestamp := 0.0; timestamp < maxTimestamp; timestamp += frameInterval {
		cmd := exec.Command("ffmpeg",
			"-v", "error", // Suppress verbose output
			"-ss", fmt.Sprintf("%.2f", timestamp),
			"-i", segmentPath,
			"-vframes", "1",
			"-f", "image2pipe",
			"-pix_fmt", "yuvj420p", // Force compatible pixel format
			"-vcodec", "mjpeg",      // Use mjpeg for better compatibility
			"-q:v", "3",             // Good quality but more forgiving
			"-an",                   // No audio
			"-")

		output, err := cmd.Output()
		if err != nil {
			// Log the error but continue processing - some frames might fail near segment boundaries
			fmt.Printf("   Warning: Could not extract frame at %.2fs from segment %d, continuing...\n",
				timestamp, segment.Index)
			continue
		}

		frame, err := jpeg.Decode(bytes.NewReader(output))
		if err != nil {
			fmt.Printf("   Warning: Could not decode frame at %.2fs from segment %d: %v\n",
				timestamp, segment.Index, err)
			continue
		}
		frames = append(frames, frame)
	}

	if len(frames) == 0 {
		return fmt.Errorf("no frames extracted from segment %d", segment.Index)
	}

	fmt.Printf("   Successfully extracted %d frames from segment %d\n", len(frames), segment.Index)

	// Create a new image to hold all frames horizontally
	frameWidth := frames[0].Bounds().Dx()
	frameHeight := frames[0].Bounds().Dy()
	stripWidth := frameWidth * len(frames)
	strip := image.NewRGBA(image.Rect(0, 0, stripWidth, frameHeight))

	// Place each frame side by side
	for i, frame := range frames {
		draw.Draw(strip,
			image.Rect(i*frameWidth, 0, (i+1)*frameWidth, frameHeight),
			frame,
			image.Point{0, 0},
			draw.Src)
	}

	// Save the segment thumbnail strip
	outFile, err := os.Create(outputPath)
	if err != nil {
		return fmt.Errorf("error creating output file: %v", err)
	}
	defer outFile.Close()

	if err := jpeg.Encode(outFile, strip, &jpeg.Options{Quality: 90}); err != nil {
		return fmt.Errorf("error encoding final image: %v", err)
	}

	fmt.Printf("✓ Generated thumbnail strip for segment %d: %s (%d frames)\n",
		segment.Index, outputPath, len(frames))
	return nil
}

// generateHLSBasedPreviewStrips creates thumbnail strips from HLS segments
func generateHLSBasedPreviewStrips(videoPath string, segmentDuration int, frameInterval float64) error {
	// Check if input file exists
	if _, err := os.Stat(videoPath); os.IsNotExist(err) {
		return fmt.Errorf("input video file does not exist: %s", videoPath)
	}

	// Create HLS segments
	hlsOutputDir := "hls_segments"
	manifest, err := generateHLSSegments(videoPath, segmentDuration, hlsOutputDir)
	if err != nil {
		return fmt.Errorf("error generating HLS segments: %v", err)
	}

	// Create output directory for thumbnails
	thumbnailsDir := "thumbnails"
	if err := os.MkdirAll(thumbnailsDir, 0755); err != nil {
		return fmt.Errorf("error creating thumbnails directory: %v", err)
	}

	// Generate thumbnail strips for each segment
	for _, segment := range manifest.Segments {
		thumbnailPath := fmt.Sprintf("%s/segment-%d-thumbnails.jpg", thumbnailsDir, segment.Index)
		err := generateThumbnailStripFromSegment(segment.Filename, segment, thumbnailPath, frameInterval)
		if err != nil {
			return fmt.Errorf("error generating thumbnails for segment %d: %v", segment.Index, err)
		}
	}

	// Create a metadata file with segment information
	metadataPath := fmt.Sprintf("%s/segments.txt", thumbnailsDir)
	metadataFile, err := os.Create(metadataPath)
	if err != nil {
		return fmt.Errorf("error creating metadata file: %v", err)
	}
	defer metadataFile.Close()

	fmt.Fprintf(metadataFile, "total_duration=%.2f\n", manifest.TotalDuration)
	fmt.Fprintf(metadataFile, "segment_duration=%d\n", segmentDuration)
	fmt.Fprintf(metadataFile, "frame_interval=%.2f\n", frameInterval)
	fmt.Fprintf(metadataFile, "segment_count=%d\n", len(manifest.Segments))
	fmt.Fprintf(metadataFile, "hls_playlist=%s/playlist.m3u8\n", hlsOutputDir)

	for _, segment := range manifest.Segments {
		fmt.Fprintf(metadataFile, "segment_%d=%.2f-%.2f\n", segment.Index, segment.StartTime, segment.EndTime)
	}

	// Copy the HLS playlist to thumbnails directory for reference
	playlistSrc := filepath.Join(hlsOutputDir, "playlist.m3u8")
	playlistDst := filepath.Join(thumbnailsDir, "playlist.m3u8")
	if err := copyFile(playlistSrc, playlistDst); err != nil {
		fmt.Printf("Warning: Could not copy playlist file: %v\n", err)
	}

	fmt.Printf("\n✅ Successfully generated %d thumbnail strips from HLS segments\n", len(manifest.Segments))
	fmt.Printf("📁 HLS segments: %s/\n", hlsOutputDir)
	fmt.Printf("📁 Thumbnails: %s/\n", thumbnailsDir)
	fmt.Printf("📄 Metadata: %s\n", metadataPath)
	fmt.Printf("📺 HLS Playlist: %s\n", playlistSrc)

	return nil
}

// copyFile copies a file from src to dst
func copyFile(src, dst string) error {
	input, err := os.ReadFile(src)
	if err != nil {
		return err
	}
	return os.WriteFile(dst, input, 0644)
}

func main() {
	// Check if input file exists
	inputFile := "input.mp4"
	if _, err := os.Stat(inputFile); os.IsNotExist(err) {
		fmt.Printf("Input file '%s' does not exist.\n", inputFile)
		fmt.Printf("Please place a video file named 'input.mp4' in the current directory.\n")
		os.Exit(1)
	}

	// Configuration
	segmentDuration := 30  // Each HLS segment will be 30 seconds
	frameInterval := 2.0   // Take a frame every 2 seconds within each segment

	fmt.Printf("🎬 Generating HLS-based preview thumbnails from '%s'\n", inputFile)
	fmt.Printf("📊 Configuration:\n")
	fmt.Printf("   - HLS segment duration: %d seconds\n", segmentDuration)
	fmt.Printf("   - Frame interval: %.1f seconds\n", frameInterval)
	fmt.Printf("\n")

	err := generateHLSBasedPreviewStrips(inputFile, segmentDuration, frameInterval)
	if err != nil {
		fmt.Printf("❌ Error generating HLS-based preview strips: %v\n", err)
		os.Exit(1)
	}

	fmt.Printf("\n🎉 Done! You now have:\n")
	fmt.Printf("   📺 HLS video segments (.ts files) for streaming\n")
	fmt.Printf("   🖼️  Thumbnail strips for video previews\n")
	fmt.Printf("   📄 m3u8 playlist for video playback\n")
}

go run segment.go

package main

import (
	"bufio"
	"bytes"
	"fmt"
	"image"
	"image/draw"
	"image/jpeg"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"strconv"
	"strings"
)

// SegmentInfo holds information about an HLS video segment
type SegmentInfo struct {
	Index       int
	Filename    string
	Duration    float64
	StartTime   float64
	EndTime     float64
}

// HLSManifest represents the parsed m3u8 file
type HLSManifest struct {
	TargetDuration float64
	TotalDuration  float64
	Segments       []SegmentInfo
}

// ThumbnailConfig represents a configuration for thumbnail generation from existing segments
type ThumbnailConfig struct {
	FrameInterval    float64 // Interval between frames in seconds
	LogicalGrouping  int     // How many segments to group together (1=no grouping, 3=group 3 segments)
	OutputSuffix     string  // Suffix for output directories and files
	Description      string  // Description of the configuration
}

// generateHLSSegments creates HLS segments using ffmpeg
func generateHLSSegments(videoPath string, segmentDuration int, outputDir string) (*HLSManifest, error) {
	// Create output directory
	if err := os.MkdirAll(outputDir, 0755); err != nil {
		return nil, fmt.Errorf("error creating output directory: %v", err)
	}

	playlistPath := filepath.Join(outputDir, "playlist.m3u8")
	segmentPattern := filepath.Join(outputDir, "segment_%03d.ts")

	fmt.Printf("🎬 Creating HLS segments with ffmpeg...\n")
	fmt.Printf("   Segment duration: %d seconds\n", segmentDuration)
	fmt.Printf("   Output directory: %s\n", outputDir)

	// Use ffmpeg to create HLS segments
	cmd := exec.Command("ffmpeg",
		"-i", videoPath,
		"-c:v", "libx264",        // Video codec
		"-c:a", "aac",            // Audio codec
		"-f", "hls",              // HLS format
		"-hls_time", fmt.Sprintf("%d", segmentDuration), // Segment duration
		"-hls_list_size", "0",    // Keep all segments in playlist
		"-hls_segment_filename", segmentPattern, // Segment filename pattern
		"-y",                     // Overwrite output files
		playlistPath)

	fmt.Printf("Running: %s\n", strings.Join(cmd.Args, " "))

	output, err := cmd.CombinedOutput()
	if err != nil {
		return nil, fmt.Errorf("error creating HLS segments: %v\nOutput: %s", err, string(output))
	}

	fmt.Printf("✅ HLS segmentation complete\n")

	// Parse the generated m3u8 file
	manifest, err := parseM3U8(playlistPath)
	if err != nil {
		return nil, fmt.Errorf("error parsing m3u8 file: %v", err)
	}

	// Note: segment paths are kept as just filenames (e.g., "segment_000.ts")
	// The hlsDir will be prepended when accessing them later

	fmt.Printf("📄 Parsed manifest: %d segments, total duration: %.2fs\n",
		len(manifest.Segments), manifest.TotalDuration)

	return manifest, nil
}

// parseM3U8 parses an m3u8 playlist file
func parseM3U8(playlistPath string) (*HLSManifest, error) {
	file, err := os.Open(playlistPath)
	if err != nil {
		return nil, fmt.Errorf("error opening playlist file: %v", err)
	}
	defer file.Close()

	manifest := &HLSManifest{
		Segments: []SegmentInfo{},
	}

	scanner := bufio.NewScanner(file)
	var currentDuration float64
	var currentStartTime float64
	segmentIndex := 0

	// Regex to extract duration from #EXTINF line
	extinfoRegex := regexp.MustCompile(`#EXTINF:([\d.]+),`)

	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())

		if strings.HasPrefix(line, "#EXT-X-TARGETDURATION:") {
			durationStr := strings.TrimPrefix(line, "#EXT-X-TARGETDURATION:")
			manifest.TargetDuration, _ = strconv.ParseFloat(durationStr, 64)
		} else if strings.HasPrefix(line, "#EXTINF:") {
			// Extract duration from EXTINF line
			matches := extinfoRegex.FindStringSubmatch(line)
			if len(matches) > 1 {
				currentDuration, _ = strconv.ParseFloat(matches[1], 64)
			}
		} else if strings.HasSuffix(line, ".ts") && !strings.HasPrefix(line, "#") {
			// This is a segment file
			segment := SegmentInfo{
				Index:     segmentIndex,
				Filename:  line,
				Duration:  currentDuration,
				StartTime: currentStartTime,
				EndTime:   currentStartTime + currentDuration,
			}
			manifest.Segments = append(manifest.Segments, segment)
			manifest.TotalDuration += currentDuration
			currentStartTime += currentDuration
			segmentIndex++
		}
	}

	if err := scanner.Err(); err != nil {
		return nil, fmt.Errorf("error reading playlist file: %v", err)
	}

	return manifest, nil
}

// generateOptimizedPreviewConfigurations creates one set of HLS segments and multiple thumbnail configurations
func generateOptimizedPreviewConfigurations(videoPath string) error {
	// Check if input file exists
	if _, err := os.Stat(videoPath); os.IsNotExist(err) {
		return fmt.Errorf("input video file does not exist: %s", videoPath)
	}

	fmt.Printf("🎬 Generating optimized HLS-based preview system from '%s'\n", videoPath)
	fmt.Printf("🚀 Efficiency: One segmentation pass, multiple thumbnail configurations\n")
	fmt.Printf("💡 Benefits:\n")
	fmt.Printf("   ⚡ Faster processing (single HLS segmentation)\n")
	fmt.Printf("   💾 Less storage (reuse same .ts files)\n")
	fmt.Printf("   🎯 Multiple preview granularities\n")
	fmt.Printf("   🎬 Better accuracy (10s segments vs 30s)\n")
	fmt.Printf("   💫 More precise hover previews\n")
	fmt.Printf("\n")

	// Step 1: Generate one set of fine-grained HLS segments (10s for better accuracy)
	segmentDuration := 10
	hlsOutputDir := "hls_segments"

	fmt.Printf("📹 Step 1: Creating HLS segments (%ds each)...\n", segmentDuration)
	manifest, err := generateHLSSegments(videoPath, segmentDuration, hlsOutputDir)
	if err != nil {
		return fmt.Errorf("error generating HLS segments: %v", err)
	}
	fmt.Printf("✅ Generated %d HLS segments, total duration: %.2fs\n\n", len(manifest.Segments), manifest.TotalDuration)

	// Step 2: Define multiple thumbnail configurations using the same segments
	configs := []ThumbnailConfig{
		{
			FrameInterval:   2.0,
			LogicalGrouping: 1,
			OutputSuffix:    "detailed",
			Description:     "Detailed (2s intervals, individual 10s segments)",
		},
		{
			FrameInterval:   4.0,
			LogicalGrouping: 3,
			OutputSuffix:    "balanced",
			Description:     "Balanced (4s intervals, 30s logical groups)",
		},
		{
			FrameInterval:   6.0,
			LogicalGrouping: 6,
			OutputSuffix:    "overview",
			Description:     "Overview (6s intervals, 60s logical groups)",
		},
	}

	fmt.Printf("🖼️ Step 2: Generating thumbnail configurations...\n")
	for i, config := range configs {
		fmt.Printf("   %d. %s\n", i+1, config.Description)
	}
	fmt.Printf("\n")

	// Step 3: Generate thumbnail strips for each configuration
	for _, config := range configs {
		fmt.Printf("🔄 Processing: %s\n", config.Description)

		err := generateThumbnailsFromExistingSegments(manifest, hlsOutputDir, config)
		if err != nil {
			return fmt.Errorf("error generating thumbnails for config %s: %v", config.OutputSuffix, err)
		}

		fmt.Printf("✅ Completed: %s\n\n", config.Description)
	}

	fmt.Printf("🎉 Optimized preview system completed!\n")
	fmt.Printf("📁 Generated:\n")
	fmt.Printf("   - %s/ (single set of HLS segments)\n", hlsOutputDir)
	for _, config := range configs {
		fmt.Printf("   - thumbnails_%s/ (%s)\n", config.OutputSuffix, config.Description)
	}

	return nil
}

// generateThumbnailsFromExistingSegments creates thumbnail strips from existing HLS segments
func generateThumbnailsFromExistingSegments(manifest *HLSManifest, hlsDir string, config ThumbnailConfig) error {
	// Create output directory for thumbnails
	thumbnailsDir := fmt.Sprintf("thumbnails_%s", config.OutputSuffix)
	if err := os.MkdirAll(thumbnailsDir, 0755); err != nil {
		return fmt.Errorf("error creating thumbnails directory: %v", err)
	}

	// Group segments according to configuration
	segmentGroups := groupSegments(manifest.Segments, config.LogicalGrouping)

	fmt.Printf("   Grouped %d segments into %d logical units\n", len(manifest.Segments), len(segmentGroups))

	// Generate thumbnail strips for each group
	for groupIndex, group := range segmentGroups {
		var thumbnailPath string
		var err error

		if config.LogicalGrouping == 1 {
			// Single segment - use existing function
			segment := group[0]
			segmentPath := filepath.Join(hlsDir, segment.Filename)
			thumbnailPath = fmt.Sprintf("%s/segment-%d-thumbnails.jpg", thumbnailsDir, segment.Index)
			err = generateThumbnailStripFromSegment(segmentPath, segment, thumbnailPath, config.FrameInterval)
		} else {
			// Multiple segments - create combined thumbnail strip
			thumbnailPath = fmt.Sprintf("%s/segment-group-%d-thumbnails.jpg", thumbnailsDir, groupIndex)
			err = generateCombinedThumbnailStrip(hlsDir, group, thumbnailPath, config.FrameInterval)
		}

		if err != nil {
			return fmt.Errorf("error generating thumbnails for group %d: %v", groupIndex, err)
		}
	}

	// Create metadata file
	return createThumbnailMetadata(thumbnailsDir, manifest, config, segmentGroups)
}

// groupSegments groups segments according to the logical grouping configuration
func groupSegments(segments []SegmentInfo, groupSize int) [][]SegmentInfo {
	if groupSize <= 1 {
		// No grouping - each segment is its own group
		groups := make([][]SegmentInfo, len(segments))
		for i, segment := range segments {
			groups[i] = []SegmentInfo{segment}
		}
		return groups
	}

	// Group segments
	var groups [][]SegmentInfo
	for i := 0; i < len(segments); i += groupSize {
		end := i + groupSize
		if end > len(segments) {
			end = len(segments)
		}
		groups = append(groups, segments[i:end])
	}

	return groups
}

// generateThumbnailStripFromSegment creates a thumbnail strip from an HLS segment
func generateThumbnailStripFromSegment(segmentPath string, segment SegmentInfo, outputPath string, frameInterval float64) error {
	if frameInterval <= 0 {
		return fmt.Errorf("frame interval must be greater than 0 seconds")
	}

	// Check if segment file exists
	if _, err := os.Stat(segmentPath); os.IsNotExist(err) {
		return fmt.Errorf("segment file does not exist: %s", segmentPath)
	}

	fmt.Printf("   Processing segment %d (%s): %.2fs duration, %.2fs intervals\n",
		segment.Index, filepath.Base(segmentPath), segment.Duration, frameInterval)

	// Extract frames at the specified interval from the segment
	frames := []image.Image{}
	maxTimestamp := segment.Duration - 1.0 // Leave 1 second buffer at the end

	for timestamp := 0.0; timestamp < maxTimestamp; timestamp += frameInterval {
		cmd := exec.Command("ffmpeg",
			"-v", "error",
			"-ss", fmt.Sprintf("%.2f", timestamp),
			"-i", segmentPath,
			"-vframes", "1",
			"-f", "image2pipe",
			"-pix_fmt", "yuvj420p",
			"-vcodec", "mjpeg",
			"-q:v", "3",
			"-an",
			"-")

		output, err := cmd.Output()
		if err != nil {
			continue // Skip failed frames
		}

		frame, err := jpeg.Decode(bytes.NewReader(output))
		if err != nil {
			continue // Skip failed frames
		}
		frames = append(frames, frame)
	}

	if len(frames) == 0 {
		return fmt.Errorf("no frames extracted from segment %d", segment.Index)
	}

	// Create a new image to hold all frames horizontally
	frameWidth := frames[0].Bounds().Dx()
	frameHeight := frames[0].Bounds().Dy()
	stripWidth := frameWidth * len(frames)
	strip := image.NewRGBA(image.Rect(0, 0, stripWidth, frameHeight))

	// Place each frame side by side
	for i, frame := range frames {
		draw.Draw(strip,
			image.Rect(i*frameWidth, 0, (i+1)*frameWidth, frameHeight),
			frame,
			image.Point{0, 0},
			draw.Src)
	}

	// Save the segment thumbnail strip
	outFile, err := os.Create(outputPath)
	if err != nil {
		return fmt.Errorf("error creating output file: %v", err)
	}
	defer outFile.Close()

	if err := jpeg.Encode(outFile, strip, &jpeg.Options{Quality: 90}); err != nil {
		return fmt.Errorf("error encoding final image: %v", err)
	}

	fmt.Printf("   ✓ Generated strip: %s (%d frames)\n", outputPath, len(frames))
	return nil
}

// generateCombinedThumbnailStrip creates a thumbnail strip from multiple segments
func generateCombinedThumbnailStrip(hlsDir string, segments []SegmentInfo, outputPath string, frameInterval float64) error {
	fmt.Printf("   Creating combined strip from %d segments: ", len(segments))
	for i, seg := range segments {
		if i > 0 {
			fmt.Printf(", ")
		}
		fmt.Printf("%d", seg.Index)
	}
	fmt.Printf("\n")

	var allFrames []image.Image

	// Extract frames from each segment in the group
	for _, segment := range segments {
		segmentPath := filepath.Join(hlsDir, segment.Filename)

		// Extract frames from this segment
		maxTimestamp := segment.Duration - 1.0
		for timestamp := 0.0; timestamp < maxTimestamp; timestamp += frameInterval {
			cmd := exec.Command("ffmpeg",
				"-v", "error",
				"-ss", fmt.Sprintf("%.2f", timestamp),
				"-i", segmentPath,
				"-vframes", "1",
				"-f", "image2pipe",
				"-pix_fmt", "yuvj420p",
				"-vcodec", "mjpeg",
				"-q:v", "3",
				"-an",
				"-")

			output, err := cmd.Output()
			if err != nil {
				continue // Skip failed frames
			}

			frame, err := jpeg.Decode(bytes.NewReader(output))
			if err != nil {
				continue // Skip failed frames
			}

			allFrames = append(allFrames, frame)
		}
	}

	if len(allFrames) == 0 {
		return fmt.Errorf("no frames extracted from segment group")
	}

	// Create combined strip
	frameWidth := allFrames[0].Bounds().Dx()
	frameHeight := allFrames[0].Bounds().Dy()
	stripWidth := frameWidth * len(allFrames)
	strip := image.NewRGBA(image.Rect(0, 0, stripWidth, frameHeight))

	// Place all frames side by side
	for i, frame := range allFrames {
		draw.Draw(strip,
			image.Rect(i*frameWidth, 0, (i+1)*frameWidth, frameHeight),
			frame,
			image.Point{0, 0},
			draw.Src)
	}

	// Save the combined thumbnail strip
	outFile, err := os.Create(outputPath)
	if err != nil {
		return fmt.Errorf("error creating output file: %v", err)
	}
	defer outFile.Close()

	if err := jpeg.Encode(outFile, strip, &jpeg.Options{Quality: 90}); err != nil {
		return fmt.Errorf("error encoding final image: %v", err)
	}

	fmt.Printf("   ✓ Generated combined strip: %s (%d frames)\n", outputPath, len(allFrames))
	return nil
}

// createThumbnailMetadata creates metadata file for the thumbnail configuration
func createThumbnailMetadata(thumbnailsDir string, manifest *HLSManifest, config ThumbnailConfig, segmentGroups [][]SegmentInfo) error {
	metadataPath := filepath.Join(thumbnailsDir, "segments.txt")
	metadataFile, err := os.Create(metadataPath)
	if err != nil {
		return fmt.Errorf("error creating metadata file: %v", err)
	}
	defer metadataFile.Close()

	fmt.Fprintf(metadataFile, "total_duration=%.2f\n", manifest.TotalDuration)
	fmt.Fprintf(metadataFile, "frame_interval=%.2f\n", config.FrameInterval)
	fmt.Fprintf(metadataFile, "logical_grouping=%d\n", config.LogicalGrouping)
	fmt.Fprintf(metadataFile, "segment_count=%d\n", len(segmentGroups))
	fmt.Fprintf(metadataFile, "output_suffix=%s\n", config.OutputSuffix)
	fmt.Fprintf(metadataFile, "description=%s\n", config.Description)

	// Calculate timing for logical groups
	currentTime := 0.0
	for i, group := range segmentGroups {
		groupDuration := 0.0
		for _, segment := range group {
			groupDuration += segment.Duration
		}
		fmt.Fprintf(metadataFile, "segment_%d=%.2f-%.2f\n", i, currentTime, currentTime+groupDuration)
		currentTime += groupDuration
	}

	return nil
}

// copyFile copies a file from src to dst
func copyFile(src, dst string) error {
	input, err := os.ReadFile(src)
	if err != nil {
		return err
	}
	return os.WriteFile(dst, input, 0644)
}

func main() {
	// Check if input file exists
	inputFile := "input.mp4"
	if _, err := os.Stat(inputFile); os.IsNotExist(err) {
		fmt.Printf("Input file '%s' does not exist.\n", inputFile)
		fmt.Printf("Please place a video file named 'input.mp4' in the current directory.\n")
		os.Exit(1)
	}

	fmt.Printf("🎬 Generating optimized HLS-based preview system from '%s'\n", inputFile)
	fmt.Printf("🚀 Efficiency: One segmentation pass, multiple thumbnail configurations\n")
	fmt.Printf("💡 Benefits:\n")
	fmt.Printf("   ⚡ Faster processing (single HLS segmentation)\n")
	fmt.Printf("   💾 Less storage (reuse same .ts files)\n")
	fmt.Printf("   🎯 Multiple preview granularities\n")
	fmt.Printf("   🎬 Better accuracy (10s segments vs 30s)\n")
	fmt.Printf("   💫 More precise hover previews\n")
	fmt.Printf("\n")

	err := generateOptimizedPreviewConfigurations(inputFile)
	if err != nil {
		fmt.Printf("❌ Error generating optimized preview system: %v\n", err)
		os.Exit(1)
	}

	fmt.Printf("\n🎉 Success! Optimized preview system ready:\n")
	fmt.Printf("   📺 One set of HLS segments (reusable for streaming)\n")
	fmt.Printf("   🖼️  Three thumbnail configurations (detailed, balanced, overview)\n")
	fmt.Printf("   ⚡ ~3x faster than generating separate segment sets\n")
}

go run main.go

- hls_segments/ ==> HLS segments
  - playlist.m3u8
  - segment_000.ts
  - segment_001.ts
  - segment_002.ts
  - ...
- thumbnails_detailed/ ==> Thumbnail preview images for detailed or slow scrubbing
  - segments.txt
  - segment-0-thumbnails.jpg
  - segment-1-thumbnails.jpg
  - segment-2-thumbnails.jpg
  - ...
- thumbnails_balanced/ ==> Thumbnail preview images for balanced or medium scrubbing
  - segments.txt
  - segment-0-thumbnails.jpg
  - segment-1-thumbnails.jpg
  - segment-2-thumbnails.jpg
  - ...
- thumbnails_overview/ ==> Thumbnail preview images for overview or fast scrubbing
  - segments.txt
  - segment-0-thumbnails.jpg
  - segment-1-thumbnails.jpg
  - segment-2-thumbnails.jpg
  - ...