┌─────────────────┐
│  Master Playlist │ ──► 包含多个码率的子播放列表
└─────────────────┘
         │
         ├── 1080p.m3u8 ──► 高清播放列表
         ├── 720p.m3u8  ──► 标清播放列表
         └── 480p.m3u8  ──► 流畅播放列表

# Windows (使用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

# 下载M3U8视频
yt-dlp "https://example.com/video.m3u8"

# 指定输出文件名
yt-dlp -o "video.mp4" "https://example.com/video.m3u8"

# 选择最佳质量
yt-dlp -f "best[ext=mp4]/best" URL

# 列出所有可用格式
yt-dlp -F URL

# 使用代理下载
yt-dlp --proxy socks5://127.0.0.1:1080 URL

# 限制下载速度
yt-dlp --limit-rate 500K URL

# 添加cookies（处理需要登录的视频）
yt-dlp --cookies cookies.txt URL

# 批量下载列表
yt-dlp -a urls.txt

# 下载字幕
yt-dlp --write-sub --sub-lang en,zh URL

# 嵌入字幕到视频
yt-dlp --embed-subs URL

# 使用aria2c加速下载
yt-dlp --external-downloader aria2c --external-downloader-args "-x 16 -k 1M" URL

# 默认输出格式
-o "~/Downloads/%(title)s.%(ext)s"

# 自动选择最佳格式
-f "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best"

# 嵌入缩略图和字幕
--embed-thumbnail
--embed-subs

# 使用aria2c加速
--external-downloader aria2c
--external-downloader-args "-x 16 -k 1M"

# 保持原始修改时间
--no-mtime

# 下载最新版本
# Windows: 下载exe文件
# macOS/Linux: 下载对应二进制文件

# 基本使用
N_m3u8DL-RE "https://example.com/video.m3u8" --save-name "output"

# 自动选择最高画质
N_m3u8DL-RE URL --auto-select

# 设置并发数
N_m3u8DL-RE URL --thread-count 16

# 设置临时文件目录
N_m3u8DL-RE URL --tmp-dir /path/to/tmp

# 使用自定义请求头
N_m3u8DL-RE URL --header "Referer: https://example.com"

# 处理加密视频
N_m3u8DL-RE URL --key "AES128KEY"

# 实时流录制
N_m3u8DL-RE URL --live-real-time-merge

# 基础下载
ffmpeg -i "https://example.com/video.m3u8" -c copy output.mp4

# 设置超时和重试
ffmpeg -timeout 5000000 -reconnect 1 -reconnect_at_eof 1 -reconnect_streamed 1 -reconnect_delay_max 2 -i URL -c copy output.mp4

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

# 添加多个请求头
ffmpeg -headers $'Referer: https://example.com\r\nCookie: session=abc123' -i URL -c copy output.mp4

# 下载指定时间段
ffmpeg -ss 00:10:00 -t 00:05:00 -i URL -c copy output.mp4

# 处理HTTPS证书问题
ffmpeg -nostdin -y -loglevel error -tls_verify 0 -i URL -c copy output.mp4

1. 媒体 → 打开网络串流
2. 输入M3U8链接
3. 工具 → 编解码信息
4. 复制Location
5. 媒体 → 转换/保存

// 支持浏览器：Chrome, Firefox, Edge
// 功能特点：
- 自动检测M3U8流
- 一键下载转换
- 支持合并片段
- 批量下载管理

// 在控制台执行，获取所有M3U8链接
(() => {
    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;
})();

// 功能特点
- 内置浏览器
- 下载管理器
- 文件管理
- 视频播放器

// 使用步骤
1. 打开内置浏览器
2. 访问M3U8链接
3. 长按链接选择下载
4. 在下载管理器查看进度

// 创建下载捷径
1. 获取剪贴板内容
2. 获取URL内容
3. 保存到文件
4. 快速指令自动化

// 配置建议
- 线程数: 16
- 片段大小: 1MB
- 自动恢复: 开启
- 后台下载: 允许

// M3U8专属功能
- HLS流检测
- 自动合并
- 批量队列
- 速度限制

import requests
from Crypto.Cipher import AES
import os

def decrypt_ts(encrypted_data, key, iv):
    """解密TS片段"""
    cipher = AES.new(key, AES.MODE_CBC, iv)
    return cipher.decrypt(encrypted_data)

def download_encrypted_m3u8(m3u8_url, key_url):
    """下载加密的M3U8视频"""
    # 获取密钥
    key = requests.get(key_url).content
    
    # 解析M3U8
    m3u8_content = requests.get(m3u8_url).text
    
    # 下载并解密片段
    for line in m3u8_content.split('\n'):
        if line.endswith('.ts'):
            ts_url = urljoin(m3u8_url, line)
            encrypted_data = requests.get(ts_url).content
            
            # 解密
            iv = os.urandom(16)  # 或从M3U8中获取
            decrypted_data = decrypt_ts(encrypted_data, key, iv)
            
            # 保存解密后的数据
            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):
        """下载单个片段"""
        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):
        """下载完整的M3U8视频"""
        # 创建输出目录
        Path(output_dir).mkdir(parents=True, exist_ok=True)
        
        # 解析M3U8
        playlist = m3u8.load(m3u8_url)
        
        # 准备下载任务
        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))
        
        # 并行下载
        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
            ]
            
            # 显示进度
            completed = 0
            total = len(futures)
            for future in concurrent.futures.as_completed(futures):
                completed += 1
                print(f"Progress: {completed}/{total} ({completed*100/total:.1f}%)")
        
        # 合并文件
        self.merge_segments(output_dir)
    
    def merge_segments(self, segment_dir):
        """合并所有片段"""
        output_file = Path(segment_dir).parent / "output.mp4"
        
        # 创建文件列表
        segments = sorted(Path(segment_dir).glob("*.ts"))
        
        # 使用FFmpeg合并
        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}")

# 使用示例
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):
        """支持断点续传的下载"""
        headers = {}
        mode = 'wb'
        resume_pos = 0
        
        # 检查是否有未完成的下载
        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)
        
        # 检查服务器是否支持断点续传
        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}")
        
        # 下载文件
        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}")

# 使用aria2c加速
yt-dlp --external-downloader aria2c \
       --external-downloader-args "-x 16 -s 16 -k 1M" URL

# N_m3u8DL-RE多线程
N_m3u8DL-RE URL --thread-count 32

def test_cdn_speed(urls):
    """测试CDN节点速度"""
    import time
    speeds = {}
    
    for url in urls:
        start = time.time()
        response = requests.head(url)
        elapsed = time.time() - start
        speeds[url] = elapsed
    
    # 选择最快的节点
    fastest = min(speeds, key=speeds.get)
    return fastest

def download_large_file(url, chunk_size=8192):
    """流式下载大文件，避免内存溢出"""
    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)
                # 可选：显示进度
                downloaded = f.tell()
                print(f"Downloaded: {downloaded:,} bytes", end='\r')

# 解决方案1：添加Referer
ffmpeg -headers "Referer: https://example.com" -i URL output.mp4

# 解决方案2：使用cookies
yt-dlp --cookies cookies.txt URL

# 解决方案3：修改User-Agent
wget --user-agent="Mozilla/5.0" URL

// 浏览器扩展绕过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):
    """带重试机制的下载"""
    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)  # 指数退避