Add standalone NVENC encoder

src/video.h

@@ -7,6 +7,7 @@
 #include "input.h"
 #include "platform/common.h"
 #include "thread_safe.h"
+#include "video_colorspace.h"
 
 extern "C" {
 #include <libavcodec/avcodec.h>
@@ -16,25 +17,19 @@ struct AVPacket;
 namespace video {
 
   struct packet_raw_t {
-    void
-    init_packet() {
-      this->av_packet = av_packet_alloc();
-    }
+    virtual ~packet_raw_t() = default;
 
-    template <class P>
-    explicit packet_raw_t(P *user_data):
-        channel_data { user_data } {
-      init_packet();
-    }
+    virtual bool
+    is_idr() = 0;
 
-    explicit packet_raw_t(std::nullptr_t):
-        channel_data { nullptr } {
-      init_packet();
-    }
+    virtual int64_t
+    frame_index() = 0;
 
-    ~packet_raw_t() {
-      av_packet_free(&this->av_packet);
-    }
+    virtual uint8_t *
+    data() = 0;
+
+    virtual size_t
+    data_size() = 0;
 
     struct replace_t {
       std::string_view old;
@@ -46,13 +41,74 @@ namespace video {
           old { std::move(old) }, _new { std::move(_new) } {}
     };
 
-    AVPacket *av_packet;
-    std::vector<replace_t> *replacements;
-    void *channel_data;
-
+    std::vector<replace_t> *replacements = nullptr;
+    void *channel_data = nullptr;
+    bool after_ref_frame_invalidation = false;
     std::optional<std::chrono::steady_clock::time_point> frame_timestamp;
   };
 
+  struct packet_raw_avcodec: packet_raw_t {
+    packet_raw_avcodec() {
+      av_packet = av_packet_alloc();
+    }
+
+    ~packet_raw_avcodec() {
+      av_packet_free(&this->av_packet);
+    }
+
+    bool
+    is_idr() override {
+      return av_packet->flags & AV_PKT_FLAG_KEY;
+    }
+
+    int64_t
+    frame_index() override {
+      return av_packet->pts;
+    }
+
+    uint8_t *
+    data() override {
+      return av_packet->data;
+    }
+
+    size_t
+    data_size() override {
+      return av_packet->size;
+    }
+
+    AVPacket *av_packet;
+  };
+
+  struct packet_raw_generic: packet_raw_t {
+    packet_raw_generic(std::vector<uint8_t> &&frame_data, int64_t frame_index, bool idr):
+        frame_data { std::move(frame_data) }, index { frame_index }, idr { idr } {
+    }
+
+    bool
+    is_idr() override {
+      return idr;
+    }
+
+    int64_t
+    frame_index() override {
+      return index;
+    }
+
+    uint8_t *
+    data() override {
+      return frame_data.data();
+    }
+
+    size_t
+    data_size() override {
+      return frame_data.size();
+    }
+
+    std::vector<uint8_t> frame_data;
+    int64_t index;
+    bool idr;
+  };
+
   using packet_t = std::unique_ptr<packet_raw_t>;
 
   struct hdr_info_raw_t {
@@ -67,33 +123,29 @@ namespace video {
 
   using hdr_info_t = std::unique_ptr<hdr_info_raw_t>;
 
+  /* Encoding configuration requested by remote client */
   struct config_t {
-    int width;
-    int height;
-    int framerate;
-    int bitrate;
-    int slicesPerFrame;
-    int numRefFrames;
+    int width;  // Video width in pixels
+    int height;  // Video height in pixels
+    int framerate;  // Requested framerate, used in individual frame bitrate budget calculation
+    int bitrate;  // Video bitrate in kilobits (1000 bits) for requested framerate
+    int slicesPerFrame;  // Number of slices per frame
+    int numRefFrames;  // Max number of reference frames
+
+    /* Requested color range and SDR encoding colorspace, HDR encoding colorspace is always BT.2020+ST2084
+       Color range (encoderCscMode & 0x1) : 0 - limited, 1 - full
+       SDR encoding colorspace (encoderCscMode >> 1) : 0 - BT.601, 1 - BT.709, 2 - BT.2020 */
     int encoderCscMode;
-    int videoFormat;
+
+    int videoFormat;  // 0 - H.264, 1 - HEVC
+
+    /* Encoding color depth (bit depth): 0 - 8-bit, 1 - 10-bit
+       HDR encoding activates when color depth is higher than 8-bit and the display which is being captured is operating in HDR mode */
     int dynamicRange;
   };
 
-  using float4 = float[4];
-  using float3 = float[3];
-  using float2 = float[2];
-
-  struct alignas(16) color_t {
-    float4 color_vec_y;
-    float4 color_vec_u;
-    float4 color_vec_v;
-    float2 range_y;
-    float2 range_uv;
-  };
-
-  extern color_t colors[6];
-
   extern int active_hevc_mode;
+  extern bool last_encoder_probe_supported_ref_frames_invalidation;
 
   void
   capture(