+
+bool Stream::add_fragment_boundary(size_t byte_position, const RationalPTS &pts)
+{
+ double pts_double = double(pts.pts) * pts.timebase_den / pts.timebase_num;
+
+ if (fragments.size() <= 1 ||
+ fragments[fragments.size() - 1].begins_header ||
+ fragments[fragments.size() - 2].begins_header) {
+ // Just starting up, so try to establish the first in-progress fragment.
+ fragments.push_back(FragmentStart{ byte_position, pts_double, false });
+ return false;
+ }
+
+ // Keep extending the in-progress fragment as long as we do not
+ // exceed the target duration by more than half a second
+ // (RFC 8216 4.3.3.1) and we get closer to the target by doing so.
+ // Note that in particular, this means we'll always extend
+ // as long as we don't exceed the target duration.
+ double current_duration = pts_double - fragments[fragments.size() - 1].pts;
+ double candidate_duration = pts_double - fragments[fragments.size() - 2].pts;
+ if (lrintf(candidate_duration) <= hls_frag_duration &&
+ fabs(candidate_duration - hls_frag_duration) < fabs(current_duration - hls_frag_duration)) {
+ fragments.back() = FragmentStart{ byte_position, pts_double, false };
+ return false;
+ } else {
+ // Extending the in-progress fragment would make it too long,
+ // so finalize it and start a new in-progress fragment.
+ fragments.push_back(FragmentStart{ byte_position, pts_double, false });
+ return true;
+ }
+}
+
+void Stream::clear_hls_playlist_cache()
+{
+ hls_playlist_http10.reset();
+ hls_playlist_http11_close.reset();
+ hls_playlist_http11_persistent.reset();
+}
+
+shared_ptr<const string> Stream::generate_hls_playlist(bool http_11, bool close_after_response)
+{
+ char buf[256];
+ snprintf(buf, sizeof(buf),
+ "#EXTM3U\r\n"
+ "#EXT-X-VERSION:7\r\n"
+ "#EXT-X-TARGETDURATION:%u\r\n"
+ "#EXT-X-MEDIA-SEQUENCE:%" PRIu64 "\r\n"
+ "#EXT-X-DISCONTINUITY-SEQUENCE:%" PRIu64 "\r\n",
+ hls_frag_duration,
+ first_fragment_index,
+ discontinuity_counter);
+
+ string playlist = buf;
+
+ if (fragments.size() >= 3) {
+ bool printed_header_for_this_group = false;
+ bool printed_first_header = false;
+ for (size_t i = 0; i < fragments.size() - 2; ++i) {
+ char buf[256];
+
+ if (fragments[i].begins_header) {
+ // End of this group. (We've already printed the header
+ // as part of the previous group.)
+ printed_header_for_this_group = false;
+ continue;
+ }
+ if (!printed_header_for_this_group) {
+ // Look forward until we find the header for this group (if any).
+ for (size_t j = i + 1; j < fragments.size() - 1; ++j) {
+ if (fragments[j].begins_header) {
+ if (printed_first_header) {
+ playlist += "#EXT-X-DISCONTINUITY\r\n";
+ }
+ snprintf(buf, sizeof(buf),
+ "#EXT-X-MAP:URI=\"%s?frag=%" PRIu64 "-%" PRIu64 "\"\r\n",
+ url.c_str(), fragments[j].byte_position,
+ fragments[j + 1].byte_position);
+ playlist += buf;
+ printed_first_header = true;
+ printed_header_for_this_group = true;
+ break;
+ }
+ }
+
+ if (!printed_header_for_this_group && !stream_header.empty()) {
+ if (printed_first_header) {
+ playlist += "#EXT-X-DISCONTINUITY\r\n";
+ }
+ snprintf(buf, sizeof(buf), "#EXT-X-MAP:URI=\"%s?frag=header\"\r\n", url.c_str());
+ playlist += buf;
+ }
+
+ // Even if we didn't find anything, we don't want to search again for each fragment.
+ printed_first_header = true;
+ printed_header_for_this_group = true;
+ }
+
+ if (fragments[i + 1].begins_header) {
+ // Since we only have start pts for each block and not duration,
+ // we have no idea how long this fragment is; the encoder restarted
+ // before it got to output the next pts. However, it's likely
+ // to be very short, so instead of trying to guess, we just skip it.
+ continue;
+ }
+
+ snprintf(buf, sizeof(buf), "#EXTINF:%f,\r\n%s?frag=%" PRIu64 "-%" PRIu64 "\r\n",
+ fragments[i + 1].pts - fragments[i].pts,
+ url.c_str(),
+ fragments[i].byte_position,
+ fragments[i + 1].byte_position);
+ playlist += buf;
+ }
+ }
+
+ string response;
+ if (http_11) {
+ response = "HTTP/1.1 200 OK\r\n";
+ if (close_after_response) {
+ response.append("Connection: close\r\n");
+ }
+ } else {
+ assert(close_after_response);
+ response = "HTTP/1.0 200 OK\r\n";
+ }
+ snprintf(buf, sizeof(buf), "Content-Length: %zu\r\n", playlist.size());
+ response.append(buf);
+ response.append("Content-Type: application/x-mpegURL\r\n");
+ if (!allow_origin.empty()) {
+ response.append("Access-Control-Allow-Origin: ");
+ response.append(allow_origin);
+ response.append("\r\n");
+ }
+ response.append("\r\n");
+ response.append(move(playlist));
+
+ return shared_ptr<const string>(new string(move(response)));
+}