Stream(const std::string &url,
size_t backlog_size,
- size_t prebuffering_bytes,
+ uint64_t prebuffering_bytes,
Encoding encoding,
Encoding src_encoding,
unsigned hls_frag_duration,
// Changes the backlog size, restructuring the data as needed.
void set_backlog_size(size_t new_size);
+ // You should hold the owning Server's <mutex>, since it calls add_data_raw().
+ // Sets unavailable to false.
+ void set_header(const std::string &new_http_header, const std::string &new_stream_header);
+
+ void set_unavailable() {
+ unavailable = true;
+ }
+
// Mutex protecting <queued_data> and <queued_data_last_starting_point>.
// Note that if you want to hold both this and the owning server's
// <mutex> you will need to take <mutex> before this one.
std::string url;
+ // If true, the backend is not completely connected, and thus, we cannot serve
+ // clients (except for historic HLS fragments).
+ bool unavailable = true;
+
// The HTTP response header, without the trailing double newline.
std::string http_header;
// This is basically to force a buffer on the client, which can help
// if the client expects us to be able to fill up the buffer much
// faster than realtime (ie., it expects a static file).
- size_t prebuffering_bytes;
+ uint64_t prebuffering_bytes;
// How many bytes this stream have received. Can very well be larger
// than <backlog_size>, since the buffer wraps.
- size_t bytes_received = 0;
+ uint64_t bytes_received = 0;
// A list of points in the stream that is suitable to start new clients at
// (after having sent the header). Empty if no such point exists yet.
- std::deque<size_t> suitable_starting_points;
+ std::deque<uint64_t> suitable_starting_points;
// A list of HLS fragment boundaries currently in the backlog; the first fragment
// is between point 0 and 1, the second is between 1 and 2, and so on.
// extended and thus should not be output. So the last fragment output is
// from points N-3..N-2.
struct FragmentStart {
- size_t byte_position;
- double pts;
+ uint64_t byte_position;
+ double pts; // Unused if begins_header is true.
+
+ // Whether the fragment started at this position is a stream header or not.
+ // Note that headers are stored _after_ the fragments they are headers for,
+ // so that they rotate out of the backlog last (and also because they are
+ // conveniently written then). The most current header is _not_ stored
+ // in the backlog; it is stored in stream_header. Only when replaced
+ // is it committed to the backlog and gets an entry here.
+ bool begins_header;
};
std::deque<FragmentStart> fragments;
- size_t first_fragment_index = 0, discontinuity_counter = 0;
+ uint64_t first_fragment_index = 0, discontinuity_counter = 0;
// HLS target duration, in seconds.
unsigned hls_frag_duration = 6;