┌─────────────────┐
│  Master Playlist │ ──► Contains multiple bitrate sub-playlists
└─────────────────┘
         │
         ├── 1080p.m3u8 ──► HD playlist
         ├── 720p.m3u8  ──► SD playlist
         └── 480p.m3u8  ──► Smooth playlist

# Windows (using pip)
pip install -U yt-dlp

# macOS
brew install yt-dlp

# Linux
sudo wget https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp -O /usr/local/bin/yt-dlp
sudo chmod a+rx /usr/local/bin/yt-dlp

# Download M3U8 video
yt-dlp "https://example.com/video.m3u8"

# Specify output filename
yt-dlp -o "video.mp4" "https://example.com/video.m3u8"

# Select best quality
yt-dlp -f "best[ext=mp4]/best" URL

# List all available formats
yt-dlp -F URL

# Download with proxy
yt-dlp --proxy socks5://127.0.0.1:1080 URL

# Limit download speed
yt-dlp --limit-rate 500K URL

# Add cookies (for login-required videos)
yt-dlp --cookies cookies.txt URL

# Batch download from list
yt-dlp -a urls.txt

# Download subtitles
yt-dlp --write-sub --sub-lang en,zh URL

# Embed subtitles in video
yt-dlp --embed-subs URL

# Use aria2c for acceleration
yt-dlp --external-downloader aria2c --external-downloader-args "-x 16 -k 1M" URL

# Default output format
-o "~/Downloads/%(title)s.%(ext)s"

# Auto-select best format
-f "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best"

# Embed thumbnail and subtitles
--embed-thumbnail
--embed-subs

# Use aria2c for acceleration
--external-downloader aria2c
--external-downloader-args "-x 16 -k 1M"

# Keep original modification time
--no-mtime

# Download latest version
# Windows: Download exe file
# macOS/Linux: Download corresponding binary

# Basic usage
N_m3u8DL-RE "https://example.com/video.m3u8" --save-name "output"

# Auto-select highest quality
N_m3u8DL-RE URL --auto-select

# Set concurrent threads
N_m3u8DL-RE URL --thread-count 16

# Set temporary directory
N_m3u8DL-RE URL --tmp-dir /path/to/tmp

# Use custom headers
N_m3u8DL-RE URL --header "Referer: https://example.com"

# Handle encrypted video
N_m3u8DL-RE URL --key "AES128KEY"

# Live stream recording
N_m3u8DL-RE URL --live-real-time-merge

# Basic download
ffmpeg -i "https://example.com/video.m3u8" -c copy output.mp4

# Set timeout and retry
ffmpeg -timeout 5000000 -reconnect 1 -reconnect_at_eof 1 -reconnect_streamed 1 -reconnect_delay_max 2 -i URL -c copy output.mp4

# Specify User-Agent
ffmpeg -user_agent "Mozilla/5.0" -i URL -c copy output.mp4

# Add multiple headers
ffmpeg -headers $'Referer: https://example.com\r\nCookie: session=abc123' -i URL -c copy output.mp4

# Download specific time range
ffmpeg -ss 00:10:00 -t 00:05:00 -i URL -c copy output.mp4

# Handle HTTPS certificate issues
ffmpeg -nostdin -y -loglevel error -tls_verify 0 -i URL -c copy output.mp4

1. Media → Open Network Stream
2. Enter M3U8 link
3. Tools → Codec Information
4. Copy Location
5. Media → Convert/Save

// Supported browsers: Chrome, Firefox, Edge
// Features:
- Auto-detect M3U8 streams
- One-click download & conversion
- Segment merging support
- Batch download management

// Execute in console to get all M3U8 links
(() => {
    const urls = [];
    const entries = performance.getEntriesByType('resource');
    entries.forEach(entry => {
        if (entry.name.includes('.m3u8')) {
            urls.push(entry.name);
        }
    });
    console.log('Found M3U8 URLs:', urls);
    return urls;
})();

// Features
- Built-in browser
- Download manager
- File management
- Video player

// Usage steps
1. Open built-in browser
2. Navigate to M3U8 link
3. Long press link to download
4. Check progress in download manager

// Create download shortcut
1. Get clipboard content
2. Get URL content
3. Save to file
4. Shortcuts automation

// Configuration suggestions
- Threads: 16
- Segment size: 1MB
- Auto-resume: Enabled
- Background download: Allowed

// M3U8-specific features
- HLS stream detection
- Automatic merging
- Batch queue
- Speed limiting

import requests
from Crypto.Cipher import AES
import os

def decrypt_ts(encrypted_data, key, iv):
    """Decrypt TS segment"""
    cipher = AES.new(key, AES.MODE_CBC, iv)
    return cipher.decrypt(encrypted_data)

def download_encrypted_m3u8(m3u8_url, key_url):
    """Download encrypted M3U8 video"""
    # Get key
    key = requests.get(key_url).content
    
    # Parse M3U8
    m3u8_content = requests.get(m3u8_url).text
    
    # Download and decrypt segments
    for line in m3u8_content.split('\n'):
        if line.endswith('.ts'):
            ts_url = urljoin(m3u8_url, line)
            encrypted_data = requests.get(ts_url).content
            
            # Decrypt
            iv = os.urandom(16)  # Or get from M3U8
            decrypted_data = decrypt_ts(encrypted_data, key, iv)
            
            # Save decrypted data
            with open(f'decrypted_{line}', 'wb') as f:
                f.write(decrypted_data)

import concurrent.futures
import requests
from pathlib import Path
import m3u8

class M3U8Downloader:
    def __init__(self, max_workers=10):
        self.max_workers = max_workers
        self.session = requests.Session()
        self.session.headers.update({
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
        })
    
    def download_segment(self, url, output_path):
        """Download single segment"""
        try:
            response = self.session.get(url, timeout=30)
            response.raise_for_status()
            
            with open(output_path, 'wb') as f:
                f.write(response.content)
            return True
        except Exception as e:
            print(f"Error downloading {url}: {e}")
            return False
    
    def download_m3u8(self, m3u8_url, output_dir):
        """Download complete M3U8 video"""
        # Create output directory
        Path(output_dir).mkdir(parents=True, exist_ok=True)
        
        # Parse M3U8
        playlist = m3u8.load(m3u8_url)
        
        # Prepare download tasks
        download_tasks = []
        for i, segment in enumerate(playlist.segments):
            segment_url = urljoin(m3u8_url, segment.uri)
            output_path = Path(output_dir) / f"segment_{i:05d}.ts"
            download_tasks.append((segment_url, output_path))
        
        # Parallel download
        with concurrent.futures.ThreadPoolExecutor(max_workers=self.max_workers) as executor:
            futures = [
                executor.submit(self.download_segment, url, path)
                for url, path in download_tasks
            ]
            
            # Show progress
            completed = 0
            total = len(futures)
            for future in concurrent.futures.as_completed(futures):
                completed += 1
                print(f"Progress: {completed}/{total} ({completed*100/total:.1f}%)")
        
        # Merge files
        self.merge_segments(output_dir)
    
    def merge_segments(self, segment_dir):
        """Merge all segments"""
        output_file = Path(segment_dir).parent / "output.mp4"
        
        # Create file list
        segments = sorted(Path(segment_dir).glob("*.ts"))
        
        # Use FFmpeg to merge
        import subprocess
        concat_file = Path(segment_dir) / "concat.txt"
        
        with open(concat_file, 'w') as f:
            for segment in segments:
                f.write(f"file '{segment.absolute()}'\n")
        
        cmd = [
            'ffmpeg', '-f', 'concat', '-safe', '0',
            '-i', str(concat_file), '-c', 'copy', str(output_file)
        ]
        subprocess.run(cmd)
        print(f"Video saved to: {output_file}")

# Usage example
downloader = M3U8Downloader(max_workers=16)
downloader.download_m3u8("https://example.com/video.m3u8", "./download")

import os
import requests
from urllib.parse import urlparse

class ResumableDownloader:
    def __init__(self):
        self.chunk_size = 1024 * 1024  # 1MB
    
    def download_with_resume(self, url, output_file):
        """Download with resume support"""
        headers = {}
        mode = 'wb'
        resume_pos = 0
        
        # Check for incomplete download
        if os.path.exists(output_file):
            resume_pos = os.path.getsize(output_file)
            headers['Range'] = f'bytes={resume_pos}-'
            mode = 'ab'
        
        response = requests.get(url, headers=headers, stream=True)
        
        # Check if server supports resume
        if response.status_code == 206:  # Partial Content
            print(f"Resuming download from {resume_pos} bytes")
        elif response.status_code == 200:
            print("Starting fresh download")
            mode = 'wb'
        else:
            raise Exception(f"Error: {response.status_code}")
        
        # Download file
        with open(output_file, mode) as f:
            for chunk in response.iter_content(chunk_size=self.chunk_size):
                if chunk:
                    f.write(chunk)
        
        print(f"Download completed: {output_file}")

# Use aria2c for acceleration
yt-dlp --external-downloader aria2c \
       --external-downloader-args "-x 16 -s 16 -k 1M" URL

# N_m3u8DL-RE multi-threading
N_m3u8DL-RE URL --thread-count 32

def test_cdn_speed(urls):
    """Test CDN node speed"""
    import time
    speeds = {}
    
    for url in urls:
        start = time.time()
        response = requests.head(url)
        elapsed = time.time() - start
        speeds[url] = elapsed
    
    # Select fastest node
    fastest = min(speeds, key=speeds.get)
    return fastest

def download_large_file(url, chunk_size=8192):
    """Stream download large files to avoid memory overflow"""
    response = requests.get(url, stream=True)
    
    with open('output.ts', 'wb') as f:
        for chunk in response.iter_content(chunk_size=chunk_size):
            if chunk:
                f.write(chunk)
                # Optional: show progress
                downloaded = f.tell()
                print(f"Downloaded: {downloaded:,} bytes", end='\r')

# Solution 1: Add Referer
ffmpeg -headers "Referer: https://example.com" -i URL output.mp4

# Solution 2: Use cookies
yt-dlp --cookies cookies.txt URL

# Solution 3: Modify User-Agent
wget --user-agent="Mozilla/5.0" URL

// Browser extension to bypass CORS
chrome.webRequest.onBeforeSendHeaders.addListener(
    function(details) {
        details.requestHeaders.push({
            name: 'Origin',
            value: 'https://allowed-origin.com'
        });
        return {requestHeaders: details.requestHeaders};
    },
    {urls: ["*://*/*"]},
    ["blocking", "requestHeaders"]
);

def download_with_retry(url, max_retries=3):
    """Download with retry mechanism"""
    for attempt in range(max_retries):
        try:
            response = requests.get(url, timeout=30)
            response.raise_for_status()
            return response.content
        except Exception as e:
            if attempt == max_retries - 1:
                raise
            print(f"Retry {attempt + 1}/{max_retries}")
            time.sleep(2 ** attempt)  # Exponential backoff