X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=x264_encoder.h;h=7a155e341bd0e64b0f0153b8a2977058cd001bf3;hb=f53bc097f57c9875a5c43c43bea5fa596e0bf99f;hp=f607a91df8ab4786f1d27a7df25910ceffe6795f;hpb=dcb3aecf327ab8b2e0bfd9ee21b48d421248da4f;p=nageru

diff --git a/x264_encoder.h b/x264_encoder.h
index f607a91..7a155e3 100644
--- a/x264_encoder.h
+++ b/x264_encoder.h
@@ -3,15 +3,11 @@
 // so a little under 100 MB at 720p), then have a separate thread pull out
 // those threads as fast as we can to give it to x264 for encoding.
 //
-// TODO: We use x264's “speedcontrol” patch if available, so that quality is
-// automatically scaled up or down to content and available CPU time.
-//
 // The encoding threads are niced down because mixing is more important than
 // encoding; if we lose frames in mixing, we'll lose frames to disk _and_
 // to the stream, as where if we lose frames in encoding, we'll lose frames
 // to the stream only, so the latter is strictly better. More importantly,
-// this allows speedcontrol (when implemented) to do its thing without
-// disturbing the mixer.
+// this allows speedcontrol to do its thing without disturbing the mixer.
 
 #ifndef _X264ENCODE_H
 #define _X264ENCODE_H 1
@@ -20,17 +16,27 @@
 #include <stdint.h>
 #include <x264.h>
 #include <atomic>
+#include <chrono>
 #include <condition_variable>
 #include <memory>
 #include <mutex>
 #include <queue>
 #include <string>
 #include <thread>
+#include <unordered_map>
+#include <vector>
 
 extern "C" {
 #include <libavformat/avformat.h>
 }
 
+#include <movit/image_format.h>
+
+#include "defs.h"
+#include "metrics.h"
+#include "print_latency.h"
+#include "x264_dynamic.h"
+
 class Mux;
 class X264SpeedControl;
 
@@ -43,11 +49,11 @@ public:
 	~X264Encoder();
 
 	// Must be called before first frame. Does not take ownership.
-	void set_mux(Mux *mux) { this->mux = mux; }
+	void add_mux(Mux *mux) { muxes.push_back(mux); }
 
 	// <data> is taken to be raw NV12 data of WIDTHxHEIGHT resolution.
 	// Does not block.
-	void add_frame(int64_t pts, int64_t duration, const uint8_t *data);
+	void add_frame(int64_t pts, int64_t duration, movit::YCbCrLumaCoefficients ycbcr_coefficients, const uint8_t *data, const ReceivedTimestamps &received_ts);
 
 	std::string get_global_headers() const {
 		while (!x264_init_done) {
@@ -63,7 +69,9 @@ public:
 private:
 	struct QueuedFrame {
 		int64_t pts, duration;
+		movit::YCbCrLumaCoefficients ycbcr_coefficients;
 		uint8_t *data;
+		ReceivedTimestamps received_ts;
 	};
 	void encoder_thread_func();
 	void init_x264();
@@ -74,7 +82,7 @@ private:
 	// pool.
 	std::unique_ptr<uint8_t[]> frame_pool;
 
-	Mux *mux = nullptr;
+	std::vector<Mux *> muxes;
 	bool wants_global_headers;
 
 	std::string global_headers;
@@ -83,9 +91,12 @@ private:
 	std::thread encoder_thread;
 	std::atomic<bool> x264_init_done{false};
 	std::atomic<bool> should_quit{false};
+	X264Dynamic dyn;
 	x264_t *x264;
 	std::unique_ptr<X264SpeedControl> speed_control;
 
+	std::function<void(x264_param_t *)> bitrate_override_func;
+
 	std::atomic<unsigned> new_bitrate_kbit{0};  // 0 for no change.
 
 	// Protects everything below it.
@@ -101,6 +112,9 @@ private:
 
 	// Whenever the state of <queued_frames> changes.
 	std::condition_variable queued_frames_nonempty;
+
+	// Key is the pts of the frame.
+	std::unordered_map<int64_t, ReceivedTimestamps> frames_being_encoded;
 };
 
 #endif  // !defined(_X264ENCODE_H)