NetFlacks is a cutting-edge peer-to-peer video streaming platform that eliminates reliance on centralized servers by distributing video content across a network of participating nodes. Built from the ground up with modern networking principles, it demonstrates scalable architecture, distributed systems design, and real-time media processing.

Progressive Streaming + P2P Distribution: Videos start playing almost instantly while chunks are fetched from multiple peers simultaneously, creating a Netflix-like experience powered by decentralized infrastructure.

graph TB
    subgraph "Client Layer"
        UI[Streamlit Web UI]
        Browser[HTML5 Video Player]
    end
    
    subgraph "Application Layer"
        SS[Streaming Server<br/>FastAPI]
        FC[File Processor<br/>FFmpeg Integration]
    end
    
    subgraph "P2P Network Layer"
        DHT[Distributed Hash Table<br/>Peer Coordination]
        P1[Peer Node 1<br/>Chunk Storage]
        P2[Peer Node 2<br/>Chunk Storage]
        P3[Peer Node N<br/>Chunk Storage]
    end
    
    subgraph "Data Layer"
        CH1[Video Chunks<br/>1MB segments]
        CH2[Metadata<br/>JSON indexes]
        CH3[Hash Verification<br/>SHA-256]
    end
    
    UI --> SS
    Browser --> SS
    SS --> DHT
    SS --> FC
    DHT --> P1
    DHT --> P2
    DHT --> P3
    P1 --> CH1
    P2 --> CH1
    P3 --> CH1
    FC --> CH2
    FC --> CH3
    
    style DHT fill:#ff6b6b
    style SS fill:#4ecdc4
    style UI fill:#45b7d1
    style P1 fill:#96ceb4
    style P2 fill:#96ceb4
    style P3 fill:#96ceb4

# Custom P2P Protocol Implementation
class PeerNode:
    def __init__(self, peer_id, host, port):
        self.peer_id = peer_id
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.dht_node = DHTNode()
        self.chunk_storage = {}
    
    async def handle_chunk_request(self, chunk_hash):
        # Asynchronous chunk serving with integrity verification
        chunk_data = self.load_chunk(chunk_hash)
        if self.verify_hash(chunk_data, chunk_hash):
            return chunk_data

# FFmpeg integration for streaming optimization
def optimize_for_streaming(video_path):
    """Relocate MP4 moov atom for instant playback"""
    cmd = [
        'ffmpeg', '-i', video_path,
        '-c', 'copy',
        '-movflags', 'faststart',
        optimized_path
    ]
    subprocess.run(cmd)

class DHT:
    def __init__(self):
        self.peers = {}
        self.chunk_locations = {}
        self.redistributor = Redistributor()
    
    def find_chunk_peers(self, chunk_hash):
        """Consistent hashing for optimal peer selection"""
        return self.redistributor.get_closest_peers(chunk_hash)

# System requirements
Python 3.8+
FFmpeg (for video processing)
Network ports 8000-9000 available

# Clone the repository
git clone https://github.com/abrr-fhyz/Peer2PeerNetwork.git
cd Peer2PeerNetwork

# Install dependencies
pip install -r requirements.txt
pip install fastapi['all']
pip install streamlit

# Verify FFmpeg installation
ffmpeg -version

#In the .env file,paste the following lines
HOST_IP=localhost
HOST_PORT=9004
DHT_PORT=8000
API_PORT=8080

# Terminal 1: Start Streaming Server
python streaming_server.py

# Terminal 2: Launch Web Interface
streamlit run main.py

1. Upload → Select video file through web interface
2. Process → System optimizes and chunks the video automatically
3. Distribute → Chunks spread across peer network via DHT
4. Stream → Click play for instant Netflix-like experience

• ✅ Custom P2P Protocol: Built networking stack from scratch using raw sockets
• ✅ Distributed Architecture: Implemented consistent hashing for scalable peer management
• ✅ Real-time Streaming: Achieved sub-3-second startup times with progressive loading
• ✅ Media Optimization: Integrated FFmpeg for instant-playback video processing
• ✅ Fault Tolerance: Redundant chunk storage with automatic peer failure handling

• 🏗️ Modular Design: Clean separation of concerns with OOP principles
• 🔄 Async Operations: Non-blocking I/O for concurrent peer communications
• 🛡️ Data Integrity: SHA-256 verification for all transmitted chunks
• 📊 Performance Monitoring: Real-time network status and streaming metrics
• 🎨 Modern UI: Responsive web interface with live progress tracking

sequenceDiagram
    participant U as User
    participant UI as Web Interface
    participant SS as Streaming Server
    participant DHT as DHT Coordinator
    participant P1 as Peer Node 1
    participant P2 as Peer Node 2
    
    U->>UI: Upload Video
    UI->>SS: Process Video Request
    SS->>SS: FFmpeg Optimization
    SS->>SS: Chunk Generation (1MB)
    SS->>DHT: Register Video Metadata
    SS->>DHT: Find Storage Peers
    DHT->>P1: Store Chunks 1,3,5...
    DHT->>P2: Store Chunks 2,4,6...
    
    Note over U,P2: Streaming Phase
    
    U->>UI: Click Play
    UI->>SS: Stream Request
    SS->>DHT: Get Chunk Locations
    DHT->>SS: Return Peer List
    
    par Concurrent Chunk Retrieval
        SS->>P1: Request Chunk 1
        P1->>SS: Return Chunk 1
    and
        SS->>P2: Request Chunk 2
        P2->>SS: Return Chunk 2
    end
    
    SS->>UI: HTTP Stream Response
    UI->>U: Video Playback Starts

• Hybrid P2P Architecture: Balances decentralization with streaming performance
• Progressive Chunk Assembly: On-the-fly video reconstruction with seeking support
• Intelligent Peer Selection: Distance-based DHT routing for optimal chunk placement
• Streaming Buffer Management: Predictive downloading for smooth playback

Course: CSE 3111 - Computer Networking
Institution: University of Dhaka, Department of Computer Science & Engineering
Session: 3rd Year 1st Semester

• Socket Programming (TCP/UDP)
• Application Layer Protocols
• Distributed Hash Tables
• Peer-to-Peer Architecture
• Media Streaming Protocols
• Network Performance Optimization

• Scalability: Successfully tested with 4+ concurrent peers
• Performance: < 3-second video startup time achieved
• Reliability: Maintained streaming during peer disconnections
• User Experience: Netflix-comparable interface and functionality

• ✅ Progressive streaming without full download
• ✅ Instant seeking within downloaded portions
• ✅ Automatic chunk redistribution on peer failure
• ✅ Real-time network status monitoring
• ✅ Cross-platform compatibility

• License: MIT License