m3u8-cli 0.1.0__py3-none-any.whl

m3u8_cli/downloader.py

@@ -0,0 +1,105 @@
+"""分片下载、密钥缓存与 AES-128 解密。"""
+
+import re
+import threading
+import time
+
+import requests
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import unpad
+
+from .errors import HLSException
+
+
+class Downloader:
+    def __init__(self, headers, timeout, retries):
+        self.headers = headers
+        self.timeout = timeout
+        self.retries = retries
+        self.local = threading.local()
+        self.keys = {}
+        self.key_lock = threading.Lock()
+
+    def session(self):
+        if not hasattr(self.local, "session"):
+            self.local.session = requests.Session()
+            self.local.session.headers.update(self.headers)
+        return self.local.session
+
+    def get_bytes(self, url):
+        response = self.session().get(
+            url, timeout=self.timeout
+        )
+        response.raise_for_status()
+        return response.content
+
+    def get_key(self, key_url):
+        # 同一密钥只请求一次，避免并发重复拉取。
+        with self.key_lock:
+            if key_url in self.keys:
+                return self.keys[key_url]
+
+            data = self.get_bytes(key_url)
+            if len(data) != 16:
+                raise HLSException(
+                    f"AES-128 密钥长度异常：{len(data)} 字节"
+                )
+
+            self.keys[key_url] = data
+            return data
+
+    def decrypt(self, data, key_info, sequence):
+        if not key_info:
+            return data
+
+        key = self.get_key(key_info["uri"])
+        iv_text = key_info.get("iv")
+
+        if iv_text:
+            if not re.fullmatch(r"0[xX][0-9a-fA-F]{1,32}", iv_text):
+                raise HLSException("无效的 AES IV")
+            iv = bytes.fromhex(iv_text[2:].zfill(32))
+        else:
+            # HLS AES-128 未指定 IV 时使用媒体序列号。
+            iv = sequence.to_bytes(16, "big")
+
+        if not data or len(data) % AES.block_size:
+            raise HLSException("AES-128 密文长度不符合 CBC 块要求")
+
+        cipher = AES.new(key, AES.MODE_CBC, iv)
+        plaintext = cipher.decrypt(data)
+
+        try:
+            return unpad(plaintext, AES.block_size)
+        except ValueError as exc:
+            raise HLSException(
+                "AES 解密后的填充无效，请检查密钥、IV 和内容类型"
+            ) from exc
+
+    def download(
+        self, url, path, key_info=None, sequence=0, decrypt=True
+    ):
+        if path.exists() and path.stat().st_size > 0:
+            return path
+
+        last_error = None
+
+        for attempt in range(self.retries + 1):
+            try:
+                data = self.get_bytes(url)
+                if decrypt:
+                    data = self.decrypt(data, key_info, sequence)
+
+                temp = path.with_suffix(path.suffix + ".part")
+                temp.write_bytes(data)
+                temp.replace(path)
+                return path
+
+            except Exception as exc:
+                last_error = exc
+                if attempt < self.retries:
+                    time.sleep(min(2 ** attempt, 10))
+
+        raise HLSException(
+            f"下载失败：{url}\n最后错误：{last_error}"
+        )

m3u8_cli/errors.py

@@ -0,0 +1,6 @@
+class HLSException(RuntimeError):
+    pass
+
+
+class DownloadCancelled(HLSException):
+    """任务被协作式取消。"""

m3u8_cli/hls_export.py

@@ -0,0 +1,151 @@
+"""把已下载的 HLS 资源导出为本地目录。"""
+
+import math
+import re
+import shutil
+from pathlib import Path
+
+from .errors import HLSException
+
+SEGMENT_RE = re.compile(r"\d{6}\.(?:ts|m4s)")
+KEY_RE = re.compile(r"key(?:_\d+)?\.bin")
+
+
+def segment_suffix(playlist):
+    """fMP4 用 .m4s，其余沿用 .ts。"""
+    return ".m4s" if playlist["maps"] else ".ts"
+
+
+def build_playlist(playlist, key_names):
+    """生成引用本地文件的可播放媒体播放列表。"""
+    suffix = segment_suffix(playlist)
+    segments = playlist["segments"]
+    durations = [float(s.get("duration") or 0) for s in segments]
+    target = max(1, math.ceil(max(durations) if durations else 0))
+
+    lines = [
+        "#EXTM3U",
+        "#EXT-X-VERSION:6" if playlist["maps"] else "#EXT-X-VERSION:3",
+        f"#EXT-X-TARGETDURATION:{target}",
+        "#EXT-X-PLAYLIST-TYPE:VOD",
+        f"#EXT-X-MEDIA-SEQUENCE:{playlist['media_sequence']}",
+    ]
+    if playlist["maps"]:
+        lines.append('#EXT-X-MAP:URI="init.mp4"')
+
+    previous_key = None
+    for i, segment in enumerate(segments):
+        key = segment.get("key")
+        if key is None and previous_key is not None:
+            lines.append("#EXT-X-KEY:METHOD=NONE")
+        elif key is not None and key != previous_key:
+            attrs = [
+                f'METHOD={key["method"]}',
+                f'URI="{key_names[key["uri"]]}"',
+            ]
+            if key.get("iv"):
+                attrs.append(f'IV={key["iv"]}')
+            lines.append("#EXT-X-KEY:" + ",".join(attrs))
+        previous_key = key
+        lines.append(f"#EXTINF:{durations[i]:.3f},")
+        lines.append(f"{i:06d}{suffix}")
+    lines.append("#EXT-X-ENDLIST")
+    return "\n".join(lines) + "\n"
+
+
+def _clear_output(output_dir):
+    """只删除本工具生成的播放列表、分片、初始化片段与密钥。"""
+    for entry in output_dir.iterdir():
+        if not (entry.is_file() or entry.is_symlink()):
+            continue
+        if (
+            entry.name == "playlist.m3u8"
+            or entry.name == "init.mp4"
+            or SEGMENT_RE.fullmatch(entry.name)
+            or KEY_RE.fullmatch(entry.name)
+        ):
+            entry.unlink()
+
+
+def _targets(playlist, key_names):
+    """返回本次导出会写入的所有目标路径。"""
+    suffix = segment_suffix(playlist)
+    targets = [f"{i:06d}{suffix}"
+               for i in range(len(playlist["segments"]))]
+    if playlist["maps"]:
+        targets.append("init.mp4")
+    targets.append("playlist.m3u8")
+    targets.extend(key_names.values())
+    return targets
+
+
+def _check_targets(playlist, output_dir, key_names, overwrite):
+    if output_dir.exists() and not output_dir.is_dir():
+        raise HLSException(f"输出路径不是目录：{output_dir}")
+    if len(playlist["maps"]) > 1:
+        raise HLSException("不支持多个初始化片段")
+
+    for name in _targets(playlist, key_names):
+        target = output_dir / name
+        if target.is_dir():
+            raise HLSException(f"目标路径是目录：{target}")
+        if not overwrite and target.exists():
+            raise HLSException(
+                f"目标已存在：{target}，使用 --overwrite 覆盖"
+            )
+
+
+def _check_sources(playlist, cache):
+    for i in range(len(playlist["segments"])):
+        source = cache / f"segment_{i:06d}.bin"
+        if not source.is_file():
+            raise HLSException(
+                f"缓存分片缺失：{source}；请删除 cache 目录后重试"
+            )
+    if playlist["maps"]:
+        source = cache / "map_0000.bin"
+        if not source.is_file():
+            raise HLSException(
+                f"缓存初始化片段缺失：{source}；请删除 cache 目录后重试"
+            )
+
+
+def export_hls(playlist, cache, output_dir, key_data, key_names,
+               overwrite):
+    """把缓存分片、初始化片段与密钥导出到本地 HLS 目录。"""
+    _check_targets(playlist, output_dir, key_names, overwrite)
+    _check_sources(playlist, cache)
+
+    try:
+        output_dir.mkdir(parents=True, exist_ok=True)
+    except OSError as exc:
+        raise HLSException(
+            f"无法创建输出目录：{output_dir}（{exc}）"
+        ) from exc
+
+    if overwrite:
+        _clear_output(output_dir)
+
+    suffix = segment_suffix(playlist)
+    for i in range(len(playlist["segments"])):
+        source = cache / f"segment_{i:06d}.bin"
+        shutil.copyfile(source, output_dir / f"{i:06d}{suffix}")
+
+    if playlist["maps"]:
+        shutil.copyfile(
+            cache / "map_0000.bin", output_dir / "init.mp4"
+        )
+
+    for uri, name in key_names.items():
+        if uri not in key_data:
+            raise HLSException(f"缺少密钥数据：{uri}")
+        (output_dir / name).write_bytes(key_data[uri])
+
+    part = output_dir / "playlist.m3u8.part"
+    try:
+        part.write_text(build_playlist(playlist, key_names), "utf-8")
+        part.replace(output_dir / "playlist.m3u8")
+    except BaseException:
+        part.unlink(missing_ok=True)
+        raise
+    return output_dir

m3u8_cli/merge.py

@@ -0,0 +1,43 @@
+"""本地分片合并与 FFmpeg 封装。"""
+
+import shutil
+import subprocess
+
+
+def combine_segments(segments, maps, map_paths, cache):
+    """按播放列表顺序把已解密分片写入 combined 文件。"""
+    is_fmp4 = bool(maps)
+    combined = cache / ("combined.mp4" if is_fmp4 else "combined.ts")
+
+    with combined.open("wb") as out:
+        # fMP4 先写初始化片段，再拼接媒体分片。
+        if is_fmp4:
+            out.write(map_paths[maps[0]].read_bytes())
+
+        for i in range(len(segments)):
+            path = cache / f"segment_{i:06d}.bin"
+            with path.open("rb") as src:
+                shutil.copyfileobj(src, out, length=1024 * 1024)
+
+    return combined
+
+
+def mux(combined, cache, output):
+    """把合并文件无损封装为最终 MP4，成功后原子替换。"""
+    # 临时文件与最终文件同属一个任务目录，重命名保持原子性。
+    temp_output = cache / (output.stem + ".partial" + output.suffix)
+    command = [
+        "ffmpeg", "-hide_banner", "-y",
+        "-i", str(combined),
+        "-map", "0",
+        "-c", "copy",
+        "-movflags", "+faststart",
+        str(temp_output),
+    ]
+
+    try:
+        subprocess.run(command, check=True)
+        temp_output.replace(output)
+    except Exception:
+        temp_output.unlink(missing_ok=True)
+        raise

m3u8_cli/paths.py

@@ -0,0 +1,30 @@
+"""任务子目录路径派生。"""
+
+from pathlib import Path
+
+from .errors import HLSException
+
+
+def derive_task_paths(output_arg):
+    """返回最终文件路径和缓存目录，不创建任何目录。"""
+    output = Path(output_arg).expanduser().resolve()
+
+    # -o output/name.mp4 时直接复用 output/，避免嵌套成 output/output/。
+    if output.parent.name == output.stem:
+        task_dir = output.parent
+    else:
+        task_dir = output.parent / output.stem
+
+    return output, task_dir / "cache"
+
+
+def resolve_task_paths(output_arg):
+    """返回任务目录内的最终文件路径和缓存目录，并创建任务目录。"""
+    output, cache = derive_task_paths(output_arg)
+    task_dir = cache.parent
+
+    if task_dir.exists() and not task_dir.is_dir():
+        raise HLSException(f"任务目录路径不是目录：{task_dir}")
+
+    task_dir.mkdir(parents=True, exist_ok=True)
+    return output, cache

m3u8_cli/playlist.py

@@ -0,0 +1,165 @@
+"""m3u8 播放列表获取与解析。"""
+
+import hashlib
+import math
+import re
+from urllib.parse import urljoin
+
+import requests
+
+from .errors import HLSException
+
+
+def parse_attrs(line):
+    """解析 EXT-X-KEY 等标签中的属性，支持引号内逗号。"""
+    result = {}
+    pattern = r'([A-Z0-9-]+)=("(?:[^"\\]|\\.)*"|[^,]*)'
+    for key, value in re.findall(pattern, line):
+        value = value.strip()
+        if value.startswith('"') and value.endswith('"'):
+            value = value[1:-1]
+        result[key] = value
+    return result
+
+
+def request_text(url, headers, timeout):
+    with requests.get(
+        url, headers=headers, timeout=timeout
+    ) as response:
+        response.raise_for_status()
+        return response.text
+
+
+def load_playlist(url, headers, timeout, depth=0):
+    """解析媒体播放列表；如果是 master playlist，选择最高带宽变体。"""
+    if depth > 5:
+        raise HLSException("主播放列表嵌套层数过多")
+
+    text = request_text(url, headers, timeout)
+    lines = [x.strip() for x in text.splitlines() if x.strip()]
+
+    if not lines or lines[0] != "#EXTM3U":
+        raise HLSException("服务器返回的内容不是有效的 M3U8")
+
+    variants = []
+    for i, line in enumerate(lines):
+        if line.startswith("#EXT-X-STREAM-INF:"):
+            attrs = parse_attrs(line)
+            for following in lines[i + 1:]:
+                if not following.startswith("#"):
+                    try:
+                        bandwidth = int(attrs.get("BANDWIDTH", "0"))
+                    except ValueError:
+                        bandwidth = 0
+                    variants.append(
+                        (bandwidth, urljoin(url, following))
+                    )
+                    break
+
+    if variants:
+        variants.sort(reverse=True)
+        print(f"发现 {len(variants)} 个清晰度，选择最高带宽变体")
+        return load_playlist(
+            variants[0][1], headers, timeout, depth + 1
+        )
+
+    media_sequence = 0
+    key = None
+    current_map = None
+    segments = []
+    maps = []
+    pending_map = None
+    pending_duration = 0.0
+
+    for line in lines:
+        if line.startswith("#EXT-X-MEDIA-SEQUENCE:"):
+            try:
+                media_sequence = int(line.split(":", 1)[1])
+            except ValueError as exc:
+                raise HLSException("无效的 MEDIA-SEQUENCE") from exc
+
+        elif line.startswith("#EXTINF:"):
+            try:
+                pending_duration = float(
+                    line.split(":", 1)[1].split(",", 1)[0]
+                )
+            except ValueError as exc:
+                raise HLSException("无效的 EXTINF") from exc
+            if not math.isfinite(pending_duration):
+                raise HLSException("无效的 EXTINF")
+
+        elif line.startswith("#EXT-X-KEY:"):
+            attrs = parse_attrs(line)
+            method = attrs.get("METHOD", "")
+
+            if method == "NONE":
+                key = None
+            elif method == "AES-128":
+                keyformat = attrs.get("KEYFORMAT", "identity")
+                if keyformat != "identity":
+                    raise HLSException(
+                        f"不支持的 KEYFORMAT：{keyformat}"
+                    )
+                if not attrs.get("URI"):
+                    raise HLSException("AES-128 标签缺少密钥 URI")
+                key = {
+                    "method": method,
+                    "uri": urljoin(url, attrs["URI"]),
+                    "iv": attrs.get("IV"),
+                }
+            else:
+                raise HLSException(
+                    f"不支持的加密方式：{method}；不处理 DRM"
+                )
+
+        elif line.startswith("#EXT-X-MAP:"):
+            attrs = parse_attrs(line)
+            if not attrs.get("URI"):
+                raise HLSException("EXT-X-MAP 缺少 URI")
+            if "BYTERANGE" in attrs:
+                raise HLSException("暂不支持初始化片段 BYTERANGE")
+            pending_map = urljoin(url, attrs["URI"])
+
+        elif line.startswith("#EXT-X-BYTERANGE:"):
+            raise HLSException(
+                "暂不支持 EXT-X-BYTERANGE，请使用完整分片 URL"
+            )
+
+        elif not line.startswith("#"):
+            segment_key = dict(key) if key else None
+            segment_map = pending_map or current_map
+
+            if pending_map:
+                current_map = pending_map
+                pending_map = None
+
+            segments.append({
+                "url": urljoin(url, line),
+                "sequence": media_sequence + len(segments),
+                "duration": pending_duration,
+                "key": segment_key,
+                "map": segment_map,
+            })
+            pending_duration = 0.0
+
+    if not segments:
+        raise HLSException("播放列表中没有媒体分片")
+
+    unique_maps = list(dict.fromkeys(
+        s["map"] for s in segments if s["map"]
+    ))
+    if len(unique_maps) > 1:
+        raise HLSException("检测到多个不同的初始化片段，当前版本不支持")
+
+    if unique_maps:
+        maps = unique_maps
+
+    return {
+        "playlist_url": url,
+        "segments": segments,
+        "maps": maps,
+        "media_sequence": media_sequence,
+        "fingerprint": hashlib.sha256(
+            text.encode("utf-8")
+        ).hexdigest(),
+    }