RangeRequestWriter.cs 7.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191
  1. using ServiceStack.Service;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.IO;
  5. using System.Linq;
  6. using System.Net;
  7. using System.Threading.Tasks;
  8. namespace MediaBrowser.Server.Implementations.HttpServer
  9. {
  10. public class RangeRequestWriter : IStreamWriter
  11. {
  12. /// <summary>
  13. /// Gets or sets the source stream.
  14. /// </summary>
  15. /// <value>The source stream.</value>
  16. private Stream SourceStream { get; set; }
  17. private HttpListenerResponse Response { get; set; }
  18. private string RangeHeader { get; set; }
  19. private bool IsHeadRequest { get; set; }
  20. /// <summary>
  21. /// Initializes a new instance of the <see cref="StreamWriter" /> class.
  22. /// </summary>
  23. /// <param name="rangeHeader">The range header.</param>
  24. /// <param name="response">The response.</param>
  25. /// <param name="source">The source.</param>
  26. /// <param name="isHeadRequest">if set to <c>true</c> [is head request].</param>
  27. public RangeRequestWriter(string rangeHeader, HttpListenerResponse response, Stream source, bool isHeadRequest)
  28. {
  29. RangeHeader = rangeHeader;
  30. Response = response;
  31. SourceStream = source;
  32. IsHeadRequest = isHeadRequest;
  33. }
  34. /// <summary>
  35. /// The _requested ranges
  36. /// </summary>
  37. private List<KeyValuePair<long, long?>> _requestedRanges;
  38. /// <summary>
  39. /// Gets the requested ranges.
  40. /// </summary>
  41. /// <value>The requested ranges.</value>
  42. protected IEnumerable<KeyValuePair<long, long?>> RequestedRanges
  43. {
  44. get
  45. {
  46. if (_requestedRanges == null)
  47. {
  48. _requestedRanges = new List<KeyValuePair<long, long?>>();
  49. // Example: bytes=0-,32-63
  50. var ranges = RangeHeader.Split('=')[1].Split(',');
  51. foreach (var range in ranges)
  52. {
  53. var vals = range.Split('-');
  54. long start = 0;
  55. long? end = null;
  56. if (!string.IsNullOrEmpty(vals[0]))
  57. {
  58. start = long.Parse(vals[0]);
  59. }
  60. if (!string.IsNullOrEmpty(vals[1]))
  61. {
  62. end = long.Parse(vals[1]);
  63. }
  64. _requestedRanges.Add(new KeyValuePair<long, long?>(start, end));
  65. }
  66. }
  67. return _requestedRanges;
  68. }
  69. }
  70. /// <summary>
  71. /// Writes to.
  72. /// </summary>
  73. /// <param name="responseStream">The response stream.</param>
  74. public void WriteTo(Stream responseStream)
  75. {
  76. Response.Headers["Accept-Ranges"] = "bytes";
  77. Response.StatusCode = 206;
  78. var task = WriteToAsync(responseStream);
  79. Task.WaitAll(task);
  80. }
  81. /// <summary>
  82. /// Writes to async.
  83. /// </summary>
  84. /// <param name="responseStream">The response stream.</param>
  85. /// <returns>Task.</returns>
  86. private async Task WriteToAsync(Stream responseStream)
  87. {
  88. using (var source = SourceStream)
  89. {
  90. var requestedRange = RequestedRanges.First();
  91. var totalLength = SourceStream.Length;
  92. // If the requested range is "0-", we can optimize by just doing a stream copy
  93. if (!requestedRange.Value.HasValue)
  94. {
  95. await ServeCompleteRangeRequest(source, requestedRange, responseStream, totalLength).ConfigureAwait(false);
  96. }
  97. // This will have to buffer a portion of the content into memory
  98. await ServePartialRangeRequest(source, requestedRange.Key, requestedRange.Value.Value, responseStream, totalLength).ConfigureAwait(false);
  99. }
  100. }
  101. /// <summary>
  102. /// Handles a range request of "bytes=0-"
  103. /// This will serve the complete content and add the content-range header
  104. /// </summary>
  105. /// <param name="sourceStream">The source stream.</param>
  106. /// <param name="requestedRange">The requested range.</param>
  107. /// <param name="responseStream">The response stream.</param>
  108. /// <param name="totalContentLength">Total length of the content.</param>
  109. /// <returns>Task.</returns>
  110. private Task ServeCompleteRangeRequest(Stream sourceStream, KeyValuePair<long, long?> requestedRange, Stream responseStream, long totalContentLength)
  111. {
  112. var rangeStart = requestedRange.Key;
  113. var rangeEnd = totalContentLength - 1;
  114. var rangeLength = 1 + rangeEnd - rangeStart;
  115. // Content-Length is the length of what we're serving, not the original content
  116. Response.ContentLength64 = rangeLength;
  117. Response.Headers["Content-Range"] = string.Format("bytes {0}-{1}/{2}", rangeStart, rangeEnd, totalContentLength);
  118. // Headers only
  119. if (IsHeadRequest)
  120. {
  121. return Task.FromResult(true);
  122. }
  123. if (rangeStart > 0)
  124. {
  125. sourceStream.Position = rangeStart;
  126. }
  127. return sourceStream.CopyToAsync(responseStream);
  128. }
  129. /// <summary>
  130. /// Serves a partial range request
  131. /// </summary>
  132. /// <param name="sourceStream">The source stream.</param>
  133. /// <param name="rangeStart">The range start.</param>
  134. /// <param name="rangeEnd">The range end.</param>
  135. /// <param name="responseStream">The response stream.</param>
  136. /// <param name="totalContentLength">Total length of the content.</param>
  137. /// <returns>Task.</returns>
  138. private async Task ServePartialRangeRequest(Stream sourceStream, long rangeStart, long rangeEnd, Stream responseStream, long totalContentLength)
  139. {
  140. var rangeLength = 1 + rangeEnd - rangeStart;
  141. // Content-Length is the length of what we're serving, not the original content
  142. Response.ContentLength64 = rangeLength;
  143. Response.Headers["Content-Range"] = string.Format("bytes {0}-{1}/{2}", rangeStart, rangeEnd, totalContentLength);
  144. // Headers only
  145. if (IsHeadRequest)
  146. {
  147. return;
  148. }
  149. sourceStream.Position = rangeStart;
  150. // Fast track to just copy the stream to the end
  151. if (rangeEnd == totalContentLength - 1)
  152. {
  153. await sourceStream.CopyToAsync(responseStream).ConfigureAwait(false);
  154. }
  155. else
  156. {
  157. // Read the bytes we need
  158. var buffer = new byte[Convert.ToInt32(rangeLength)];
  159. await sourceStream.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
  160. await responseStream.WriteAsync(buffer, 0, Convert.ToInt32(rangeLength)).ConfigureAwait(false);
  161. }
  162. }
  163. }
  164. }