Question

我正在编写基本的Http Live Stream（HLS）下载程序，我将按照＆＃34;＃EXT-X-TARGETDURATION＆＃34;指定的间隔重新下载m3u8媒体播放列表。然后在* .ts段可用时下载。

这是首次下载时m3u8媒体播放列表的样子。

#EXTM3U
#EXT-X-VERSION:3
#EXT-X-TARGETDURATION:12
#EXT-X-MEDIA-SEQUENCE:1
#EXTINF:7.975,
http://website.com/segment_1.ts
#EXTINF:7.941,
http://website.com/segment_2.ts
#EXTINF:7.975,
http://website.com/segment_3.ts

我想使用HttpClient async / await同时下载这些* .ts段。细分的大小不一样，所以即使下载了＆＃34; segment_1.ts＆＃34;首先启动，它可能会在其他两个部分之后完成。

这些片段都是一个大型视频的一部分，因此下载片段的数据按照它们开始的顺序写入非常重要，而不是按照它们完成的顺序写入。

如果细分受众群一个接一个地下载，下面我的代码可以正常运行，但是当同时下载多个细分时却不行，因为有时它们不会按照它们的开始顺序完成。

我考虑过使用Task.WhenAll，它保证了正确的顺序，但我不想不必要地将下载的段保存在内存中，因为它们的大小可能只有几兆字节。如果下载＆＃34; segment_1.ts＆＃34;首先完成，然后它应该立即写入磁盘，而不必等待其他段完成。将所有* .ts段写入单独的文件并最终将它们连接起来也不是一种选择，因为它需要双倍磁盘空间而且总视频的大小可能只有几千兆字节。

我不知道该怎么做，我想知道是否有人可以帮助我。我正在寻找一种不需要我手动创建线程或长时间阻塞ThreadPool线程的方法。

已删除部分代码和异常处理，以便更容易查看正在发生的事情。

// Async BlockingCollection from the AsyncEx library
private AsyncCollection<byte[]> segmentDataQueue = new AsyncCollection<byte[]>();

public void Start()
{
    RunConsumer();
    RunProducer();
}

private async void RunProducer()
{
    while (!_isCancelled)
    {
        var response = await _client.GetAsync(_playlistBaseUri + _playlistFilename, _cts.Token).ConfigureAwait(false);
        var data = await response.Content.ReadAsStringAsync().ConfigureAwait(false);

        string[] lines = data.Split(new string[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
        if (!lines.Any() || lines[0] != "#EXTM3U")
            throw new Exception("Invalid m3u8 media playlist.");

        for (var i = 1; i < lines.Length; i++)
        {
           var line = lines[i];
           if (line.StartsWith("#EXT-X-TARGETDURATION"))
           {
               ParseTargetDuration(line);
           }
           else if (line.StartsWith("#EXT-X-MEDIA-SEQUENCE"))
           {
               ParseMediaSequence(line);
           }
           else if (!line.StartsWith("#"))
           {
               if (_isNewSegment)
               {

                   // Fire and forget
                   DownloadTsSegment(line);

               }
           }
        }

        // Wait until it's time to reload the m3u8 media playlist again
        await Task.Delay(_targetDuration * 1000, _cts.Token).ConfigureAwait(false);
    }
}

// async void. We never await this method, so we can download multiple segments at once
private async void DownloadTsSegment(string tsUrl)
{
    var response = await _client.GetAsync(tsUrl, _cts.Token).ConfigureAwait(false);
    var data = await response.Content.ReadAsByteArrayAsync().ConfigureAwait(false);

    // Add the downloaded segment data to the AsyncCollection
    await segmentDataQueue.AddAsync(data, _cts.Token).ConfigureAwait(false);
}

private async void RunConsumer()
{
    using (FileStream fs = new FileStream(_filePath, FileMode.Create, FileAccess.Write, FileShare.Read))
    {
        while (!_isCancelled)
        {
            // Wait until new segment data is added to the AsyncCollection and write it to disk
            var data = await segmentDataQueue.TakeAsync(_cts.Token).ConfigureAwait(false);
            await fs.WriteAsync(data, 0, data.Length).ConfigureAwait(false);
        }
    }
}

Answer 1

我认为你根本不需要生产者/消费者队列。但是，我认为你应该避免“开火而忘记”。

您可以同时启动它们，并在完成时对其进行处理。

首先，定义如何下载单个细分：

private async Task<byte[]> DownloadTsSegmentAsync(string tsUrl)
{
  var response = await _client.GetAsync(tsUrl, _cts.Token).ConfigureAwait(false);
  return await response.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
}

然后添加播放列表的解析，从而产生段下载的列表（已经在进行中）：

private List<Task<byte[]>> DownloadTasks(string data)
{
  var result = new List<Task<byte[]>>();
  string[] lines = data.Split(new string[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
  if (!lines.Any() || lines[0] != "#EXTM3U")
    throw new Exception("Invalid m3u8 media playlist.");
  ...
           if (_isNewSegment)
           {
             result.Add(DownloadTsSegmentAsync(line));
           }
  ...
  return result;
}

通过写入文件一次一个（按顺序）使用此列表：

private async Task RunConsumerAsync(List<Task<byte[]>> downloads)
{
  using (FileStream fs = new FileStream(_filePath, FileMode.Create, FileAccess.Write, FileShare.Read))
  {
    for (var task in downloads)
    {
      var data = await task.ConfigureAwait(false);
      await fs.WriteAsync(data, 0, data.Length).ConfigureAwait(false);
    }
  }
}

并与制片人一起开始：

public async Task RunAsync()
{
  // TODO: consider CancellationToken instead of a boolean.
  while (!_isCancelled)
  {
    var response = await _client.GetAsync(_playlistBaseUri + _playlistFilename, _cts.Token).ConfigureAwait(false);
    var data = await response.Content.ReadAsStringAsync().ConfigureAwait(false);

    var tasks = DownloadTasks(data);
    await RunConsumerAsync(tasks);

    await Task.Delay(_targetDuration * 1000, _cts.Token).ConfigureAwait(false);
  }
}

请注意，此解决方案同时运行所有下载，这可能会导致内存压力。如果这是一个问题，我建议你重组使用TPL Dataflow，它内置了对限制的支持。

Answer 2

为每个下载分配一个序列号。将结果放入Dictionary<int, byte[]>。每次下载完成时，它都会添加自己的结果。

然后检查是否有要写入磁盘的段：

while (dict.ContainsKey(lowestWrittenSegmentNumber + 1)) {
 WriteSegment(dict[lowestWrittenSegmentNumber + 1]);
 lowestWrittenSegmentNumber++;
}

这样，所有段都按顺序和缓冲结束在磁盘上。

RunConsumer();
RunProducer();

请务必使用async Task，以便等待await Task.WhenAll(RunConsumer(), RunProducer());完成。但是你不应再需要RunConsumer了。

如何确保多个异步下载的数据按照启动顺序保存？

2 个答案: