Transcoding and Nip71 update

2025-08-21 19:32:26 -07:00 · 2025-08-21 19:32:26 -07:00 · 76979d055b
commit 76979d055b
parent 03c2af56ab
19 changed files with 1979 additions and 64 deletions
--- a/.claude/settings.local.json
+++ b/.claude/settings.local.json
@ -8,7 +8,8 @@
      "Bash(grep:*)",
      "Bash(go run:*)",
      "Bash(go build:*)",
-      "Bash(find:*)"
+      "Bash(find:*)",
+      "WebFetch(domain:raw.githubusercontent.com)"
    ],
    "deny": [],
    "ask": []
--- a/README.md
+++ b/README.md
@ -1,6 +1,6 @@
 # BitTorrent Gateway

-A comprehensive unified content distribution system that seamlessly integrates BitTorrent protocol, WebSeed technology, DHT peer discovery, built-in tracker, and Nostr announcements. This gateway provides intelligent content distribution by automatically selecting the optimal delivery method based on file size and network conditions.
+A comprehensive unified content distribution system that seamlessly integrates BitTorrent protocol, WebSeed technology, DHT peer discovery, built-in tracker, video transcoding, and Nostr announcements. This gateway provides intelligent content distribution by automatically selecting the optimal delivery method based on file size and network conditions, with automatic video transcoding for web-compatible streaming.

 ## Architecture Overview

@ -32,12 +32,21 @@ The BitTorrent Gateway operates as a unified system with multiple specialized co
 - P2P coordination and peer ranking
 - Client compatibility optimizations for qBittorrent, Transmission, WebTorrent, Deluge, uTorrent

+**5. Video Transcoding Engine**
+- Automatic H.264/AAC conversion for web compatibility
+- Smart serving: transcoded versions when ready, originals otherwise
+- Background processing with priority queuing
+- FFmpeg integration with progress tracking
+- Multiple quality profiles and format support
+
 ### Smart Storage Strategy

-The system uses an intelligent dual-storage approach:
+The system uses an intelligent dual-storage approach with video optimization:

 - **Small Files (<100MB)**: Stored directly as blobs using Blossom protocol
 - **Large Files (≥100MB)**: Automatically chunked into 2MB pieces, stored as torrents with WebSeed fallback
+- **Video Files**: Automatically queued for H.264/AAC transcoding to web-compatible MP4 format
+- **Smart Serving**: Transcoded versions served when ready, original chunks as fallback

 ### P2P Coordination System

@ -54,6 +63,7 @@ A sophisticated P2P coordinator manages all networking components:

 - Go 1.21 or later
 - SQLite3
+- FFmpeg (for video transcoding, optional)
 - 10MB+ available storage
 - Linux/macOS/Windows

@ -274,6 +284,14 @@ nostr:
  relays:
    - "wss://freelay.sovbit.host"

+# Video transcoding configuration
+transcoding:
+  enabled: true                # Enable/disable transcoding (requires ffmpeg)
+  concurrent_jobs: 2           # Number of parallel transcoding jobs
+  work_dir: "./data/transcoded" # Directory for transcoded files
+  auto_transcode: true         # Automatically transcode uploaded videos
+  min_file_size: 50MB          # Don't transcode files smaller than this
+
 # Admin configuration
 admin:
  enabled: true
@ -333,6 +351,10 @@ curl http://localhost:9877/api/torrent/[hash] -o file.torrent

 # Stream video (HLS)
 curl http://localhost:9877/api/stream/[hash]/playlist.m3u8
+
+# Check transcoding status (requires auth)
+curl http://localhost:9877/api/users/me/files/[hash]/transcoding-status \
+  -H "Authorization: Bearer [session_token]"
 ```

 ### User Management
@ -386,6 +408,7 @@ When a file is uploaded, the gateway creates a Nostr event like this:
    ["blossom", "sha256_blob_hash"],
    ["stream", "https://gateway.example.com/api/stream/hash"],
    ["hls", "https://gateway.example.com/api/stream/hash/playlist.m3u8"],
+    ["transcoded", "https://gateway.example.com/api/stream/hash?transcoded=true"],
    ["duration", "3600"],
    ["video", "1920x1080", "30fps", "h264"],
    ["m", "video/mp4"],
--- a/TECHNICAL_OVERVIEW.md
+++ b/TECHNICAL_OVERVIEW.md
@ -19,6 +19,7 @@ The BitTorrent Gateway is built as a unified system with multiple specialized co
 │ • WebSeed           │ • Nostr Protocol    │ • DHT Protocol  │
 │ • Rate Limiting     │ • Content Address   │ • Bootstrap     │
 │ • Abuse Prevention  │ • LRU Caching       │ • Announce      │
+│ • Video Transcoding │                     │                 │
 └─────────────────────┴─────────────────────┴─────────────────┘
                                │
                   ┌────────────┴────────────┐
@ -52,6 +53,7 @@ The BitTorrent Gateway is built as a unified system with multiple specialized co
 - Smart proxy for reassembling chunked content
 - Advanced LRU caching system
 - Rate limiting and abuse prevention
+- Integrated video transcoding engine

 **Implementation Details**:
 - Built with Gorilla Mux router
@ -121,6 +123,23 @@ The BitTorrent Gateway is built as a unified system with multiple specialized co
 - Performance-based peer ranking
 - Automatic failover and redundancy

+#### 6. Video Transcoding Engine (internal/transcoding/)
+
+**Purpose**: Automatic video conversion for web compatibility
+**Key Features**:
+- H.264/AAC MP4 conversion using FFmpeg
+- Background processing with priority queuing
+- Smart serving (transcoded when ready, original as fallback)
+- Progress tracking and status API endpoints
+- Configurable quality profiles and resource limits
+
+**Implementation Details**:
+- Queue-based job processing with worker pools
+- Database tracking of transcoding status and progress
+- File reconstruction for chunked torrents
+- Intelligent priority system based on file size
+- Error handling and retry mechanisms
+
 ## Storage Architecture

 ### Intelligent Storage Strategy
@ -128,21 +147,30 @@ The BitTorrent Gateway is built as a unified system with multiple specialized co
 The system uses a dual-strategy approach based on file size:

 ```
-File Upload → Size Analysis → Storage Decision
-                    │
-            ┌───────┴───────┐
+File Upload → Size Analysis → Storage Decision → Video Processing
                    │                              │
-       < 100MB         ≥ 100MB
+            ┌───────┴───────┐                     │
+            │               │                     │
+       < 100MB         ≥ 100MB                   │
+            │               │                     │
+    ┌───────▼───────┐  ┌────▼────┐               │
+    │ Blob Storage  │  │ Chunked │               │
+    │               │  │ Storage │               │
+    │ • Direct blob │  │         │               │
+    │ • Immediate   │  │ • 2MB   │               │
+    │   access      │  │   chunks│               │
+    │ • No P2P      │  │ • Torrent│               │
+    │   overhead    │  │   + DHT  │               │
+    └───────────────┘  └─────────┘               │
                           │                     │
-    ┌───────▼───────┐  ┌────▼────┐
-    │ Blob Storage  │  │ Chunked │
-    │               │  │ Storage │
-    │ • Direct blob │  │         │
-    │ • Immediate   │  │ • 2MB   │
-    │   access      │  │   chunks│
-    │ • No P2P      │  │ • Torrent│
-    │   overhead    │  │   + DHT  │
-    └───────────────┘  └─────────┘
+                    ┌──────┴─────────────────────▼──┐
+                    │        Video Analysis         │
+                    │                               │
+                    │ • Format Detection           │
+                    │ • Transcoding Queue          │
+                    │ • Priority Assignment        │
+                    │ • Background Processing      │
+                    └───────────────────────────────┘
 ```

 ### Storage Backends
@ -177,6 +205,15 @@ CREATE TABLE chunks (
    chunk_size INTEGER,
    PRIMARY KEY(file_hash, chunk_index)
 );
+
+-- Transcoding job tracking
+CREATE TABLE transcoding_status (
+    file_hash TEXT PRIMARY KEY,
+    status TEXT NOT NULL,
+    error_message TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
 ```

 #### Blob Storage
@ -191,6 +228,12 @@ CREATE TABLE chunks (
 - Enables parallel downloads and partial file access
 - Each chunk independently content-addressed

+#### Transcoded Storage
+- Processed video files stored in `./data/transcoded/`
+- Organized by original file hash subdirectories
+- H.264/AAC MP4 format for universal web compatibility
+- Smart serving prioritizes transcoded versions when available
+
 ### Caching System

 #### LRU Piece Cache
@ -218,6 +261,77 @@ type CacheEntry struct {
 - Concurrent access with read-write locks
 - Cache hit ratio tracking and optimization

+## Video Transcoding System
+
+### Architecture Overview
+
+The transcoding system provides automatic video conversion for web compatibility:
+
+```go
+type TranscodingEngine struct {
+    // Core Components
+    Transcoder    *Transcoder     // FFmpeg integration
+    Manager       *Manager        // Job coordination
+    WorkerPool    chan Job        // Background processing
+    Database      *sql.DB         // Status tracking
+    
+    // Configuration
+    ConcurrentJobs int            // Parallel workers
+    WorkDirectory  string         // Processing workspace
+    QualityProfiles []Quality     // Output formats
+}
+```
+
+### Processing Pipeline
+
+1. **Upload Detection**: Video files automatically identified during upload
+2. **Queue Decision**: Files ≥50MB queued for transcoding with priority based on size
+3. **File Reconstruction**: Chunked torrents reassembled into temporary files
+4. **FFmpeg Processing**: H.264/AAC conversion with web optimization flags
+5. **Smart Serving**: Transcoded versions served when ready, originals as fallback
+
+### Transcoding Manager
+
+```go
+func (tm *Manager) QueueVideoForTranscoding(fileHash, fileName, filePath string, fileSize int64) {
+    // Check if already processed
+    if tm.HasTranscodedVersion(fileHash) {
+        return
+    }
+    
+    // Analyze file format
+    needsTranscoding, err := tm.transcoder.NeedsTranscoding(filePath)
+    if !needsTranscoding {
+        tm.markAsWebCompatible(fileHash)
+        return
+    }
+    
+    // Create prioritized job
+    job := Job{
+        ID:        fmt.Sprintf("transcode_%s", fileHash),
+        InputPath: filePath,
+        OutputDir: filepath.Join(tm.transcoder.workDir, fileHash),
+        Priority:  tm.calculatePriority(fileSize),
+        Callback:  tm.jobCompletionHandler,
+    }
+    
+    tm.transcoder.SubmitJob(job)
+    tm.markTranscodingQueued(fileHash)
+}
+```
+
+### Smart Priority System
+
+- **High Priority** (8): Files < 500MB for faster user feedback
+- **Medium Priority** (5): Standard processing queue
+- **Low Priority** (2): Files > 5GB to prevent resource monopolization
+
+### Status API Integration
+
+Users can track transcoding progress via authenticated endpoints:
+- `/api/users/me/files/{hash}/transcoding-status` - Real-time status and progress
+- Response includes job status, progress percentage, and transcoded file availability
+
 ## P2P Integration & Coordination

 ### Unified Peer Discovery
@ -429,9 +543,10 @@ type SystemStats struct {
 - `/api/health` - Component health status
 - `/api/diagnostics` - Comprehensive system diagnostics
 - `/api/webseed/health` - WebSeed-specific health
+- `/api/users/me/files/{hash}/transcoding-status` - Video transcoding progress

 ## Conclusion

-The BitTorrent Gateway represents a comprehensive solution for decentralized content distribution, combining the best aspects of traditional web hosting with peer-to-peer networks. Its modular architecture, intelligent routing, and production-ready features make it suitable for both small-scale deployments and large-scale content distribution networks.
+The BitTorrent Gateway represents a comprehensive solution for decentralized content distribution, combining the best aspects of traditional web hosting with peer-to-peer networks and modern video processing capabilities. Its modular architecture, intelligent routing, automatic transcoding, and production-ready features make it suitable for both small-scale deployments and large-scale content distribution networks.

-The system's emphasis on standards compliance, security, and performance ensures reliable operation while maintaining the decentralized principles of the BitTorrent protocol. Through its unified approach to peer discovery, intelligent caching, and comprehensive monitoring, it provides a robust foundation for modern content distribution needs.
+The system's emphasis on standards compliance, security, performance, and user experience ensures reliable operation while maintaining the decentralized principles of the BitTorrent protocol. Through its unified approach to peer discovery, intelligent caching, automatic video optimization, and comprehensive monitoring, it provides a robust foundation for modern multimedia content distribution needs.
--- a/configs/config.yaml
+++ b/configs/config.yaml
@ -71,6 +71,49 @@ tracker:
 nostr:
  relays:
    - "wss://freelay.sovbit.host"
+  publish_nip35: true          # Publish NIP-35 torrent events for DTAN compatibility
+  publish_nip71: true          # Publish NIP-71 video events for social clients
+  video_relays:                # Specific relays for video content (optional)
+    - "wss://relay.damus.io"
+    - "wss://nos.lol"
+    - "wss://relay.nostr.band"
+  private_key: ""              # Hex-encoded private key (leave empty to auto-generate)
+  auto_publish: true           # Auto-publish video files on upload
+  thumbnails_dir: "data/thumbnails"  # Directory for video thumbnails
+
+# Video transcoding configuration
+transcoding:
+  enabled: true                # Enable/disable transcoding (requires ffmpeg)
+  concurrent_jobs: 2           # Number of parallel transcoding jobs
+  work_dir: "./data/transcoded"  # Directory for transcoded files
+  
+  # When to transcode
+  auto_transcode: true         # Automatically transcode uploaded videos
+  min_file_size: 50MB          # Don't transcode files smaller than this
+  
+  # Output settings
+  qualities:
+    - name: "1080p"
+      width: 1920
+      height: 1080
+      bitrate: "5000k"
+    - name: "720p"  
+      width: 1280
+      height: 720
+      bitrate: "2500k"
+    - name: "480p"
+      width: 854
+      height: 480
+      bitrate: "1000k"
+  
+  # Storage management
+  retention:
+    transcoded_files: "30d"    # Delete transcoded files after this time if not accessed
+    failed_jobs: "7d"          # Clean up failed job records after this time
+  
+  # Resource limits
+  max_cpu_percent: 80          # Limit CPU usage (not implemented yet)
+  nice_level: 10               # Process priority (lower = higher priority)

 # Smart proxy configuration
 proxy:
--- a/docs/deployment.md
+++ b/docs/deployment.md
@ -8,7 +8,8 @@ This guide covers deploying the Torrent Gateway in production using Docker Compo

 - Docker and Docker Compose installed
 - SQLite3 for database operations
- 4GB+ RAM recommended
+- FFmpeg for video transcoding (optional but recommended)
+- 4GB+ RAM recommended (8GB+ for transcoding)
 - 50GB+ disk space for storage

 ## Quick Deployment
--- a/docs/performance.md
+++ b/docs/performance.md
@ -2,7 +2,7 @@

 ## Overview

-This guide covers optimizing Torrent Gateway performance for different workloads and deployment sizes.
+This guide covers optimizing Torrent Gateway performance for different workloads and deployment sizes, including video transcoding workloads.

 ## Database Optimization

@ -23,6 +23,10 @@ CREATE INDEX idx_chunks_chunk_hash ON chunks(chunk_hash);

 -- User statistics
 CREATE INDEX idx_users_storage_used ON users(storage_used);
+
+-- Transcoding status optimization
+CREATE INDEX idx_transcoding_status ON transcoding_status(status);
+CREATE INDEX idx_transcoding_updated ON transcoding_status(updated_at);
 ```

 ### Database Maintenance
@ -398,3 +402,57 @@ time curl -O http://localhost:9876/api/download/[hash]
 - [ ] Regular load testing scheduled
 - [ ] Capacity planning reviewed
 - [ ] Performance dashboards created
+
+## Video Transcoding Performance
+
+### Hardware Requirements
+
+**CPU:**
+- 4+ cores recommended for concurrent transcoding
+- Modern CPU with hardware encoding support (Intel QuickSync, AMD VCE)
+- Higher core count = more concurrent jobs
+
+**Memory:**
+- 2GB+ RAM per concurrent transcoding job
+- Additional 1GB+ for temporary file storage
+- Consider SSD swap for large files
+
+**Storage:**
+- Fast SSD for work directory (`transcoding.work_dir`)
+- Separate from main storage to avoid I/O contention
+- Plan for 2-3x video file size temporary space
+
+### Configuration Optimization
+
+```yaml
+transcoding:
+  enabled: true
+  concurrent_jobs: 4              # Match CPU cores
+  work_dir: "/fast/ssd/transcoding" # Use fastest storage
+  max_cpu_percent: 80             # Limit CPU usage
+  nice_level: 10                  # Lower priority than main service
+  min_file_size: 100MB            # Skip small files
+```
+
+### Performance Monitoring
+
+**Key Metrics:**
+- Queue depth and processing time
+- CPU usage during transcoding
+- Storage I/O patterns
+- Memory consumption per job
+- Failed job retry rates
+
+**Alerts:**
+- Queue backlog > 50 jobs
+- Average processing time > 5 minutes per GB
+- Failed job rate > 10%
+- Storage space < 20% free
+
+### Optimization Strategies
+
+1. **Priority System**: Smaller files processed first for user feedback
+2. **Resource Limits**: Prevent transcoding from affecting main service
+3. **Smart Serving**: Original files served while transcoding in progress
+4. **Batch Processing**: Group similar formats for efficiency
+5. **Hardware Acceleration**: Use GPU encoding when available
--- a/docs/troubleshooting.md
+++ b/docs/troubleshooting.md
@ -392,4 +392,82 @@ echo "Docker Compose version: $(docker-compose --version)" >> system_info.txt
 echo "System: $(uname -a)" >> system_info.txt
 echo "Memory: $(free -h)" >> system_info.txt
 echo "Disk: $(df -h)" >> system_info.txt
+echo "FFmpeg: $(ffmpeg -version 2>/dev/null | head -1 || echo 'Not installed')" >> system_info.txt
 ```
+
+## Video Transcoding Issues
+
+### FFmpeg Not Found
+
+**Symptoms:** Transcoding fails with "ffmpeg not found" errors
+
+**Solution:**
+```bash
+# Install FFmpeg
+sudo apt install ffmpeg  # Ubuntu/Debian
+sudo yum install ffmpeg  # CentOS/RHEL
+brew install ffmpeg      # macOS
+
+# Verify installation
+ffmpeg -version
+```
+
+### Transcoding Jobs Stuck
+
+**Symptoms:** Videos remain in "queued" or "processing" status
+
+**Diagnostic Steps:**
+```bash
+# Check transcoding status
+curl -H "Authorization: Bearer $TOKEN" \
+  http://localhost:9877/api/users/me/files/$HASH/transcoding-status
+
+# Check process resources
+ps aux | grep ffmpeg
+top -p $(pgrep ffmpeg)
+```
+
+**Common Causes:**
+- Insufficient disk space in work directory
+- Memory limits exceeded
+- Invalid video format
+- Corrupted source file
+
+### High Resource Usage
+
+**Symptoms:** System slow during transcoding, high CPU/memory usage
+
+**Solutions:**
+```yaml
+# Reduce concurrent jobs
+transcoding:
+  concurrent_jobs: 2        # Lower from 4
+
+# Limit CPU usage
+transcoding:
+  max_cpu_percent: 50       # Reduce from 80
+  nice_level: 15            # Increase from 10
+
+# Increase minimum file size threshold
+transcoding:
+  min_file_size: 200MB      # Skip more small files
+```
+
+### Failed Transcoding Jobs
+
+**Symptoms:** Jobs marked as "failed" in status API
+
+**Diagnostic Steps:**
+```bash
+# Check transcoding logs
+grep "transcoding" /var/log/torrent-gateway.log
+
+# Check FFmpeg error output
+journalctl -u torrent-gateway | grep ffmpeg
+```
+
+**Common Solutions:**
+- Verify source file is not corrupted
+- Check available disk space
+- Ensure FFmpeg supports input format
+- Review resource limits
--- a/go.mod
+++ b/go.mod
@ -6,6 +6,7 @@ require (
 	github.com/anacrolix/torrent v1.58.1
 	github.com/go-redis/redis/v8 v8.11.5
 	github.com/gorilla/mux v1.8.1
+	github.com/gorilla/websocket v1.5.0
 	github.com/mattn/go-sqlite3 v1.14.24
 	github.com/nbd-wtf/go-nostr v0.51.12
 	github.com/prometheus/client_golang v1.12.2
--- a/go.sum
+++ b/go.sum
@ -246,6 +246,7 @@ github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51
 github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
 github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
 github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
+github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
 github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
--- a/internal/api/handlers.go
+++ b/internal/api/handlers.go
@ -7,8 +7,10 @@ import (
 	"fmt"
 	"io"
 	"log"
+	"os"
 	"mime/multipart"
 	"net/http"
+	"path/filepath"
 	"sort"
 	"strconv"
 	"strings"
@ -26,6 +28,7 @@ import (
 	"git.sovbit.dev/enki/torrentGateway/internal/streaming"
 	"git.sovbit.dev/enki/torrentGateway/internal/torrent"
 	"git.sovbit.dev/enki/torrentGateway/internal/tracker"
+	"git.sovbit.dev/enki/torrentGateway/internal/transcoding"
 	"git.sovbit.dev/enki/torrentGateway/internal/dht"
 	"github.com/gorilla/mux"
 	nip "github.com/nbd-wtf/go-nostr"
@ -109,6 +112,99 @@ type Gateway struct {
 	publicURL           string
 	trackerInstance     *tracker.Tracker
 	dhtBootstrap        DHTBootstrap
+	transcodingManager  TranscodingManager
+}
+
+// TranscodingStatusHandler returns transcoding status for a specific file
+func (g *Gateway) TranscodingStatusHandler(w http.ResponseWriter, r *http.Request) {
+	// Get file hash from URL
+	vars := mux.Vars(r)
+	fileHash := vars["hash"]
+	
+	if err := g.validateFileHash(fileHash); err != nil {
+		g.writeErrorResponse(w, ErrInvalidFileHash, err.Error())
+		return
+	}
+	
+	// Check if user has access to this file
+	requestorPubkey := middleware.GetUserFromContext(r.Context())
+	canAccess, err := g.storage.CheckFileAccess(fileHash, requestorPubkey)
+	if err != nil {
+		g.writeError(w, http.StatusInternalServerError, "Access check failed", ErrorTypeInternal,
+			fmt.Sprintf("Failed to check file access: %v", err))
+		return
+	}
+	if !canAccess {
+		g.writeError(w, http.StatusForbidden, "Access denied", ErrorTypeUnauthorized,
+			"You do not have permission to access this file")
+		return
+	}
+	
+	// Get file metadata to check if it's a video
+	metadata, err := g.getMetadata(fileHash)
+	if err != nil {
+		g.writeErrorResponse(w, ErrFileNotFound, fmt.Sprintf("No file found with hash: %s", fileHash))
+		return
+	}
+	
+	// Prepare response
+	response := map[string]interface{}{
+		"file_hash": fileHash,
+		"is_video": false,
+		"transcoding_enabled": g.transcodingManager != nil,
+	}
+	
+	// Check if it's a video file
+	if metadata.StreamingInfo != nil && metadata.StreamingInfo.IsVideo {
+		response["is_video"] = true
+		response["original_file"] = metadata.FileName
+		
+		if g.transcodingManager != nil {
+			status := g.transcodingManager.GetTranscodingStatus(fileHash)
+			response["status"] = status
+			
+			// Add more details based on status
+			switch status {
+			case "completed", "web_compatible":
+				transcodedPath := g.transcodingManager.GetTranscodedPath(fileHash)
+				response["transcoded_available"] = transcodedPath != ""
+				if transcodedPath != "" {
+					// Get transcoded file info
+					if fileInfo, err := os.Stat(transcodedPath); err == nil {
+						response["transcoded_size"] = fileInfo.Size()
+						response["transcoded_path"] = filepath.Base(transcodedPath)
+					}
+				}
+			case "queued":
+				response["message"] = "Video is queued for transcoding"
+			case "processing":
+				response["message"] = "Video is being transcoded"
+			case "failed":
+				response["message"] = "Transcoding failed - serving original"
+			case "disabled":
+				response["message"] = "Transcoding is disabled"
+			default:
+				response["message"] = "Transcoding status unknown"
+			}
+			
+			// If there's a job in progress, get progress details
+			if status == "processing" || status == "queued" {
+				if progress, exists := g.transcodingManager.GetJobProgress(fileHash); exists {
+					response["progress"] = progress
+					response["job_id"] = fmt.Sprintf("transcode_%s", fileHash)
+				}
+			}
+		} else {
+			response["status"] = "disabled"
+			response["message"] = "Transcoding is not enabled"
+		}
+	} else {
+		response["message"] = "File is not a video or video info unavailable"
+	}
+	
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(response)
 }

 // DHTBootstrap interface for DHT integration
@ -178,6 +274,8 @@ func (g *Gateway) validateHTTPMethod(r *http.Request, allowedMethods []string) e

 type NostrPublisher interface {
 	PublishTorrentAnnouncement(ctx context.Context, data nostr.TorrentEventData) (*nip.Event, error)
+	CreateNIP71VideoEvent(data nostr.TorrentEventData) (*nip.Event, error)
+	PublishEvent(ctx context.Context, event *nip.Event) error
 }

 type BlossomClient interface {
@ -185,6 +283,15 @@ type BlossomClient interface {
 	Get(hash string) ([]byte, error)
 }

+type TranscodingManager interface {
+	QueueVideoForTranscoding(fileHash, fileName, filePath string, fileSize int64)
+	HasTranscodedVersion(fileHash string) bool
+	GetTranscodedPath(fileHash string) string
+	GetTranscodingStatus(fileHash string) string
+	GetJobProgress(fileHash string) (float64, bool)
+	InitializeDatabase() error
+}
+
 type FileMetadata struct {
 	FileHash     string                  `json:"file_hash"`
 	FileName     string                  `json:"file_name"`
@ -226,13 +333,14 @@ func NewGateway(cfg *config.Config, storage *storage.Backend) *Gateway {
 		}
 	}
 	
-	// Generate a new private key for this session (in production, this should be loaded from config)
+	// Initialize Nostr publisher from config
 	var nostrPublisher NostrPublisher
-	realPublisher, err := nostr.NewPublisher("", nostrRelays)
+	privateKey := cfg.Nostr.PrivateKey // Use private key from config
+	realPublisher, err := nostr.NewPublisher(privateKey, nostrRelays)
 	if err != nil {
-		// Fall back to mock if real publisher fails to initialize
-		log.Printf("Warning: Failed to initialize Nostr publisher, using mock: %v", err)
-		nostrPublisher = nostr.CreateMockPublisher()
+		log.Printf("Failed to initialize Nostr publisher: %v", err)
+		log.Printf("Disabling Nostr publishing")
+		nostrPublisher = nil
 	} else {
 		pubkey, _ := realPublisher.GetPublicKeyBech32()
 		log.Printf("Initialized Nostr publisher with public key: %s", pubkey)
@ -242,6 +350,30 @@ func NewGateway(cfg *config.Config, storage *storage.Backend) *Gateway {
 	// Set public URL for tracker functionality
 	publicURL := fmt.Sprintf("http://localhost:%d", cfg.Gateway.Port)

+	// Initialize transcoding manager
+	var transcodingManager TranscodingManager
+	if cfg.Transcoding.Enabled {
+		transcoder, err := transcoding.NewTranscoder(
+			cfg.Transcoding.WorkDir,
+			cfg.Transcoding.ConcurrentJobs,
+			cfg.Transcoding.Enabled,
+		)
+		if err != nil {
+			log.Printf("Warning: Failed to initialize transcoder: %v", err)
+			log.Printf("Transcoding will be disabled")
+			transcodingManager = nil
+		} else {
+			manager := transcoding.NewManager(transcoder, storage.GetDB())
+			if err := manager.InitializeDatabase(); err != nil {
+				log.Printf("Warning: Failed to initialize transcoding database: %v", err)
+			}
+			transcodingManager = manager
+			log.Printf("Transcoding enabled with %d concurrent workers", cfg.Transcoding.ConcurrentJobs)
+		}
+	} else {
+		log.Printf("Transcoding is disabled")
+	}
+	
 	return &Gateway{
 		blossomClient:      blossomClient,
 		nostrPublisher:     nostrPublisher,
@ -249,9 +381,146 @@ func NewGateway(cfg *config.Config, storage *storage.Backend) *Gateway {
 		storage:            storage,
 		profileFetcher:     profile.NewProfileFetcher(nostrRelays),
 		publicURL:          publicURL,
+		transcodingManager: transcodingManager,
 	}
 }

+// serveTranscodedFile serves a transcoded video file with proper headers and range support
+func (g *Gateway) serveTranscodedFile(w http.ResponseWriter, r *http.Request, filePath, originalFileName string) {
+	// Open the transcoded file
+	file, err := os.Open(filePath)
+	if err != nil {
+		g.writeError(w, http.StatusInternalServerError, "Transcoded file unavailable", ErrorTypeInternal,
+			fmt.Sprintf("Failed to open transcoded file: %v", err))
+		return
+	}
+	defer file.Close()
+
+	// Get file info
+	fileInfo, err := file.Stat()
+	if err != nil {
+		g.writeError(w, http.StatusInternalServerError, "File stat failed", ErrorTypeInternal,
+			fmt.Sprintf("Failed to stat transcoded file: %v", err))
+		return
+	}
+
+	fileSize := fileInfo.Size()
+
+	// Set headers for transcoded MP4
+	w.Header().Set("Content-Type", "video/mp4")
+	w.Header().Set("Accept-Ranges", "bytes")
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	w.Header().Set("Access-Control-Allow-Methods", "GET, HEAD, OPTIONS")
+	w.Header().Set("Access-Control-Allow-Headers", "Range, Content-Type, Authorization")
+	w.Header().Set("Access-Control-Expose-Headers", "Content-Length, Content-Range, Accept-Ranges")
+	w.Header().Set("Cache-Control", "public, max-age=3600")
+	w.Header().Set("X-Content-Type-Options", "nosniff")
+	
+	// Use original filename but with .mp4 extension
+	if originalFileName != "" {
+		ext := filepath.Ext(originalFileName)
+		baseFileName := strings.TrimSuffix(originalFileName, ext)
+		filename := fmt.Sprintf("%s_transcoded.mp4", baseFileName)
+		w.Header().Set("Content-Disposition", fmt.Sprintf("inline; filename=\"%s\"", filename))
+	}
+
+	// Handle HEAD request
+	if r.Method == http.MethodHead {
+		w.Header().Set("Content-Length", fmt.Sprintf("%d", fileSize))
+		w.WriteHeader(http.StatusOK)
+		return
+	}
+
+	// Handle range requests for video seeking
+	rangeHeader := r.Header.Get("Range")
+	if rangeHeader != "" {
+		// Parse range header
+		rangeReq, err := streaming.ParseRangeHeader(rangeHeader, fileSize)
+		if err != nil {
+			g.writeErrorResponse(w, ErrInvalidRange, fmt.Sprintf("Invalid range header: %v", err))
+			return
+		}
+
+		if rangeReq != nil {
+			// Validate range
+			if rangeReq.Start < 0 || rangeReq.End >= fileSize || rangeReq.Start > rangeReq.End {
+				w.Header().Set("Content-Range", fmt.Sprintf("bytes */%d", fileSize))
+				g.writeError(w, http.StatusRequestedRangeNotSatisfiable, "Range not satisfiable", ErrorTypeInvalidRange,
+					fmt.Sprintf("Range %d-%d is not satisfiable for file size %d", rangeReq.Start, rangeReq.End, fileSize))
+				return
+			}
+
+			// Seek to start position
+			if _, err := file.Seek(rangeReq.Start, 0); err != nil {
+				g.writeError(w, http.StatusInternalServerError, "Seek failed", ErrorTypeInternal,
+					fmt.Sprintf("Failed to seek in transcoded file: %v", err))
+				return
+			}
+
+			// Set partial content headers
+			contentLength := rangeReq.End - rangeReq.Start + 1
+			w.Header().Set("Content-Length", fmt.Sprintf("%d", contentLength))
+			w.Header().Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", rangeReq.Start, rangeReq.End, fileSize))
+			w.WriteHeader(http.StatusPartialContent)
+
+			// Copy the requested range
+			if _, err := io.CopyN(w, file, contentLength); err != nil && err != io.EOF {
+				log.Printf("Error serving transcoded file range: %v", err)
+			}
+			return
+		}
+	}
+
+	// Serve full file
+	w.Header().Set("Content-Length", fmt.Sprintf("%d", fileSize))
+	w.WriteHeader(http.StatusOK)
+	
+	if _, err := io.Copy(w, file); err != nil && err != io.EOF {
+		log.Printf("Error serving transcoded file: %v", err)
+	}
+}
+
+// reconstructTorrentFile reconstructs a torrent file from chunks for transcoding
+func (g *Gateway) reconstructTorrentFile(fileHash, fileName string) (string, error) {
+	// Create temporary file for reconstruction  
+	tempDir := filepath.Join(g.config.Transcoding.WorkDir, "temp")
+	if err := os.MkdirAll(tempDir, 0755); err != nil {
+		return "", fmt.Errorf("failed to create temp directory: %w", err)
+	}
+
+	// Create temporary file with original filename to preserve extension
+	tempFile := filepath.Join(tempDir, fmt.Sprintf("%s_%s", fileHash, fileName))
+	
+	// Get metadata to find chunks
+	metadata, err := g.getMetadata(fileHash)
+	if err != nil {
+		return "", fmt.Errorf("failed to get metadata: %w", err)
+	}
+
+	// Open output file
+	outFile, err := os.Create(tempFile)
+	if err != nil {
+		return "", fmt.Errorf("failed to create temp file: %w", err)
+	}
+	defer outFile.Close()
+
+	// Reassemble chunks in order
+	for i, chunkInfo := range metadata.Chunks {
+		chunkData, err := g.storage.GetChunkData(chunkInfo.Hash)
+		if err != nil {
+			os.Remove(tempFile) // Clean up on error
+			return "", fmt.Errorf("failed to get chunk %d: %w", i, err)
+		}
+
+		if _, err := outFile.Write(chunkData); err != nil {
+			os.Remove(tempFile) // Clean up on error  
+			return "", fmt.Errorf("failed to write chunk %d: %w", i, err)
+		}
+	}
+
+	return tempFile, nil
+}
+
 // Implement Gateway interface methods for tracker integration
 func (g *Gateway) GetPublicURL() string {
 	return g.publicURL
@ -475,6 +744,30 @@ func (g *Gateway) handleBlobUpload(w http.ResponseWriter, r *http.Request, file
 		return
 	}

+	// Create streaming info for video files
+	isVideo, mimeType := streaming.DetectMediaType(fileName)
+	var streamingInfo *streaming.FileInfo
+	var hlsPlaylist *streaming.HLSPlaylist
+
+	if isVideo {
+		duration := streaming.EstimateVideoDuration(metadata.Size, fileName)
+		streamingInfo = &streaming.FileInfo{
+			Name:       fileName,
+			Size:       metadata.Size,
+			ChunkCount: 1, // Blob is treated as single chunk
+			ChunkSize:  int(metadata.Size),
+			Duration:   duration,
+			IsVideo:    true,
+			MimeType:   mimeType,
+		}
+		
+		config := streaming.DefaultHLSConfig()
+		playlist, err := streaming.GenerateHLSSegments(*streamingInfo, config)
+		if err == nil {
+			hlsPlaylist = playlist
+		}
+	}
+
 	// Create API response metadata
 	apiMetadata := FileMetadata{
 		FileHash:      metadata.Hash,
@ -483,6 +776,8 @@ func (g *Gateway) handleBlobUpload(w http.ResponseWriter, r *http.Request, file
 		ChunkCount:    1,  // Blobs count as single "chunk"
 		StorageType:   "blob",
 		Chunks:        []ChunkInfo{{Index: 0, Hash: metadata.Hash, Size: int(metadata.Size)}},
+		StreamingInfo: streamingInfo,
+		HLSPlaylist:   hlsPlaylist,
 	}

 	// Store API metadata for compatibility
@ -494,9 +789,6 @@ func (g *Gateway) handleBlobUpload(w http.ResponseWriter, r *http.Request, file
 	// Publish to Nostr for blobs
 	var nostrEventID string
 	if g.nostrPublisher != nil {
-		// Detect if this is a video file for streaming metadata
-		isVideo, mimeType := streaming.DetectMediaType(fileName)
-		
 		eventData := nostr.TorrentEventData{
 			Title:       fmt.Sprintf("File: %s", fileName),
 			FileName:    fileName,
@ -507,11 +799,13 @@ func (g *Gateway) handleBlobUpload(w http.ResponseWriter, r *http.Request, file
 		}
 		
 		// Add streaming URLs for video files
-		if isVideo {
+		if streamingInfo != nil {
 			baseURL := g.getBaseURL()
 			eventData.StreamURL = fmt.Sprintf("%s/api/stream/%s", baseURL, metadata.Hash)
 			eventData.HLSPlaylistURL = fmt.Sprintf("%s/api/stream/%s/playlist.m3u8", baseURL, metadata.Hash)
-			eventData.Duration = int64(streaming.EstimateVideoDuration(metadata.Size, fileName))
+			eventData.Duration = int64(streamingInfo.Duration)
+			eventData.VideoCodec = "h264" // Default assumption
+			eventData.MimeType = streamingInfo.MimeType
 		}

 		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
@ -523,6 +817,27 @@ func (g *Gateway) handleBlobUpload(w http.ResponseWriter, r *http.Request, file
 		} else if event != nil {
 			nostrEventID = nostr.GetEventID(event)
 		}
+
+		// Also publish NIP-71 video event for video files
+		if g.config.Nostr.PublishNIP71 && streamingInfo != nil {
+			nip71Event, err := g.nostrPublisher.CreateNIP71VideoEvent(eventData)
+			if err != nil {
+				fmt.Printf("Warning: Failed to create NIP-71 video event: %v\n", err)
+			} else {
+				err = g.nostrPublisher.PublishEvent(ctx, nip71Event)
+				if err != nil {
+					fmt.Printf("Warning: Failed to publish NIP-71 video event: %v\n", err)
+				} else {
+					fmt.Printf("Published NIP-71 video event: %s\n", nip71Event.ID)
+				}
+			}
+		}
+	}
+
+	// Queue video for transcoding if applicable  
+	// Note: Blob transcoding not implemented yet - small videos are usually already web-compatible
+	if g.transcodingManager != nil && streamingInfo != nil && g.config.Transcoding.AutoTranscode {
+		log.Printf("Small video file %s - skipping transcoding (typically already web-compatible)", fileName)
 	}

 	// Send success response for blob
@ -738,6 +1053,37 @@ func (g *Gateway) handleTorrentUpload(w http.ResponseWriter, r *http.Request, fi
 		} else if event != nil {
 			nostrEventID = nostr.GetEventID(event)
 		}
+
+		// Also publish NIP-71 video event for video files
+		if g.config.Nostr.PublishNIP71 && isVideo {
+			nip71Event, err := g.nostrPublisher.CreateNIP71VideoEvent(eventData)
+			if err != nil {
+				fmt.Printf("Warning: Failed to create NIP-71 video event: %v\n", err)
+			} else {
+				err = g.nostrPublisher.PublishEvent(ctx, nip71Event)
+				if err != nil {
+					fmt.Printf("Warning: Failed to publish NIP-71 video event: %v\n", err)
+				} else {
+					fmt.Printf("Published NIP-71 video event: %s\n", nip71Event.ID)
+				}
+			}
+		}
+	}
+
+	// Queue video for transcoding if applicable
+	if g.transcodingManager != nil && streamingInfo != nil && g.config.Transcoding.AutoTranscode {
+		// For torrent files, we need to reconstruct the original file for transcoding
+		go func() {
+			// Run in background to not block upload response
+			originalPath, err := g.reconstructTorrentFile(metadata.Hash, fileName)
+			if err != nil {
+				log.Printf("Warning: Failed to reconstruct file %s for transcoding: %v", fileName, err)
+				return
+			}
+			
+			log.Printf("Queueing large video file %s for transcoding", fileName)
+			g.transcodingManager.QueueVideoForTranscoding(metadata.Hash, fileName, originalPath, metadata.Size)
+		}()
 	}

 	// Send success response for torrent
@ -2419,6 +2765,24 @@ func (g *Gateway) StreamingHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}

+	// Check for transcoded version first (higher priority for video files)
+	var transcodedPath string
+	if g.transcodingManager != nil && metadata.StreamingInfo != nil && metadata.StreamingInfo.IsVideo {
+		transcodedPath = g.transcodingManager.GetTranscodedPath(fileHash)
+		if transcodedPath != "" {
+			log.Printf("Serving transcoded version for %s", fileHash)
+			// Serve the transcoded file directly (it's a single MP4 file)
+			g.serveTranscodedFile(w, r, transcodedPath, metadata.FileName)
+			return
+		}
+		
+		// Log transcoding status for debugging
+		status := g.transcodingManager.GetTranscodingStatus(fileHash)
+		if status != "unknown" && status != "disabled" {
+			log.Printf("Transcoded version not ready for %s, status: %s - serving original chunks", fileHash, status)
+		}
+	}
+
 	// Get range header for partial content support
 	rangeHeader := r.Header.Get("Range")
 	
@ -2723,6 +3087,8 @@ func RegisterRoutes(r *mux.Router, cfg *config.Config, storage *storage.Backend)
 	publicRoutes.HandleFunc("/stream/{hash}/playlist.m3u8", rateLimiter.StreamMiddleware(gateway.HLSPlaylistHandler)).Methods("GET")
 	publicRoutes.HandleFunc("/stream/{hash}/segment/{segment}", rateLimiter.StreamMiddleware(gateway.HLSSegmentHandler)).Methods("GET")
 	publicRoutes.HandleFunc("/info/{hash}", gateway.InfoHandler).Methods("GET")
+	publicRoutes.HandleFunc("/webtorrent/{hash}", gateway.WebTorrentInfoHandler).Methods("GET")
+	publicRoutes.HandleFunc("/thumbnail/{hash}.jpg", gateway.ThumbnailHandler).Methods("GET")
 	publicRoutes.HandleFunc("/files", gateway.ListFilesHandler).Methods("GET")
 	publicRoutes.HandleFunc("/profile/{pubkey}", gateway.ProfileHandler).Methods("GET")

@ -2748,6 +3114,7 @@ func RegisterRoutes(r *mux.Router, cfg *config.Config, storage *storage.Backend)
 	userRoutes.HandleFunc("/files", authHandlers.UserFilesHandler).Methods("GET")
 	userRoutes.HandleFunc("/files/{hash}", authHandlers.DeleteFileHandler).Methods("DELETE")
 	userRoutes.HandleFunc("/files/{hash}/access", authHandlers.UpdateFileAccessHandler).Methods("PUT")
+	userRoutes.HandleFunc("/files/{hash}/transcoding-status", gateway.TranscodingStatusHandler).Methods("GET")
 	userRoutes.HandleFunc("/admin-status", authHandlers.AdminStatusHandler).Methods("GET")
 	
 	// Upload endpoint now requires authentication
@ -3268,11 +3635,16 @@ func RegisterTrackerRoutes(r *mux.Router, cfg *config.Config, storage *storage.B
 	announceHandler := tracker.NewAnnounceHandler(trackerInstance)
 	scrapeHandler := tracker.NewScrapeHandler(trackerInstance)

+	// WebSocket tracker for WebTorrent clients
+	wsTracker := tracker.NewWebSocketTracker()
+	wsTracker.StartCleanup()
+
 	// BitTorrent tracker endpoints (public, no auth required)
 	r.Handle("/announce", announceHandler).Methods("GET")
 	r.Handle("/scrape", scrapeHandler).Methods("GET")
+	r.HandleFunc("/tracker", wsTracker.HandleWS).Methods("GET") // WebSocket upgrade
 	
-	log.Printf("Registered BitTorrent tracker endpoints")
+	log.Printf("Registered BitTorrent tracker endpoints with WebSocket support")
 }

 // GetGatewayFromRoutes returns a gateway instance for DHT integration
@ -3280,9 +3652,176 @@ func GetGatewayFromRoutes(cfg *config.Config, storage *storage.Backend) *Gateway
 	return NewGateway(cfg, storage)
 }

+// WebTorrentInfoHandler returns WebTorrent-optimized file metadata with WebSocket trackers
+func (g *Gateway) WebTorrentInfoHandler(w http.ResponseWriter, r *http.Request) {
+	// Validate HTTP method
+	if err := g.validateHTTPMethod(r, []string{http.MethodGet}); err != nil {
+		g.writeErrorResponse(w, ErrMethodNotAllowed, err.Error())
+		return
+	}
+
+	// Get and validate file hash
+	vars := mux.Vars(r)
+	fileHash := vars["hash"]
+	
+	if err := g.validateFileHash(fileHash); err != nil {
+		g.writeErrorResponse(w, ErrInvalidFileHash, err.Error())
+		return
+	}
+
+	// Check file access permissions
+	requestorPubkey := middleware.GetUserFromContext(r.Context())
+	canAccess, err := g.storage.CheckFileAccess(fileHash, requestorPubkey)
+	if err != nil {
+		g.writeError(w, http.StatusInternalServerError, "Access check failed", ErrorTypeInternal,
+			fmt.Sprintf("Failed to check file access: %v", err))
+		return
+	}
+	if !canAccess {
+		g.writeError(w, http.StatusForbidden, "Access denied", ErrorTypeUnauthorized,
+			"You do not have permission to access this file")
+		return
+	}
+
+	// Get metadata
+	metadata, err := g.getMetadata(fileHash)
+	if err != nil {
+		g.writeErrorResponse(w, ErrFileNotFound, fmt.Sprintf("No file found with hash: %s", fileHash))
+		return
+	}
+
+	if metadata == nil || metadata.TorrentInfo == nil {
+		g.writeError(w, http.StatusNotFound, "Torrent not available", ErrorTypeNotFound,
+			"File does not have torrent information")
+		return
+	}
+
+	// Generate WebTorrent-optimized magnet link with WebSocket trackers
+	webTorrentMagnet := g.generateWebTorrentMagnet(metadata)
+
+	// Create WebTorrent-specific response
+	response := map[string]interface{}{
+		"magnet_uri":         webTorrentMagnet,
+		"info_hash":          metadata.TorrentInfo.InfoHash,
+		"name":               metadata.FileName,
+		"size":               metadata.TotalSize,
+		"piece_length":       g.calculateWebTorrentPieceLength(metadata.TotalSize),
+		"streaming_supported": metadata.StreamingInfo != nil && metadata.StreamingInfo.IsVideo,
+		"webseed_url":        fmt.Sprintf("%s/webseed/%s/", g.publicURL, metadata.FileHash),
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(response)
+}
+
+// generateWebTorrentMagnet creates a WebTorrent-optimized magnet link
+func (g *Gateway) generateWebTorrentMagnet(metadata *FileMetadata) string {
+	if metadata.TorrentInfo == nil {
+		return ""
+	}
+
+	// Start with existing magnet
+	magnetURI := metadata.TorrentInfo.Magnet
+	
+	// Add WebSocket trackers for WebRTC compatibility
+	wsTrackers := []string{
+		"wss://tracker.btorrent.xyz",
+		"wss://tracker.openwebtorrent.com", 
+		"wss://tracker.webtorrent.dev",
+		fmt.Sprintf("wss://localhost:%d/tracker", g.config.Gateway.Port), // Our WebSocket tracker
+	}
+
+	for _, tracker := range wsTrackers {
+		magnetURI += "&tr=" + tracker
+	}
+
+	// Add WebSeed URL
+	webSeedURL := fmt.Sprintf("%s/webseed/%s/", g.publicURL, metadata.FileHash)
+	magnetURI += "&ws=" + webSeedURL
+
+	return magnetURI
+}
+
+// calculateWebTorrentPieceLength calculates BitTorrent piece length based on file size
+func (g *Gateway) calculateWebTorrentPieceLength(fileSize int64) int64 {
+	const (
+		KB = 1024
+		MB = KB * 1024
+		GB = MB * 1024
+	)
+
+	switch {
+	case fileSize < 50*MB:
+		return 256 * KB
+	case fileSize < 500*MB:
+		return 512 * KB  
+	case fileSize < 2*GB:
+		return 1 * MB
+	default:
+		return 2 * MB
+	}
+}
+
 // getBaseURL returns the base URL for the gateway
 func (g *Gateway) getBaseURL() string {
 	// TODO: This should be configurable or detected from request
 	// For now, use localhost with the configured port
 	return fmt.Sprintf("http://localhost:%d", g.config.Gateway.Port)
 }
+
+
+// ThumbnailHandler serves video thumbnails
+func (g *Gateway) ThumbnailHandler(w http.ResponseWriter, r *http.Request) {
+	// Validate HTTP method
+	if err := g.validateHTTPMethod(r, []string{http.MethodGet}); err != nil {
+		g.writeErrorResponse(w, ErrMethodNotAllowed, err.Error())
+		return
+	}
+
+	// Get file hash from URL parameter
+	vars := mux.Vars(r)
+	fileHash := vars["hash"]
+
+	if err := g.validateFileHash(fileHash); err != nil {
+		g.writeErrorResponse(w, ErrInvalidFileHash, err.Error())
+		return
+	}
+
+	// Build thumbnail path
+	thumbnailPath := fmt.Sprintf("%s/%s.jpg", g.config.Nostr.ThumbnailsDir, fileHash)
+
+	// Check if thumbnail exists
+	_, err := os.Stat(thumbnailPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			g.writeError(w, http.StatusNotFound, "Thumbnail not found", ErrorTypeNotFound,
+				fmt.Sprintf("Thumbnail for hash %s not found", fileHash))
+			return
+		}
+		g.writeError(w, http.StatusInternalServerError, "Failed to access thumbnail", ErrorTypeInternal,
+			fmt.Sprintf("Failed to check thumbnail: %v", err))
+		return
+	}
+
+	// Open and serve the thumbnail
+	file, err := os.Open(thumbnailPath)
+	if err != nil {
+		g.writeError(w, http.StatusInternalServerError, "Failed to open thumbnail", ErrorTypeInternal,
+			fmt.Sprintf("Failed to open thumbnail file: %v", err))
+		return
+	}
+	defer file.Close()
+
+	// Set headers
+	w.Header().Set("Content-Type", "image/jpeg")
+	w.Header().Set("Cache-Control", "public, max-age=86400") // Cache for 1 day
+
+	// Serve the file
+	_, err = io.Copy(w, file)
+	if err != nil {
+		fmt.Printf("Error serving thumbnail: %v\n", err)
+	}
+}
+
+// StorageInterface implementation for storage.Backend
+// The storage.Backend already implements StoreNostrEvents, so it satisfies the interface
--- a/internal/config/config.go
+++ b/internal/config/config.go
@ -24,6 +24,7 @@ type Config struct {
 	Admin        AdminConfig        `yaml:"admin"`
 	RateLimiting RateLimitingConfig `yaml:"rate_limiting"`
 	Branding     BrandingConfig     `yaml:"branding"`
+	Transcoding  TranscodingConfig  `yaml:"transcoding"`
 }

 // GatewayConfig configures the HTTP API gateway
@ -102,6 +103,12 @@ type TrackerConfig struct {
 // NostrConfig configures Nostr relay settings
 type NostrConfig struct {
 	Relays         []string `yaml:"relays"`
+	PublishNIP35   bool     `yaml:"publish_nip35"`   // Publish NIP-35 torrent events for DTAN
+	PublishNIP71   bool     `yaml:"publish_nip71"`   // Publish NIP-71 video events
+	VideoRelays    []string `yaml:"video_relays"`    // Specific relays for video content
+	PrivateKey     string   `yaml:"private_key"`     // Hex-encoded private key
+	AutoPublish    bool     `yaml:"auto_publish"`    // Auto-publish on upload
+	ThumbnailsDir  string   `yaml:"thumbnails_dir"`  // Directory for video thumbnails
 }

 // ProxyConfig configures smart proxy settings
@ -168,6 +175,33 @@ type BrandingConfig struct {
 	SupportURL  string `yaml:"support_url"`
 }

+// TranscodingConfig configures video transcoding
+type TranscodingConfig struct {
+	Enabled        bool             `yaml:"enabled"`
+	ConcurrentJobs int              `yaml:"concurrent_jobs"`
+	WorkDir        string           `yaml:"work_dir"`
+	AutoTranscode  bool             `yaml:"auto_transcode"`
+	MinFileSize    string           `yaml:"min_file_size"`
+	Qualities      []QualityConfig  `yaml:"qualities"`
+	Retention      RetentionConfig  `yaml:"retention"`
+	MaxCPUPercent  int              `yaml:"max_cpu_percent"`
+	NiceLevel      int              `yaml:"nice_level"`
+}
+
+// QualityConfig represents a transcoding quality preset
+type QualityConfig struct {
+	Name    string `yaml:"name"`
+	Width   int    `yaml:"width"`
+	Height  int    `yaml:"height"`
+	Bitrate string `yaml:"bitrate"`
+}
+
+// RetentionConfig configures file retention policies
+type RetentionConfig struct {
+	TranscodedFiles string `yaml:"transcoded_files"`
+	FailedJobs      string `yaml:"failed_jobs"`
+}
+
 // LoadConfig loads configuration from a YAML file
 func LoadConfig(filename string) (*Config, error) {
 	data, err := os.ReadFile(filename)
@ -193,6 +227,38 @@ func LoadConfig(filename string) (*Config, error) {
 		config.Branding.Description = "Decentralized file sharing gateway"
 	}

+	// Set Nostr defaults
+	if len(config.Nostr.Relays) == 0 && (config.Nostr.PublishNIP35 || config.Nostr.PublishNIP71) {
+		config.Nostr.Relays = []string{
+			"wss://relay.damus.io",
+			"wss://nos.lol",
+			"wss://relay.nostr.band",
+		}
+	}
+	if len(config.Nostr.VideoRelays) == 0 && config.Nostr.PublishNIP71 {
+		config.Nostr.VideoRelays = config.Nostr.Relays // Use same relays by default
+	}
+	if config.Nostr.ThumbnailsDir == "" {
+		config.Nostr.ThumbnailsDir = "data/thumbnails"
+	}
+
+	// Set transcoding defaults
+	if config.Transcoding.WorkDir == "" {
+		config.Transcoding.WorkDir = "./data/transcoded"
+	}
+	if config.Transcoding.ConcurrentJobs == 0 {
+		config.Transcoding.ConcurrentJobs = 2
+	}
+	if config.Transcoding.MinFileSize == "" {
+		config.Transcoding.MinFileSize = "50MB"
+	}
+	if config.Transcoding.MaxCPUPercent == 0 {
+		config.Transcoding.MaxCPUPercent = 80
+	}
+	if config.Transcoding.NiceLevel == 0 {
+		config.Transcoding.NiceLevel = 10
+	}
+
 	return &config, nil
 }

--- a/internal/nostr/nip71.go
+++ b/internal/nostr/nip71.go
@ -0,0 +1,125 @@
+package nostr
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/nbd-wtf/go-nostr"
+)
+
+const (
+	// NIP-71: Video Events
+	KindVideoHorizontal = 21
+	KindVideoVertical   = 22
+)
+
+// CreateNIP71VideoEvent creates a NIP-71 video event with WebTorrent extensions
+func (p *Publisher) CreateNIP71VideoEvent(data TorrentEventData) (*nostr.Event, error) {
+	// Determine if vertical video based on dimensions
+	kind := KindVideoHorizontal
+	if data.VideoHeight > data.VideoWidth {
+		kind = KindVideoVertical
+	}
+
+	event := &nostr.Event{
+		Kind:      kind,
+		CreatedAt: nostr.Now(),
+		Content:   data.Description,
+		Tags:      nostr.Tags{},
+	}
+
+	// Standard NIP-71 tags
+	if data.Title != "" {
+		event.Tags = event.Tags.AppendUnique(nostr.Tag{"title", data.Title})
+	}
+	
+	event.Tags = event.Tags.AppendUnique(nostr.Tag{"published_at", fmt.Sprintf("%d", time.Now().Unix())})
+	
+	if data.Description != "" {
+		event.Tags = event.Tags.AppendUnique(nostr.Tag{"alt", data.Description})
+	}
+
+	// Duration in seconds
+	if data.Duration > 0 {
+		event.Tags = event.Tags.AppendUnique(nostr.Tag{"duration", fmt.Sprintf("%d", data.Duration)})
+	}
+
+	// Add HLS streaming URL
+	if data.HLSPlaylistURL != "" {
+		event.Tags = event.Tags.AppendUnique(nostr.Tag{
+			"imeta",
+			fmt.Sprintf("dim %dx%d", data.VideoWidth, data.VideoHeight),
+			fmt.Sprintf("url %s", data.HLSPlaylistURL),
+			"m application/x-mpegURL",
+		})
+	}
+
+	// Add direct download URL
+	if data.StreamURL != "" {
+		event.Tags = event.Tags.AppendUnique(nostr.Tag{
+			"imeta",
+			fmt.Sprintf("dim %dx%d", data.VideoWidth, data.VideoHeight),
+			fmt.Sprintf("url %s", data.StreamURL),
+			fmt.Sprintf("m %s", data.MimeType),
+			fmt.Sprintf("size %d", data.FileSize),
+		})
+	}
+
+	// Add WebTorrent magnet link
+	if data.MagnetLink != "" {
+		event.Tags = event.Tags.AppendUnique(nostr.Tag{"magnet", data.MagnetLink})
+		
+		// WebTorrent extensions
+		event.Tags = event.Tags.AppendUnique(nostr.Tag{"webtorrent", data.MagnetLink})
+		event.Tags = event.Tags.AppendUnique(nostr.Tag{"streaming_method", "webtorrent"})
+		event.Tags = event.Tags.AppendUnique(nostr.Tag{"piece_order", "sequential"})
+	}
+
+	// Add WebSocket trackers for WebTorrent
+	wsTrackers := []string{
+		"wss://tracker.btorrent.xyz",
+		"wss://tracker.openwebtorrent.com", 
+		"wss://tracker.webtorrent.dev",
+	}
+	for _, tracker := range wsTrackers {
+		event.Tags = event.Tags.AppendUnique(nostr.Tag{"ws_tracker", tracker})
+	}
+
+	// Add WebSeed fallback
+	if data.WebSeedURL != "" {
+		event.Tags = event.Tags.AppendUnique(nostr.Tag{"webseed", data.WebSeedURL})
+	}
+
+	// Cross-reference with NIP-35 torrent
+	if data.InfoHash != "" {
+		event.Tags = event.Tags.AppendUnique(nostr.Tag{"i", data.InfoHash})
+	}
+
+	// Blossom reference
+	if data.BlossomHash != "" {
+		event.Tags = event.Tags.AppendUnique(nostr.Tag{"blossom", data.BlossomHash})
+	}
+
+	// Content categorization
+	event.Tags = event.Tags.AppendUnique(nostr.Tag{"t", "video"})
+	event.Tags = event.Tags.AppendUnique(nostr.Tag{"t", "p2p"})
+	event.Tags = event.Tags.AppendUnique(nostr.Tag{"t", "webtorrent"})
+	event.Tags = event.Tags.AppendUnique(nostr.Tag{"t", "streaming"})
+
+	// Quality tags
+	if data.VideoHeight >= 2160 {
+		event.Tags = event.Tags.AppendUnique(nostr.Tag{"t", "4k"})
+	} else if data.VideoHeight >= 1080 {
+		event.Tags = event.Tags.AppendUnique(nostr.Tag{"t", "hd"})
+	} else if data.VideoHeight >= 720 {
+		event.Tags = event.Tags.AppendUnique(nostr.Tag{"t", "hd"})
+	}
+
+	// Sign the event
+	err := event.Sign(p.privateKey)
+	if err != nil {
+		return nil, fmt.Errorf("error signing NIP-71 event: %w", err)
+	}
+
+	return event, nil
+}
--- a/internal/tracker/websocket.go
+++ b/internal/tracker/websocket.go
@ -0,0 +1,246 @@
+package tracker
+
+import (
+	"log"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+type WebSocketTracker struct {
+	upgrader websocket.Upgrader
+	swarms   map[string]*Swarm
+	mu       sync.RWMutex
+}
+
+type Swarm struct {
+	peers map[string]*WebRTCPeer
+	mu    sync.RWMutex
+}
+
+type WebRTCPeer struct {
+	ID         string          `json:"peer_id"`
+	Conn       *websocket.Conn `json:"-"`
+	LastSeen   time.Time       `json:"last_seen"`
+	InfoHashes []string        `json:"info_hashes"`
+}
+
+type WebTorrentMessage struct {
+	Action     string                 `json:"action"`
+	InfoHash   string                 `json:"info_hash,omitempty"`
+	PeerID     string                 `json:"peer_id,omitempty"`
+	Answer     map[string]interface{} `json:"answer,omitempty"`
+	Offer      map[string]interface{} `json:"offer,omitempty"`
+	ToPeerID   string                 `json:"to_peer_id,omitempty"`
+	FromPeerID string                 `json:"from_peer_id,omitempty"`
+	NumWant    int                    `json:"numwant,omitempty"`
+}
+
+func NewWebSocketTracker() *WebSocketTracker {
+	return &WebSocketTracker{
+		upgrader: websocket.Upgrader{
+			CheckOrigin: func(r *http.Request) bool {
+				return true // Allow all origins for WebTorrent compatibility
+			},
+		},
+		swarms: make(map[string]*Swarm),
+	}
+}
+
+func (wt *WebSocketTracker) HandleWS(w http.ResponseWriter, r *http.Request) {
+	conn, err := wt.upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		log.Printf("WebSocket upgrade failed: %v", err)
+		return
+	}
+	defer conn.Close()
+
+	log.Printf("WebTorrent client connected from %s", r.RemoteAddr)
+
+	// Handle WebTorrent protocol
+	for {
+		var msg WebTorrentMessage
+		if err := conn.ReadJSON(&msg); err != nil {
+			if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
+				log.Printf("WebSocket error: %v", err)
+			}
+			break
+		}
+
+		switch msg.Action {
+		case "announce":
+			wt.handleAnnounce(conn, msg)
+		case "scrape":
+			wt.handleScrape(conn, msg)
+		case "offer":
+			wt.handleOffer(conn, msg)
+		case "answer":
+			wt.handleAnswer(conn, msg)
+		}
+	}
+}
+
+func (wt *WebSocketTracker) handleAnnounce(conn *websocket.Conn, msg WebTorrentMessage) {
+	wt.mu.Lock()
+	defer wt.mu.Unlock()
+
+	// Get or create swarm
+	if wt.swarms[msg.InfoHash] == nil {
+		wt.swarms[msg.InfoHash] = &Swarm{
+			peers: make(map[string]*WebRTCPeer),
+		}
+	}
+	swarm := wt.swarms[msg.InfoHash]
+
+	swarm.mu.Lock()
+	defer swarm.mu.Unlock()
+
+	// Add/update peer
+	peer := &WebRTCPeer{
+		ID:         msg.PeerID,
+		Conn:       conn,
+		LastSeen:   time.Now(),
+		InfoHashes: []string{msg.InfoHash},
+	}
+	swarm.peers[msg.PeerID] = peer
+
+	// Return peer list (excluding the requesting peer)
+	var peers []map[string]interface{}
+	numWant := msg.NumWant
+	if numWant == 0 {
+		numWant = 30 // Default
+	}
+
+	count := 0
+	for peerID := range swarm.peers {
+		if peerID != msg.PeerID && count < numWant {
+			peers = append(peers, map[string]interface{}{
+				"id": peerID,
+			})
+			count++
+		}
+	}
+
+	response := map[string]interface{}{
+		"action":    "announce",
+		"interval":  300, // 5 minutes for WebTorrent
+		"info_hash": msg.InfoHash,
+		"complete":  len(swarm.peers), // Simplified
+		"incomplete": 0,
+		"peers":     peers,
+	}
+
+	if err := conn.WriteJSON(response); err != nil {
+		log.Printf("Failed to send announce response: %v", err)
+	}
+}
+
+func (wt *WebSocketTracker) handleScrape(conn *websocket.Conn, msg WebTorrentMessage) {
+	wt.mu.RLock()
+	defer wt.mu.RUnlock()
+
+	files := make(map[string]map[string]int)
+	if swarm := wt.swarms[msg.InfoHash]; swarm != nil {
+		swarm.mu.RLock()
+		files[msg.InfoHash] = map[string]int{
+			"complete":   len(swarm.peers), // Simplified
+			"incomplete": 0,
+			"downloaded": len(swarm.peers),
+		}
+		swarm.mu.RUnlock()
+	}
+
+	response := map[string]interface{}{
+		"action": "scrape",
+		"files":  files,
+	}
+
+	if err := conn.WriteJSON(response); err != nil {
+		log.Printf("Failed to send scrape response: %v", err)
+	}
+}
+
+func (wt *WebSocketTracker) handleOffer(conn *websocket.Conn, msg WebTorrentMessage) {
+	wt.mu.RLock()
+	defer wt.mu.RUnlock()
+
+	if swarm := wt.swarms[msg.InfoHash]; swarm != nil {
+		swarm.mu.RLock()
+		if targetPeer := swarm.peers[msg.ToPeerID]; targetPeer != nil {
+			// Forward offer to target peer
+			offerMsg := map[string]interface{}{
+				"action":        "offer",
+				"info_hash":     msg.InfoHash,
+				"peer_id":       msg.FromPeerID,
+				"offer":         msg.Offer,
+				"from_peer_id":  msg.FromPeerID,
+				"to_peer_id":    msg.ToPeerID,
+			}
+			if err := targetPeer.Conn.WriteJSON(offerMsg); err != nil {
+				log.Printf("Failed to forward offer: %v", err)
+			}
+		}
+		swarm.mu.RUnlock()
+	}
+}
+
+func (wt *WebSocketTracker) handleAnswer(conn *websocket.Conn, msg WebTorrentMessage) {
+	wt.mu.RLock()
+	defer wt.mu.RUnlock()
+
+	if swarm := wt.swarms[msg.InfoHash]; swarm != nil {
+		swarm.mu.RLock()
+		if targetPeer := swarm.peers[msg.ToPeerID]; targetPeer != nil {
+			// Forward answer to target peer
+			answerMsg := map[string]interface{}{
+				"action":        "answer",
+				"info_hash":     msg.InfoHash,
+				"peer_id":       msg.FromPeerID,
+				"answer":        msg.Answer,
+				"from_peer_id":  msg.FromPeerID,
+				"to_peer_id":    msg.ToPeerID,
+			}
+			if err := targetPeer.Conn.WriteJSON(answerMsg); err != nil {
+				log.Printf("Failed to forward answer: %v", err)
+			}
+		}
+		swarm.mu.RUnlock()
+	}
+}
+
+// Cleanup expired peers
+func (wt *WebSocketTracker) StartCleanup() {
+	ticker := time.NewTicker(5 * time.Minute)
+	go func() {
+		defer ticker.Stop()
+		for range ticker.C {
+			wt.cleanupExpiredPeers()
+		}
+	}()
+}
+
+func (wt *WebSocketTracker) cleanupExpiredPeers() {
+	wt.mu.Lock()
+	defer wt.mu.Unlock()
+
+	now := time.Now()
+	expiry := now.Add(-10 * time.Minute) // 10 minute timeout
+
+	for infoHash, swarm := range wt.swarms {
+		swarm.mu.Lock()
+		for peerID, peer := range swarm.peers {
+			if peer.LastSeen.Before(expiry) {
+				peer.Conn.Close()
+				delete(swarm.peers, peerID)
+			}
+		}
+		
+		// Remove empty swarms
+		if len(swarm.peers) == 0 {
+			delete(wt.swarms, infoHash)
+		}
+		swarm.mu.Unlock()
+	}
+}
--- a/internal/transcoding/manager.go
+++ b/internal/transcoding/manager.go
@ -0,0 +1,226 @@
+package transcoding
+
+import (
+	"database/sql"
+	"fmt"
+	"log"
+	"path/filepath"
+)
+
+// Manager coordinates transcoding with the existing storage system
+type Manager struct {
+	transcoder *Transcoder
+	db         *sql.DB
+	enabled    bool
+}
+
+// NewManager creates a new transcoding manager
+func NewManager(transcoder *Transcoder, db *sql.DB) *Manager {
+	return &Manager{
+		transcoder: transcoder,
+		db:         db,
+		enabled:    transcoder != nil && transcoder.IsEnabled(),
+	}
+}
+
+// QueueVideoForTranscoding adds a video file to the transcoding queue
+func (tm *Manager) QueueVideoForTranscoding(fileHash, fileName, filePath string, fileSize int64) {
+	if !tm.enabled {
+		return
+	}
+
+	// Check if already transcoded
+	if tm.HasTranscodedVersion(fileHash) {
+		log.Printf("File %s already has transcoded version, skipping", fileHash)
+		return
+	}
+
+	// Check if file needs transcoding
+	needsTranscoding, err := tm.transcoder.NeedsTranscoding(filePath)
+	if err != nil {
+		log.Printf("Error checking if %s needs transcoding: %v", fileName, err)
+		// Continue anyway - better to try and fail than skip
+	}
+
+	if !needsTranscoding {
+		log.Printf("File %s doesn't need transcoding (already web-compatible)", fileName)
+		tm.markAsWebCompatible(fileHash)
+		return
+	}
+
+	// Create transcoding job
+	job := Job{
+		ID:        fmt.Sprintf("transcode_%s", fileHash),
+		InputPath: filePath,
+		OutputDir: filepath.Join(tm.transcoder.workDir, fileHash),
+		FileHash:  fileHash,
+		Qualities: DefaultQualities,
+		Priority:  tm.calculatePriority(fileSize),
+		Callback: func(err error) {
+			if err != nil {
+				log.Printf("Transcoding failed for %s: %v", fileName, err)
+				tm.markTranscodingFailed(fileHash, err.Error())
+			} else {
+				log.Printf("Transcoding completed successfully for %s", fileName)
+				tm.markTranscodingCompleted(fileHash)
+			}
+		},
+	}
+
+	log.Printf("Queuing %s for transcoding (size: %.2f MB)", fileName, float64(fileSize)/1024/1024)
+	tm.transcoder.SubmitJob(job)
+	tm.markTranscodingQueued(fileHash)
+}
+
+// HasTranscodedVersion checks if a file has a transcoded version available
+func (tm *Manager) HasTranscodedVersion(fileHash string) bool {
+	if !tm.enabled {
+		return false
+	}
+
+	// Check file system
+	transcodedPath := tm.transcoder.GetTranscodedPath(fileHash)
+	if transcodedPath != "" {
+		return true
+	}
+
+	// Check database record
+	var status string
+	err := tm.db.QueryRow(`
+		SELECT status FROM transcoding_status 
+		WHERE file_hash = ? AND status IN ('completed', 'web_compatible')
+	`, fileHash).Scan(&status)
+	
+	return err == nil && (status == "completed" || status == "web_compatible")
+}
+
+// GetTranscodedPath returns the path to transcoded version if available
+func (tm *Manager) GetTranscodedPath(fileHash string) string {
+	if !tm.enabled {
+		return ""
+	}
+
+	return tm.transcoder.GetTranscodedPath(fileHash)
+}
+
+// GetTranscodingStatus returns the current status of transcoding for a file
+func (tm *Manager) GetTranscodingStatus(fileHash string) string {
+	if !tm.enabled {
+		return "disabled"
+	}
+
+	// First check if job is in progress
+	if job, exists := tm.transcoder.GetJobStatus(fmt.Sprintf("transcode_%s", fileHash)); exists {
+		return job.Status
+	}
+
+	// Check database
+	var status string
+	err := tm.db.QueryRow(`
+		SELECT status FROM transcoding_status WHERE file_hash = ?
+	`, fileHash).Scan(&status)
+	
+	if err != nil {
+		return "unknown"
+	}
+
+	return status
+}
+
+// GetJobProgress returns the progress percentage and whether the job exists
+func (tm *Manager) GetJobProgress(fileHash string) (float64, bool) {
+	if !tm.enabled {
+		return 0.0, false
+	}
+
+	jobID := fmt.Sprintf("transcode_%s", fileHash)
+	job, exists := tm.transcoder.GetJobStatus(jobID)
+	if !exists {
+		return 0.0, false
+	}
+
+	return job.Progress, true
+}
+
+// calculatePriority determines transcoding priority based on file characteristics
+func (tm *Manager) calculatePriority(fileSize int64) int {
+	priority := 5 // Default medium priority
+
+	if fileSize < 500*1024*1024 { // < 500MB
+		priority = 8 // Higher priority for smaller files (faster to transcode)
+	}
+
+	if fileSize > 5*1024*1024*1024 { // > 5GB
+		priority = 2 // Lower priority for very large files
+	}
+
+	return priority
+}
+
+// markTranscodingQueued records that a file has been queued for transcoding
+func (tm *Manager) markTranscodingQueued(fileHash string) {
+	tm.updateTranscodingStatus(fileHash, "queued")
+}
+
+// markTranscodingCompleted records that transcoding completed successfully
+func (tm *Manager) markTranscodingCompleted(fileHash string) {
+	tm.updateTranscodingStatus(fileHash, "completed")
+}
+
+// markTranscodingFailed records that transcoding failed
+func (tm *Manager) markTranscodingFailed(fileHash string, errorMsg string) {
+	_, err := tm.db.Exec(`
+		INSERT OR REPLACE INTO transcoding_status 
+		(file_hash, status, error_message, updated_at) 
+		VALUES (?, ?, ?, datetime('now'))
+	`, fileHash, "failed", errorMsg)
+	
+	if err != nil {
+		log.Printf("Warning: Failed to update transcoding status for %s: %v", fileHash, err)
+	}
+}
+
+// markAsWebCompatible records that a file doesn't need transcoding
+func (tm *Manager) markAsWebCompatible(fileHash string) {
+	tm.updateTranscodingStatus(fileHash, "web_compatible")
+}
+
+// updateTranscodingStatus updates the transcoding status in database
+func (tm *Manager) updateTranscodingStatus(fileHash, status string) {
+	if tm.db == nil {
+		return
+	}
+
+	_, err := tm.db.Exec(`
+		INSERT OR REPLACE INTO transcoding_status 
+		(file_hash, status, updated_at) 
+		VALUES (?, ?, datetime('now'))
+	`, fileHash, status)
+	
+	if err != nil {
+		log.Printf("Warning: Failed to update transcoding status for %s: %v", fileHash, err)
+	}
+}
+
+// InitializeDatabase creates the transcoding status table if it doesn't exist
+func (tm *Manager) InitializeDatabase() error {
+	if tm.db == nil {
+		return fmt.Errorf("no database connection")
+	}
+
+	_, err := tm.db.Exec(`
+		CREATE TABLE IF NOT EXISTS transcoding_status (
+			file_hash TEXT PRIMARY KEY,
+			status TEXT NOT NULL,
+			error_message TEXT,
+			created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+			updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+		)
+	`)
+
+	if err != nil {
+		return fmt.Errorf("failed to create transcoding_status table: %w", err)
+	}
+
+	return nil
+}
--- a/internal/transcoding/transcoder.go
+++ b/internal/transcoding/transcoder.go
@ -0,0 +1,236 @@
+package transcoding
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// Quality represents a transcoding quality profile
+type Quality struct {
+	Name     string `json:"name"`
+	Width    int    `json:"width"`
+	Height   int    `json:"height"`
+	Bitrate  string `json:"bitrate"`
+	Preset   string `json:"preset"`
+}
+
+// Job represents a transcoding job
+type Job struct {
+	ID          string    `json:"id"`
+	InputPath   string    `json:"input_path"`
+	OutputDir   string    `json:"output_dir"`
+	FileHash    string    `json:"file_hash"`
+	Qualities   []Quality `json:"qualities"`
+	Priority    int       `json:"priority"`
+	Status      string    `json:"status"` // "queued", "processing", "completed", "failed"
+	Progress    float64   `json:"progress"`
+	Error       string    `json:"error,omitempty"`
+	StartTime   time.Time `json:"start_time"`
+	CompletedAt time.Time `json:"completed_at,omitempty"`
+	Callback    func(error) `json:"-"`
+}
+
+// Transcoder handles video transcoding operations
+type Transcoder struct {
+	workDir     string
+	ffmpegPath  string
+	concurrent  int
+	queue       chan Job
+	jobs        map[string]*Job // Track job status
+	enabled     bool
+}
+
+// DefaultQualities provides standard quality profiles
+var DefaultQualities = []Quality{
+	{Name: "1080p", Width: 1920, Height: 1080, Bitrate: "5000k", Preset: "fast"},
+	{Name: "720p", Width: 1280, Height: 720, Bitrate: "2500k", Preset: "fast"},
+	{Name: "480p", Width: 854, Height: 480, Bitrate: "1000k", Preset: "fast"},
+}
+
+// NewTranscoder creates a new transcoder instance
+func NewTranscoder(workDir string, concurrent int, enabled bool) (*Transcoder, error) {
+	if !enabled {
+		return &Transcoder{
+			enabled: false,
+			jobs:    make(map[string]*Job),
+		}, nil
+	}
+
+	// Verify FFmpeg is available
+	if _, err := exec.LookPath("ffmpeg"); err != nil {
+		return nil, fmt.Errorf("ffmpeg not found in PATH: %w", err)
+	}
+
+	// Create work directory if it doesn't exist
+	if err := os.MkdirAll(workDir, 0755); err != nil {
+		return nil, fmt.Errorf("failed to create work directory: %w", err)
+	}
+
+	t := &Transcoder{
+		workDir:     workDir,
+		ffmpegPath:  "ffmpeg",
+		concurrent:  concurrent,
+		queue:       make(chan Job, 100),
+		jobs:        make(map[string]*Job),
+		enabled:     true,
+	}
+
+	// Start worker goroutines
+	for i := 0; i < concurrent; i++ {
+		go t.worker()
+	}
+
+	return t, nil
+}
+
+// IsEnabled returns whether transcoding is enabled
+func (t *Transcoder) IsEnabled() bool {
+	return t.enabled
+}
+
+// worker processes jobs from the queue
+func (t *Transcoder) worker() {
+	for job := range t.queue {
+		t.processJob(job)
+	}
+}
+
+// SubmitJob adds a job to the transcoding queue
+func (t *Transcoder) SubmitJob(job Job) {
+	if !t.enabled {
+		if job.Callback != nil {
+			job.Callback(fmt.Errorf("transcoding is disabled"))
+		}
+		return
+	}
+
+	job.Status = "queued"
+	job.StartTime = time.Now()
+	t.jobs[job.ID] = &job
+	t.queue <- job
+}
+
+// GetJobStatus returns the current status of a job
+func (t *Transcoder) GetJobStatus(jobID string) (*Job, bool) {
+	job, exists := t.jobs[jobID]
+	return job, exists
+}
+
+// NeedsTranscoding checks if a file needs transcoding for web compatibility
+func (t *Transcoder) NeedsTranscoding(filePath string) (bool, error) {
+	if !t.enabled {
+		return false, nil
+	}
+
+	// Use ffprobe to analyze the file
+	cmd := exec.Command("ffprobe", "-v", "quiet", "-print_format", "json", "-show_format", "-show_streams", filePath)
+	output, err := cmd.Output()
+	if err != nil {
+		return true, err // Assume needs transcoding if we can't analyze
+	}
+
+	outputStr := string(output)
+
+	// Check if already in web-friendly format
+	hasH264 := strings.Contains(outputStr, "\"codec_name\": \"h264\"")
+	hasAAC := strings.Contains(outputStr, "\"codec_name\": \"aac\"")
+	isMP4 := strings.HasSuffix(strings.ToLower(filePath), ".mp4")
+
+	// If it's H.264/AAC in MP4 container, probably doesn't need transcoding
+	if hasH264 && hasAAC && isMP4 {
+		return false, nil
+	}
+
+	return true, nil
+}
+
+// CreateStreamingVersion creates a single web-compatible MP4 version
+func (t *Transcoder) CreateStreamingVersion(inputPath, outputPath string) error {
+	if !t.enabled {
+		return fmt.Errorf("transcoding is disabled")
+	}
+
+	// Ensure output directory exists
+	if err := os.MkdirAll(filepath.Dir(outputPath), 0755); err != nil {
+		return fmt.Errorf("failed to create output directory: %w", err)
+	}
+
+	args := []string{
+		"-i", inputPath,
+		"-c:v", "libx264",      // H.264 video codec
+		"-c:a", "aac",          // AAC audio codec  
+		"-preset", "fast",      // Balance speed/quality
+		"-crf", "23",           // Quality (23 is default, lower = better)
+		"-maxrate", "2M",       // Max bitrate for streaming
+		"-bufsize", "4M",       // Buffer size
+		"-movflags", "+faststart", // Enable fast start for web
+		"-y",                   // Overwrite output file
+		outputPath,
+	}
+
+	cmd := exec.Command(t.ffmpegPath, args...)
+	return cmd.Run()
+}
+
+// processJob handles the actual transcoding work
+func (t *Transcoder) processJob(job Job) {
+	job.Status = "processing"
+	t.jobs[job.ID] = &job
+
+	var err error
+	defer func() {
+		if err != nil {
+			job.Status = "failed"
+			job.Error = err.Error()
+		} else {
+			job.Status = "completed"
+			job.Progress = 100.0
+		}
+		job.CompletedAt = time.Now()
+		t.jobs[job.ID] = &job
+		
+		if job.Callback != nil {
+			job.Callback(err)
+		}
+	}()
+
+	// Create output directory
+	if err = os.MkdirAll(job.OutputDir, 0755); err != nil {
+		err = fmt.Errorf("failed to create output directory: %w", err)
+		return
+	}
+
+	// Create streaming MP4 version (most important for web compatibility)
+	outputPath := filepath.Join(job.OutputDir, "stream.mp4")
+	err = t.CreateStreamingVersion(job.InputPath, outputPath)
+	if err != nil {
+		err = fmt.Errorf("transcoding failed: %w", err)
+		return
+	}
+
+	job.Progress = 100.0
+}
+
+// GetTranscodedPath returns the path to a transcoded file if it exists
+func (t *Transcoder) GetTranscodedPath(fileHash string) string {
+	if !t.enabled {
+		return ""
+	}
+
+	streamPath := filepath.Join(t.workDir, fileHash, "stream.mp4")
+	if _, err := os.Stat(streamPath); err == nil {
+		return streamPath
+	}
+	return ""
+}
+
+// Close shuts down the transcoder
+func (t *Transcoder) Close() {
+	if t.enabled && t.queue != nil {
+		close(t.queue)
+	}
+}
--- a/internal/web/index.html
+++ b/internal/web/index.html
@ -212,7 +212,7 @@
                <div class="about-content">
                    <div class="intro-section">
                        <h3>What This Platform Does</h3>
-                        <p>The BitTorrent Gateway is a next-generation content distribution system that combines the reliability of traditional web hosting with the power of peer-to-peer networks and decentralized social discovery through Nostr. It automatically chooses the best way to store and distribute your files:</p>
+                        <p>The BitTorrent Gateway is a next-generation content distribution system that combines the reliability of traditional web hosting with the power of peer-to-peer networks, automatic video transcoding, and decentralized social discovery through Nostr. It automatically chooses the best way to store, process, and distribute your files:</p>
                        
                        <div class="storage-flow">
                            <div class="flow-item">
@ -230,6 +230,14 @@
                                    <p>Automatically chunked into 2MB pieces with torrent + DHT distribution</p>
                                </div>
                            </div>
+                            <div class="flow-arrow">→</div>
+                            <div class="flow-item">
+                                <div class="flow-icon">🎬</div>
+                                <div class="flow-content">
+                                    <strong>Video Processing</strong>
+                                    <p>Automatic H.264/AAC transcoding for universal web compatibility</p>
+                                </div>
+                            </div>
                        </div>
                        
                        <div class="key-benefits">
@ -259,6 +267,12 @@
                                        <strong>Cost Effective:</strong> P2P distribution reduces bandwidth costs for large files
                                    </div>
                                </div>
+                                <div class="benefit-item">
+                                    <span class="benefit-icon">🎬</span>
+                                    <div class="benefit-content">
+                                        <strong>Universal Video Playback:</strong> Automatic transcoding ensures videos play in any browser
+                                    </div>
+                                </div>
                            </div>
                        </div>
                    </div>
@ -280,7 +294,7 @@
                                <div class="step-number">2</div>
                                <div class="step-content">
                                    <h5>Automatic Processing</h5>
-                                    <p>System creates torrents, generates magnet links, and sets up WebSeed URLs</p>
+                                    <p>System creates torrents, transcodes videos to web formats, generates magnet links, and sets up WebSeed URLs</p>
                                </div>
                            </div>
                            <div class="flow-arrow">↓</div>
@ -380,8 +394,8 @@
                                <div class="step">
                                    <span class="step-number">2</span>
                                    <div class="step-content">
-                                        <strong>Storage & Distribution</strong>
-                                        <p>Small files stored as blobs, large files chunked and torrents created</p>
+                                        <strong>Storage & Processing</strong>
+                                        <p>Small files stored as blobs, large files chunked, videos queued for transcoding</p>
                                    </div>
                                </div>
                                <div class="step">
@ -447,6 +461,13 @@
                                    <p>LRU caching system, concurrent processing, geographic peer selection, and connection pooling</p>
                                </div>
                            </div>
+                            <div class="feature-card">
+                                <div class="feature-icon">🎬</div>
+                                <div class="feature-content">
+                                    <h4>Automatic Video Transcoding</h4>
+                                    <p>Background H.264/AAC conversion with priority queuing, progress tracking, and smart serving</p>
+                                </div>
+                            </div>
                        </div>
                    </div>

@ -455,9 +476,9 @@
                        <div class="component-list">
                            <div class="component">
                                <h4>🚀 Gateway Server (Port 9877)</h4>
-                                <p>Main API server with WebSeed implementation, smart proxy for chunked content reassembly, advanced LRU caching system, and comprehensive security middleware.</p>
+                                <p>Main API server with WebSeed implementation, smart proxy for chunked content reassembly, advanced LRU caching system, video transcoding engine, and comprehensive security middleware.</p>
                                <div class="component-specs">
-                                    <span>WebSeed (BEP-19) • Rate Limiting • Abuse Prevention</span>
+                                    <span>WebSeed (BEP-19) • Video Transcoding • Rate Limiting • Abuse Prevention</span>
                                </div>
                            </div>
                            
@ -537,6 +558,11 @@
                                    <code>/api/health</code>
                                    <span class="desc">Component health status</span>
                                </div>
+                                <div class="endpoint">
+                                    <span class="method get">GET</span>
+                                    <code>/api/users/me/files/{hash}/transcoding-status</code>
+                                    <span class="desc">Video transcoding progress and status</span>
+                                </div>
                            </div>
                        </div>
                        
@ -648,6 +674,7 @@
                            <span class="protocol-badge">BitTorrent Protocol</span>
                            <span class="protocol-badge">WebSeed (BEP-19)</span>
                            <span class="protocol-badge">HLS Streaming</span>
+                            <span class="protocol-badge">H.264/AAC Transcoding</span>
                            <span class="protocol-badge">Blossom Protocol</span>
                            <span class="protocol-badge">Nostr (NIP-35)</span>
                            <span class="protocol-badge">Kademlia DHT</span>
--- a/internal/web/player.html
+++ b/internal/web/player.html
@ -6,6 +6,7 @@
    <title>Video Player - Blossom Gateway</title>
    <link rel="stylesheet" href="/static/style.css">
    <script src="/static/hls.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/webtorrent/latest/webtorrent.min.js"></script>
 </head>
 <body>
    <div class="container">
@ -71,6 +72,9 @@
                        <button onclick="openWebSeed()" class="modern-btn secondary">
                            🌐 WebSeed
                        </button>
+                        <button onclick="toggleP2P()" class="modern-btn secondary" id="p2p-toggle">
+                            🔗 Enable P2P
+                        </button>
                    </div>
                </div>

@ -127,6 +131,18 @@
                            <div class="stat-label">Dropped Frames:</div>
                            <div id="dropped-frames" class="stat-value">--</div>
                        </div>
+                        <div class="stat-item">
+                            <div class="stat-label">P2P Peers:</div>
+                            <div id="p2p-peers" class="stat-value">0</div>
+                        </div>
+                        <div class="stat-item">
+                            <div class="stat-label">P2P Download:</div>
+                            <div id="p2p-download" class="stat-value">0 KB/s</div>
+                        </div>
+                        <div class="stat-item">
+                            <div class="stat-label">P2P Upload:</div>
+                            <div id="p2p-upload" class="stat-value">0 KB/s</div>
+                        </div>
                    </div>
                </div>
            </div>
--- a/internal/web/static/player.js
+++ b/internal/web/static/player.js
@ -5,6 +5,9 @@ class VideoPlayer {
        this.video = null;
        this.videoHash = null;
        this.videoName = null;
+        this.webTorrentClient = null;
+        this.currentTorrent = null;
+        this.isP2PEnabled = false;
        this.stats = {
            startTime: Date.now(),
            bytesLoaded: 0,
@ -20,6 +23,14 @@ class VideoPlayer {
        
        // Update stats every second
        setInterval(() => this.updatePlaybackStats(), 1000);
+        
+        // Initialize WebTorrent client
+        if (typeof WebTorrent !== 'undefined') {
+            this.webTorrentClient = new WebTorrent();
+            console.log('WebTorrent client initialized');
+        } else {
+            console.warn('WebTorrent not available');
+        }
    }

    initializeFromURL() {
@ -619,6 +630,108 @@ function toggleTheme() {
    localStorage.setItem('theme', newTheme);
 }

+// P2P toggle function
+function toggleP2P() {
+    if (!player || !player.webTorrentClient) {
+        showToastMessage('WebTorrent not available in this browser', 'error');
+        return;
+    }
+    
+    if (player.isP2PEnabled) {
+        player.disableP2P();
+    } else {
+        player.enableP2P();
+    }
+}
+
+// Add P2P methods to VideoPlayer class
+VideoPlayer.prototype.enableP2P = async function() {
+    if (!this.webTorrentClient || this.isP2PEnabled) return;
+    
+    try {
+        const response = await fetch(`/api/webtorrent/${this.videoHash}`);
+        if (!response.ok) throw new Error('Failed to get WebTorrent info');
+        
+        const data = await response.json();
+        const magnetURI = data.magnet_uri;
+        
+        showToastMessage('Connecting to P2P network...', 'info');
+        document.getElementById('p2p-toggle').textContent = '⏳ Connecting...';
+        
+        this.webTorrentClient.add(magnetURI, (torrent) => {
+            this.currentTorrent = torrent;
+            this.isP2PEnabled = true;
+            
+            // Find video file
+            const file = torrent.files.find(f => 
+                f.name.endsWith('.mp4') || 
+                f.name.endsWith('.webm') ||
+                f.name.endsWith('.mkv') ||
+                f.name.endsWith('.avi')
+            );
+            
+            if (file) {
+                // Prioritize sequential download for streaming
+                file.select();
+                
+                // Replace video source with P2P stream
+                file.streamTo(this.video);
+                showToastMessage('P2P streaming enabled!', 'success');
+                document.getElementById('p2p-toggle').textContent = '🔗 Disable P2P';
+                
+                // Update P2P stats
+                this.updateP2PStats();
+                this.p2pStatsInterval = setInterval(() => this.updateP2PStats(), 1000);
+            }
+        });
+        
+    } catch (error) {
+        console.error('P2P enable error:', error);
+        showToastMessage('Failed to enable P2P streaming', 'error');
+        document.getElementById('p2p-toggle').textContent = '🔗 Enable P2P';
+    }
+};
+
+VideoPlayer.prototype.disableP2P = function() {
+    if (!this.isP2PEnabled) return;
+    
+    if (this.currentTorrent) {
+        this.currentTorrent.destroy();
+        this.currentTorrent = null;
+    }
+    
+    if (this.p2pStatsInterval) {
+        clearInterval(this.p2pStatsInterval);
+        this.p2pStatsInterval = null;
+    }
+    
+    this.isP2PEnabled = false;
+    document.getElementById('p2p-toggle').textContent = '🔗 Enable P2P';
+    
+    // Reset P2P stats
+    document.getElementById('p2p-peers').textContent = '0';
+    document.getElementById('p2p-download').textContent = '0 KB/s';
+    document.getElementById('p2p-upload').textContent = '0 KB/s';
+    
+    // Revert to direct streaming
+    this.initializeDirectStreaming();
+    showToastMessage('Switched back to direct streaming', 'info');
+};
+
+VideoPlayer.prototype.updateP2PStats = function() {
+    if (!this.currentTorrent) return;
+    
+    document.getElementById('p2p-peers').textContent = this.currentTorrent.numPeers;
+    document.getElementById('p2p-download').textContent = this.formatSpeed(this.currentTorrent.downloadSpeed);
+    document.getElementById('p2p-upload').textContent = this.formatSpeed(this.currentTorrent.uploadSpeed);
+};
+
+VideoPlayer.prototype.formatSpeed = function(bytes) {
+    if (bytes < 1024) return bytes + ' B/s';
+    if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB/s';
+    return (bytes / 1024 / 1024).toFixed(1) + ' MB/s';
+};
+
 // Initialize player when page loads
 let player;
 document.addEventListener('DOMContentLoaded', () => {
--- a/BIN
+++ b/BIN