Skip to content

基于自定义规则的番剧采集APP,支持流媒体在线观看,支持弹幕,支持实时超分辨率。

9.7 KB
Raw Blame
class M3u8Key {
  final String method;
  final String uri;
  final String? iv;

  M3u8Key({required this.method, required this.uri, this.iv});

  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      other is M3u8Key &&
          method == other.method &&
          uri == other.uri &&
          iv == other.iv;

  @override
  int get hashCode => Object.hash(method, uri, iv);

  @override
  String toString() {
    final sb = StringBuffer('#EXT-X-KEY:METHOD=$method,URI="$uri"');
    if (iv != null) {
      sb.write(',IV=$iv');
    }
    return sb.toString();
  }
}

class M3u8Segment {
  final double duration;
  final String uri;
  final int discontinuityGroup;
  final M3u8Key? key;

  M3u8Segment({
    required this.duration,
    required this.uri,
    required this.discontinuityGroup,
    this.key,
  });
}

class M3u8Variant {
  final int bandwidth;
  final String? resolution;
  final String uri;

  M3u8Variant({required this.bandwidth, this.resolution, required this.uri});
}

class M3u8MasterPlaylist {
  final List<M3u8Variant> variants;

  M3u8MasterPlaylist({required this.variants});

  M3u8Variant get bestVariant {
    return variants.reduce((a, b) => a.bandwidth > b.bandwidth ? a : b);
  }
}

class M3u8MediaPlaylist {
  final List<M3u8Segment> segments;
  final double targetDuration;
  final bool isVod;

  M3u8MediaPlaylist({
    required this.segments,
    required this.targetDuration,
    required this.isVod,
  });
}

enum M3u8Type { master, media }

class M3u8Parser {
  static M3u8Type detectType(String content) {
    if (content.contains('#EXT-X-STREAM-INF')) {
      return M3u8Type.master;
    }
    return M3u8Type.media;
  }

  static String resolveUrl(String baseUrl, String relativeUrl) {
    if (relativeUrl.startsWith('http://') ||
        relativeUrl.startsWith('https://')) {
      return relativeUrl;
    }
    final baseUri = Uri.parse(baseUrl);
    if (relativeUrl.startsWith('/')) {
      return '${baseUri.scheme}://${baseUri.host}${baseUri.hasPort ? ':${baseUri.port}' : ''}$relativeUrl';
    }
    final basePath = baseUrl.substring(0, baseUrl.lastIndexOf('/') + 1);
    return '$basePath$relativeUrl';
  }

  static M3u8MasterPlaylist parseMasterPlaylist(
      String content, String baseUrl) {
    final lines = content.split('\n').map((l) => l.trim()).toList();
    final variants = <M3u8Variant>[];

    for (int i = 0; i < lines.length; i++) {
      final line = lines[i];
      if (line.startsWith('#EXT-X-STREAM-INF:')) {
        final attrs = line.substring('#EXT-X-STREAM-INF:'.length);
        int bandwidth = 0;
        String? resolution;

        final bandwidthMatch = RegExp(r'BANDWIDTH=(\d+)').firstMatch(attrs);
        if (bandwidthMatch != null) {
          bandwidth = int.parse(bandwidthMatch.group(1)!);
        }

        final resolutionMatch =
            RegExp(r'RESOLUTION=([^\s,]+)').firstMatch(attrs);
        if (resolutionMatch != null) {
          resolution = resolutionMatch.group(1);
        }

        if (i + 1 < lines.length && !lines[i + 1].startsWith('#')) {
          final uri = resolveUrl(baseUrl, lines[i + 1]);
          variants.add(M3u8Variant(
              bandwidth: bandwidth, resolution: resolution, uri: uri));
        }
      }
    }

    return M3u8MasterPlaylist(variants: variants);
  }

  static M3u8MediaPlaylist parseMediaPlaylist(String content, String baseUrl) {
    final lines = content.split('\n').map((l) => l.trim()).toList();
    final segments = <M3u8Segment>[];
    double targetDuration = 0;
    bool hasEndList = false;
    bool isExplicitVod = false;
    bool isLiveEvent = false;
    int currentDiscontinuityGroup = 0;
    M3u8Key? currentKey;
    double currentDuration = 0;

    for (int i = 0; i < lines.length; i++) {
      final line = lines[i];

      if (line.startsWith('#EXT-X-TARGETDURATION:')) {
        targetDuration =
            double.parse(line.substring('#EXT-X-TARGETDURATION:'.length));
      } else if (line == '#EXT-X-ENDLIST') {
        hasEndList = true;
      } else if (line == '#EXT-X-PLAYLIST-TYPE:VOD') {
        isExplicitVod = true;
      } else if (line == '#EXT-X-PLAYLIST-TYPE:EVENT') {
        isLiveEvent = true;
      } else if (line == '#EXT-X-DISCONTINUITY') {
        currentDiscontinuityGroup++;
      } else if (line.startsWith('#EXT-X-KEY:')) {
        currentKey = _parseKey(line, baseUrl);
      } else if (line.startsWith('#EXTINF:')) {
        final durationStr = line.substring('#EXTINF:'.length).split(',')[0];
        currentDuration = double.parse(durationStr);
      } else if (line.isNotEmpty && !line.startsWith('#')) {
        final uri = resolveUrl(baseUrl, line);
        segments.add(M3u8Segment(
          duration: currentDuration,
          uri: uri,
          discontinuityGroup: currentDiscontinuityGroup,
          key: currentKey,
        ));
        currentDuration = 0;
      }
    }

    // Consider it VOD if:
    // 1. Has #EXT-X-ENDLIST, or
    // 2. Has #EXT-X-PLAYLIST-TYPE:VOD, or
    // 3. Has finite segments and is not explicitly a live EVENT stream.
    // Many third-party video sources omit #EXT-X-ENDLIST for VOD content.
    final bool isVod =
        hasEndList || isExplicitVod || (!isLiveEvent && segments.isNotEmpty);

    return M3u8MediaPlaylist(
      segments: segments,
      targetDuration: targetDuration,
      isVod: isVod,
    );
  }

  static M3u8Key? _parseKey(String line, String baseUrl) {
    final attrs = line.substring('#EXT-X-KEY:'.length);

    final methodMatch = RegExp(r'METHOD=([^,]+)').firstMatch(attrs);
    final method = methodMatch?.group(1) ?? 'NONE';

    if (method == 'NONE') return null;

    final uriMatch = RegExp(r'URI="([^"]+)"').firstMatch(attrs);
    final uri = uriMatch != null ? resolveUrl(baseUrl, uriMatch.group(1)!) : '';

    final ivMatch = RegExp(r'IV=(0x[0-9a-fA-F]+)').firstMatch(attrs);
    final iv = ivMatch?.group(1);

    return M3u8Key(method: method, uri: uri, iv: iv);
  }

  static List<M3u8Key> extractUniqueKeys(M3u8MediaPlaylist playlist) {
    final seen = <String>{};
    final keys = <M3u8Key>[];
    for (final seg in playlist.segments) {
      if (seg.key != null && !seen.contains(seg.key!.uri)) {
        seen.add(seg.key!.uri);
        keys.add(seg.key!);
      }
    }
    return keys;
  }

  static String buildLocalM3u8(
    List<M3u8Segment> segments, {
    required double targetDuration,
    Map<String, String> keyUriToLocal = const {},
  }) {
    final sb = StringBuffer();
    sb.writeln('#EXTM3U');
    sb.writeln('#EXT-X-VERSION:3');
    sb.writeln('#EXT-X-TARGETDURATION:${targetDuration.ceil()}');
    sb.writeln('#EXT-X-MEDIA-SEQUENCE:0');

    int lastDiscontinuityGroup = 0;
    M3u8Key? lastKey;

    for (int i = 0; i < segments.length; i++) {
      final seg = segments[i];

      if (seg.discontinuityGroup != lastDiscontinuityGroup && i > 0) {
        sb.writeln('#EXT-X-DISCONTINUITY');
        lastDiscontinuityGroup = seg.discontinuityGroup;
      }

      if (seg.key != lastKey) {
        if (seg.key == null) {
          sb.writeln('#EXT-X-KEY:METHOD=NONE');
        } else {
          final localUri = keyUriToLocal[seg.key!.uri] ?? seg.key!.uri;
          final keySb = StringBuffer(
              '#EXT-X-KEY:METHOD=${seg.key!.method},URI="$localUri"');
          if (seg.key!.iv != null) {
            keySb.write(',IV=${seg.key!.iv}');
          }
          sb.writeln(keySb.toString());
        }
        lastKey = seg.key;
      }

      sb.writeln('#EXTINF:${seg.duration.toStringAsFixed(6)},');
      sb.writeln('seg_${i.toString().padLeft(5, '0')}.ts');
    }

    sb.writeln('#EXT-X-ENDLIST');
    return sb.toString();
  }

  static bool _isM3u8Url(String url) {
    final path = Uri.parse(url).path.toLowerCase();
    return path.endsWith('.m3u8');
  }

  /// 展开嵌套 M3U8 片段。
  /// [fetcher] 异步回调,给定 URL 返回 M3U8 文本内容。
  /// [maxDepth] 递归深度上限,防止无限嵌套。
  static Future<List<M3u8Segment>> resolveNestedSegments(
    List<M3u8Segment> segments,
    Future<String> Function(String url) fetcher, {
    int maxDepth = 3,
  }) async {
    if (maxDepth <= 0) return segments;
    if (!segments.any((s) => _isM3u8Url(s.uri))) return segments;

    final result = <M3u8Segment>[];
    int groupOffset = 0;

    for (final seg in segments) {
      if (!_isM3u8Url(seg.uri)) {
        result.add(M3u8Segment(
          duration: seg.duration,
          uri: seg.uri,
          discontinuityGroup: seg.discontinuityGroup + groupOffset,
          key: seg.key,
        ));
        continue;
      }

      // 该 segment 的 URI 指向嵌套 m3u8,展开
      try {
        final content = await fetcher(seg.uri);
        final nested = parseMediaPlaylist(content, seg.uri);
        final resolved = await resolveNestedSegments(
          nested.segments,
          fetcher,
          maxDepth: maxDepth - 1,
        );

        if (resolved.isEmpty) continue;

        final nestedBase = seg.discontinuityGroup + groupOffset;
        int maxNestedGroup = 0;
        for (final ns in resolved) {
          if (ns.discontinuityGroup > maxNestedGroup) {
            maxNestedGroup = ns.discontinuityGroup;
          }
        }

        for (final ns in resolved) {
          result.add(M3u8Segment(
            duration: ns.duration,
            uri: ns.uri,
            discontinuityGroup: ns.discontinuityGroup + nestedBase,
            key: ns.key,
          ));
        }

        // 后续 segment 的 group 需要额外偏移,避免碰撞
        groupOffset += maxNestedGroup;
      } catch (e) {
        // 获取/解析失败,保留原始 segment
        result.add(M3u8Segment(
          duration: seg.duration,
          uri: seg.uri,
          discontinuityGroup: seg.discontinuityGroup + groupOffset,
          key: seg.key,
        ));
      }
    }

    return result;
  }
}