pixelflux 1.3.1__tar.gz → 1.3.3__tar.gz

{pixelflux-1.3.1/pixelflux.egg-info → pixelflux-1.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pixelflux
-Version: 1.3.1
+Version: 1.3.3
 Summary: A performant web native pixel delivery pipeline for diverse sources, blending VNC-inspired parallel processing of pixel buffers with flexible modern encoding formats.
 Home-page: https://github.com/linuxserver/pixelflux
 Author: Linuxserver.io
@@ -87,15 +87,20 @@ settings.output_mode = 1
 # Force CPU encoding and ignore hardware encoders
 capture_settings.use_cpu = False
 
+# --- Debugging ---
+settings.debug_logging = False # Enable/disable the continuous FPS and settings log to the console.
+
 # --- JPEG Settings ---
 settings.jpeg_quality = 75              # Quality for changed stripes (0-100)
 settings.paint_over_jpeg_quality = 90   # Quality for static "paint-over" stripes (0-100)
 
 # --- H.264 Settings ---
-settings.h264_crf = 23                  # CRF value (0-51, lower is better quality/higher bitrate)
-settings.h264_fullcolor = False         # Use I444 (full color) instead of I420 for software encoding
-settings.h264_fullframe = True          # Encode full frames (required for HW accel) instead of just changed stripes
-settings.h264_streaming_mode = False    # Bypass all VNC logic and work like a normal video encoder, higher constant CPU usage for fullscreen gaming/videos
+settings.h264_crf = 25                   # CRF value (0-51, lower is better quality/higher bitrate)
+settings.h264_paintover_crf = 18         # CRF for H.264 paintover on static content. Must be lower than h264_crf to activate.
+settings.h264_paintover_burst_frames = 5 # Number of high-quality frames to send in a burst when a paintover is triggered.
+settings.h264_fullcolor = False          # Use I444 (full color) instead of I420 for software encoding
+settings.h264_fullframe = True           # Encode full frames (required for HW accel) instead of just changed stripes
+settings.h264_streaming_mode = False     # Bypass all VNC logic and work like a normal video encoder, higher constant CPU usage for fullscreen gaming/videos
 
 # --- Hardware Acceleration ---
 # Set to >= 0 to enable VA-API on a specific /dev/dri/renderD* node.

{pixelflux-1.3.1 → pixelflux-1.3.3}/README.md

@@ -73,15 +73,20 @@ settings.output_mode = 1
 # Force CPU encoding and ignore hardware encoders
 capture_settings.use_cpu = False
 
+# --- Debugging ---
+settings.debug_logging = False # Enable/disable the continuous FPS and settings log to the console.
+
 # --- JPEG Settings ---
 settings.jpeg_quality = 75              # Quality for changed stripes (0-100)
 settings.paint_over_jpeg_quality = 90   # Quality for static "paint-over" stripes (0-100)
 
 # --- H.264 Settings ---
-settings.h264_crf = 23                  # CRF value (0-51, lower is better quality/higher bitrate)
-settings.h264_fullcolor = False         # Use I444 (full color) instead of I420 for software encoding
-settings.h264_fullframe = True          # Encode full frames (required for HW accel) instead of just changed stripes
-settings.h264_streaming_mode = False    # Bypass all VNC logic and work like a normal video encoder, higher constant CPU usage for fullscreen gaming/videos
+settings.h264_crf = 25                   # CRF value (0-51, lower is better quality/higher bitrate)
+settings.h264_paintover_crf = 18         # CRF for H.264 paintover on static content. Must be lower than h264_crf to activate.
+settings.h264_paintover_burst_frames = 5 # Number of high-quality frames to send in a burst when a paintover is triggered.
+settings.h264_fullcolor = False          # Use I444 (full color) instead of I420 for software encoding
+settings.h264_fullframe = True           # Encode full frames (required for HW accel) instead of just changed stripes
+settings.h264_streaming_mode = False     # Bypass all VNC logic and work like a normal video encoder, higher constant CPU usage for fullscreen gaming/videos
 
 # --- Hardware Acceleration ---
 # Set to >= 0 to enable VA-API on a specific /dev/dri/renderD* node.

{pixelflux-1.3.1 → pixelflux-1.3.3}/pixelflux/__init__.py

@@ -16,6 +16,8 @@ class CaptureSettings(ctypes.Structure):
         ("damage_block_duration", ctypes.c_int),
         ("output_mode", ctypes.c_int),
         ("h264_crf", ctypes.c_int),
+        ("h264_paintover_crf", ctypes.c_int),
+        ("h264_paintover_burst_frames", ctypes.c_int),
         ("h264_fullcolor", ctypes.c_bool),
         ("h264_fullframe", ctypes.c_bool),
         ("h264_streaming_mode", ctypes.c_bool),
@@ -24,6 +26,7 @@ class CaptureSettings(ctypes.Structure):
         ("watermark_location_enum", ctypes.c_int),
         ("vaapi_render_node_index", ctypes.c_int),
         ("use_cpu", ctypes.c_bool),
+        ("debug_logging", ctypes.c_bool),
     ]
 
 WATERMARK_LOCATION_NONE = 0

{pixelflux-1.3.1 → pixelflux-1.3.3}/pixelflux/screen_capture_module.cpp

@@ -288,12 +288,6 @@ enum class WatermarkLocation : int {
   NONE = 0, TL = 1, TR = 2, BL = 3, BR = 4, MI = 5, AN = 6
 };
 
-/** 
- * @brief Defines static paintover settings for CPU encoding
- */ 
-const int H264_PAINTOVER_BURST_FRAMES = 3;
-const int H264_PAINTOVER_CRF = 18;
-
 /**
  * @brief Holds settings for screen capture and encoding.
  * This struct aggregates all configurable parameters for the capture process,
@@ -313,6 +307,8 @@ struct CaptureSettings {
   int damage_block_duration;
   OutputMode output_mode;
   int h264_crf;
+  int h264_paintover_crf;
+  int h264_paintover_burst_frames;
   bool h264_fullcolor;
   bool h264_fullframe;
   bool h264_streaming_mode;
@@ -321,6 +317,7 @@ struct CaptureSettings {
   WatermarkLocation watermark_location_enum;
   int vaapi_render_node_index;
   bool use_cpu;
+  bool debug_logging;
 
   /**
    * @brief Default constructor for CaptureSettings.
@@ -340,6 +337,8 @@ struct CaptureSettings {
       damage_block_duration(30),
       output_mode(OutputMode::JPEG),
       h264_crf(25),
+      h264_paintover_crf(18),
+      h264_paintover_burst_frames(5),
       h264_fullcolor(false),
       h264_fullframe(false),
       h264_streaming_mode(false),
@@ -347,7 +346,8 @@ struct CaptureSettings {
       watermark_path(nullptr),
       watermark_location_enum(WatermarkLocation::NONE),
       vaapi_render_node_index(-1),
-      use_cpu(false) {}
+      use_cpu(false),
+      debug_logging(false) {}
 
   /**
    * @brief Parameterized constructor for CaptureSettings.
@@ -371,12 +371,12 @@ struct CaptureSettings {
    */
   CaptureSettings(int cw, int ch, int cx, int cy, double fps, int jq,
                   int pojq, bool upoq, int potf, int dbt, int dbd,
-                  OutputMode om = OutputMode::JPEG, int crf = 25,
+                  OutputMode om = OutputMode::JPEG, int crf = 25, int h264_po_crf = 18, int h264_po_burst = 5,
                   bool h264_fc = false, bool h264_ff = false, bool h264_sm = false,
                   bool capture_cursor = false,
                   const char* wm_path = nullptr,
                   WatermarkLocation wm_loc = WatermarkLocation::NONE,
-                  int vaapi_idx = -1, bool use_cpu_flag = false)
+                  int vaapi_idx = -1, bool use_cpu_flag = false, bool debug_log = false)
     : capture_width(cw),
       capture_height(ch),
       capture_x(cx),
@@ -390,6 +390,8 @@ struct CaptureSettings {
       damage_block_duration(dbd),
       output_mode(om),
       h264_crf(crf),
+      h264_paintover_crf(h264_po_crf),
+      h264_paintover_burst_frames(h264_po_burst),
       h264_fullcolor(h264_fc),
       h264_fullframe(h264_ff),
       h264_streaming_mode(h264_sm),
@@ -397,7 +399,8 @@ struct CaptureSettings {
       watermark_path(wm_path),
       watermark_location_enum(wm_loc),
       vaapi_render_node_index(vaapi_idx),
-      use_cpu(use_cpu_flag) {}
+      use_cpu(use_cpu_flag),
+      debug_logging(debug_log) {}
 };
 
 /**
@@ -708,6 +711,34 @@ bool initialize_nvenc_encoder(int width,
     return true;
   }
 
+  if (g_nvenc_state.initialized && g_nvenc_state.initialized_width == width &&
+      g_nvenc_state.initialized_height == height &&
+      g_nvenc_state.initialized_buffer_format == target_buffer_format) {
+
+    NV_ENC_RECONFIGURE_PARAMS reconfigure_params = {0};
+    NV_ENC_CONFIG new_config = g_nvenc_state.encode_config;
+
+    reconfigure_params.version = NV_ENC_RECONFIGURE_PARAMS_VER;
+    reconfigure_params.reInitEncodeParams = g_nvenc_state.init_params;
+    reconfigure_params.reInitEncodeParams.encodeConfig = &new_config;
+    
+    new_config.rcParams.constQP.qpInterP = target_qp;
+    new_config.rcParams.constQP.qpIntra = target_qp;
+    new_config.rcParams.constQP.qpInterB = target_qp;
+    
+    bool is_quality_increasing = (target_qp < g_nvenc_state.initialized_qp);
+    reconfigure_params.forceIDR = is_quality_increasing;
+
+    NVENCSTATUS status = g_nvenc_state.nvenc_funcs.nvEncReconfigureEncoder(
+        g_nvenc_state.encoder_session, &reconfigure_params);
+
+    if (status == NV_ENC_SUCCESS) {
+        g_nvenc_state.initialized_qp = target_qp;
+        g_nvenc_state.encode_config = new_config;
+        return true;
+    }
+  }
+
   if (g_nvenc_state.initialized) {
     g_nvenc_mutex.unlock();
     reset_nvenc_encoder();
@@ -1705,6 +1736,8 @@ public:
   int damage_block_threshold = 15;
   int damage_block_duration = 30;
   int h264_crf = 25;
+  int h264_paintover_crf = 18;
+  int h264_paintover_burst_frames = 5;
   bool h264_fullcolor = false;
   bool h264_fullframe = false;
   bool h264_streaming_mode = false;
@@ -1713,6 +1746,7 @@ public:
   std::string watermark_path_internal;
   WatermarkLocation watermark_location_internal;
   bool use_cpu = false;
+  bool debug_logging = false;
 
   std::atomic<bool> stop_requested;
   std::thread capture_thread;
@@ -1852,12 +1886,15 @@ public:
     damage_block_duration = new_settings.damage_block_duration;
     output_mode = new_settings.output_mode;
     h264_crf = new_settings.h264_crf;
+    h264_paintover_crf = new_settings.h264_paintover_crf;
+    h264_paintover_burst_frames = new_settings.h264_paintover_burst_frames;
     h264_fullcolor = new_settings.h264_fullcolor;
     h264_fullframe = new_settings.h264_fullframe;
     h264_streaming_mode = new_settings.h264_streaming_mode;
     capture_cursor = new_settings.capture_cursor;
     vaapi_render_node_index = new_settings.vaapi_render_node_index;
     use_cpu = new_settings.use_cpu;
+    debug_logging = new_settings.debug_logging;
     std::string new_wm_path_str = new_settings.watermark_path ? new_settings.watermark_path : "";
     bool path_actually_changed_in_settings = (watermark_path_internal != new_wm_path_str);
   
@@ -1883,9 +1920,10 @@ public:
       jpeg_quality, paint_over_jpeg_quality, use_paint_over_quality,
       paint_over_trigger_frames, damage_block_threshold,
       damage_block_duration, output_mode, h264_crf,
+      h264_paintover_crf, h264_paintover_burst_frames,
       h264_fullcolor, h264_fullframe, h264_streaming_mode, capture_cursor,
       watermark_path_internal.c_str(), watermark_location_internal,
-      vaapi_render_node_index, use_cpu
+      vaapi_render_node_index, use_cpu, debug_logging
       );
   }
 
@@ -2009,6 +2047,8 @@ private:
     int local_current_damage_block_threshold;
     int local_current_damage_block_duration;
     int local_current_h264_crf;
+    int local_current_h264_paintover_crf;
+    int local_current_h264_paintover_burst_frames;
     bool local_current_h264_fullcolor;
     bool local_current_h264_fullframe;
     bool local_current_h264_streaming_mode;
@@ -2020,6 +2060,7 @@ private:
     std::string local_watermark_path_setting;
     WatermarkLocation local_watermark_location_setting;
     bool local_use_cpu;
+    bool local_debug_logging;
 
     {
       std::lock_guard<std::mutex> lock(settings_mutex);
@@ -2036,12 +2077,15 @@ private:
       local_current_damage_block_duration = damage_block_duration;
       local_current_output_mode = output_mode;
       local_current_h264_crf = h264_crf;
+      local_current_h264_paintover_crf = h264_paintover_crf;
+      local_current_h264_paintover_burst_frames = h264_paintover_burst_frames;
       local_current_h264_fullcolor = h264_fullcolor;
       local_current_h264_fullframe = h264_fullframe;
       local_current_h264_streaming_mode = h264_streaming_mode;
       local_current_capture_cursor = capture_cursor;
       local_vaapi_render_node_index = vaapi_render_node_index;
       local_use_cpu = use_cpu;
+      local_debug_logging = debug_logging;
       local_watermark_path_setting = watermark_path_internal;
       local_watermark_location_setting = watermark_location_internal;
     }
@@ -2112,6 +2156,25 @@ private:
     }
     Window root_window = DefaultRootWindow(display);
     int screen = DefaultScreen(display);
+    XWindowAttributes attributes;
+    if (XGetWindowAttributes(display, root_window, &attributes)) {
+        if (local_capture_width_actual > attributes.width) {
+            local_capture_width_actual = attributes.width;
+            local_capture_x_offset = 0;
+        }
+        if (local_capture_height_actual > attributes.height) {
+            local_capture_height_actual = attributes.height;
+            local_capture_y_offset = 0;
+        }
+        if (local_capture_x_offset + local_capture_width_actual > attributes.width) {
+            local_capture_x_offset = attributes.width - local_capture_width_actual;
+        }
+        if (local_capture_y_offset + local_capture_height_actual > attributes.height) {
+            local_capture_y_offset = attributes.height - local_capture_height_actual;
+        }
+        if (local_capture_x_offset < 0) local_capture_x_offset = 0;
+        if (local_capture_y_offset < 0) local_capture_y_offset = 0;
+    }
 
     if (!XShmQueryExtension(display)) {
       std::cerr << "Error: X Shared Memory Extension not available!" << std::endl;
@@ -2215,6 +2278,66 @@ private:
     std::cout << "CPU cores available: " << num_cores << std::endl;
     int num_stripes_config = num_cores;
 
+    int N_processing_stripes;
+    if (local_capture_height_actual <= 0) {
+      N_processing_stripes = 0;
+    } else {
+      if (local_current_output_mode == OutputMode::H264) {
+        if (local_current_h264_fullframe) {
+          N_processing_stripes = 1;
+        } else {
+          const int MIN_H264_STRIPE_HEIGHT_PX = 64;
+          if (local_capture_height_actual < MIN_H264_STRIPE_HEIGHT_PX) {
+            N_processing_stripes = 1;
+          } else {
+            int max_stripes_by_min_height =
+              local_capture_height_actual / MIN_H264_STRIPE_HEIGHT_PX;
+            N_processing_stripes =
+              std::min(num_stripes_config, max_stripes_by_min_height);
+            if (N_processing_stripes == 0) N_processing_stripes = 1;
+          }
+        }
+      } else {
+        N_processing_stripes =
+          std::min(num_stripes_config, local_capture_height_actual);
+        if (N_processing_stripes == 0 && local_capture_height_actual > 0) {
+          N_processing_stripes = 1;
+        }
+      }
+    }
+    if (N_processing_stripes == 0 && local_capture_height_actual > 0) {
+       N_processing_stripes = 1;
+    }
+    std::stringstream settings_ss;
+    settings_ss << "Stream settings active -> Res: " << local_capture_width_actual << "x"
+                << local_capture_height_actual
+                << " | FPS: " << std::fixed << std::setprecision(1) << local_current_target_fps
+                << " | Stripes: " << N_processing_stripes;
+    if (local_current_output_mode == OutputMode::JPEG) {
+        settings_ss << " | Mode: JPEG";
+        settings_ss << " | Quality: " << local_current_jpeg_quality;
+        if (local_current_use_paint_over_quality) {
+            settings_ss << " | PaintOver Q: " << local_current_paint_over_jpeg_quality
+                        << " (Trigger: " << local_current_paint_over_trigger_frames << "f)";
+        }
+    } else {
+        std::string encoder_type = "CPU";
+        if (this->vaapi_operational) encoder_type = "VAAPI";
+        else if (this->nvenc_operational) encoder_type = "NVENC";
+        settings_ss << " | Mode: H264 (" << encoder_type << ")";
+        settings_ss << (local_current_h264_fullframe ? " FullFrame" : " Striped");
+        if (local_current_h264_streaming_mode) settings_ss << " Streaming";
+        settings_ss << " | CRF: " << local_current_h264_crf;
+        if (local_current_use_paint_over_quality) {
+            settings_ss << " | PaintOver CRF: " << local_current_h264_paintover_crf
+                        << " (Burst: " << local_current_h264_paintover_burst_frames << "f)";
+        }
+        settings_ss << " | Colorspace: " << (local_current_h264_fullcolor ? "I444 (Full Range)" : "I420 (Limited Range)");
+    }
+    settings_ss << " | Damage Thresh: " << local_current_damage_block_threshold << "f"
+                << " | Damage Dur: " << local_current_damage_block_duration << "f";
+    std::cout << settings_ss.str() << std::endl;
+
     std::vector<uint64_t> previous_hashes(num_stripes_config, 0);
     std::vector<int> no_motion_frame_counts(num_stripes_config, 0);
     std::vector<bool> paint_over_sent(num_stripes_config, false);
@@ -2276,6 +2399,8 @@ private:
         }
         local_current_output_mode = output_mode;
         local_current_h264_crf = h264_crf;
+        local_current_h264_paintover_crf = h264_paintover_crf;
+        local_current_h264_paintover_burst_frames = h264_paintover_burst_frames;
         local_current_h264_fullcolor = h264_fullcolor;
         local_current_h264_fullframe = h264_fullframe;
         local_current_h264_streaming_mode = h264_streaming_mode;
@@ -2284,6 +2409,7 @@ private:
         local_watermark_path_setting = watermark_path_internal;
         local_watermark_location_setting = watermark_location_internal;
         local_use_cpu = use_cpu;
+        local_debug_logging = debug_logging;
       }
 
       bool current_watermark_is_actually_loaded_in_loop;
@@ -2757,7 +2883,7 @@ private:
           int crf_for_encode = local_current_h264_crf;
           if (local_current_output_mode == OutputMode::H264 && h264_paintover_burst_frames_remaining[i] > 0) {
               send_this_stripe = true;
-              crf_for_encode = H264_PAINTOVER_CRF;
+              crf_for_encode = local_current_h264_paintover_crf;
               h264_paintover_burst_frames_remaining[i]--;
               current_hash = calculate_current_hash();
               hash_calculated_this_iteration = true;
@@ -2808,17 +2934,27 @@ private:
                   consecutive_stripe_changes[i] = 0;
                   no_motion_frame_counts[i]++;
                   if (no_motion_frame_counts[i] >= local_current_paint_over_trigger_frames && !paint_over_sent[i]) {
-                      if (local_current_output_mode == OutputMode::JPEG && local_current_use_paint_over_quality) {
+                      if (local_current_output_mode == OutputMode::JPEG && 
+                          local_current_use_paint_over_quality &&
+                          local_current_paint_over_jpeg_quality > local_current_jpeg_quality) {
                           send_this_stripe = true;
                           current_jpeg_qualities[i] = local_current_paint_over_jpeg_quality;
                           paint_over_sent[i] = true;
                       } else if (local_current_output_mode == OutputMode::H264) {
-                          if (H264_PAINTOVER_CRF < local_current_h264_crf) {
+                          if (local_current_use_paint_over_quality && local_current_h264_paintover_crf < local_current_h264_crf) {
                               send_this_stripe = true;
-                              force_idr_for_paintover = true;
-                              crf_for_encode = H264_PAINTOVER_CRF;
-                              h264_paintover_burst_frames_remaining[i] = H264_PAINTOVER_BURST_FRAMES - 1;
                               paint_over_sent[i] = true;
+                              if (this->nvenc_operational) {
+                                  g_nvenc_force_next_idr_global = true;
+                                  h264_paintover_burst_frames_remaining[i] = local_current_h264_paintover_burst_frames - 1;
+                              } else if (this->vaapi_operational) {
+                                  g_vaapi_force_next_idr_global = true;
+                                  h264_paintover_burst_frames_remaining[i] = 0;
+                              } else {
+                                  force_idr_for_paintover = true;
+                                  crf_for_encode = local_current_h264_paintover_crf;
+                                  h264_paintover_burst_frames_remaining[i] = local_current_h264_paintover_burst_frames - 1;
+                              }
                           }
                       }
                   }
@@ -2865,6 +3001,16 @@ private:
                 futures.push_back(task.get_future());
                 threads.push_back(std::thread(std::move(task)));
               } else if (this->nvenc_operational) {
+                int target_qp_for_frame = crf_for_encode;
+                if (local_current_use_paint_over_quality && g_nvenc_force_next_idr_global) {
+                    target_qp_for_frame = local_current_h264_paintover_crf;
+                }
+                if (!initialize_nvenc_encoder(local_capture_width_actual, local_capture_height_actual, target_qp_for_frame, local_current_target_fps, local_current_h264_fullcolor)) {
+                    std::cerr << "NVENC: Re-initialization for QP change failed. Disabling NVENC." << std::endl;
+                    this->nvenc_operational = false;
+                    reset_nvenc_encoder();
+                    continue;
+                }
                 std::packaged_task<StripeEncodeResult()> task([=]() {
                     bool force_idr = g_nvenc_force_next_idr_global.exchange(false);
                     return encode_fullframe_nvenc(
@@ -2877,7 +3023,7 @@ private:
                     );
                 });
                 futures.push_back(task.get_future());
-                threads.push_back(std::thread(std::move(task))); 
+                threads.push_back(std::thread(std::move(task)));
               } else {
                 if (force_idr_for_paintover) {
                   std::lock_guard<std::mutex> lock(g_h264_minimal_store.store_mutex);
@@ -2982,7 +3128,7 @@ private:
           std::chrono::duration_cast<std::chrono::seconds>(
             current_output_time_log - last_output_time);
 
-        if (output_elapsed_time_log.count() >= 1) {
+        if (local_debug_logging && output_elapsed_time_log.count() >= 1) {
           double actual_fps_val =
             (encoded_frame_count > 0 && output_elapsed_time_log.count() > 0)
             ? static_cast<double>(encoded_frame_count) / output_elapsed_time_log.count()

{pixelflux-1.3.1 → pixelflux-1.3.3/pixelflux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pixelflux
-Version: 1.3.1
+Version: 1.3.3
 Summary: A performant web native pixel delivery pipeline for diverse sources, blending VNC-inspired parallel processing of pixel buffers with flexible modern encoding formats.
 Home-page: https://github.com/linuxserver/pixelflux
 Author: Linuxserver.io
@@ -87,15 +87,20 @@ settings.output_mode = 1
 # Force CPU encoding and ignore hardware encoders
 capture_settings.use_cpu = False
 
+# --- Debugging ---
+settings.debug_logging = False # Enable/disable the continuous FPS and settings log to the console.
+
 # --- JPEG Settings ---
 settings.jpeg_quality = 75              # Quality for changed stripes (0-100)
 settings.paint_over_jpeg_quality = 90   # Quality for static "paint-over" stripes (0-100)
 
 # --- H.264 Settings ---
-settings.h264_crf = 23                  # CRF value (0-51, lower is better quality/higher bitrate)
-settings.h264_fullcolor = False         # Use I444 (full color) instead of I420 for software encoding
-settings.h264_fullframe = True          # Encode full frames (required for HW accel) instead of just changed stripes
-settings.h264_streaming_mode = False    # Bypass all VNC logic and work like a normal video encoder, higher constant CPU usage for fullscreen gaming/videos
+settings.h264_crf = 25                   # CRF value (0-51, lower is better quality/higher bitrate)
+settings.h264_paintover_crf = 18         # CRF for H.264 paintover on static content. Must be lower than h264_crf to activate.
+settings.h264_paintover_burst_frames = 5 # Number of high-quality frames to send in a burst when a paintover is triggered.
+settings.h264_fullcolor = False          # Use I444 (full color) instead of I420 for software encoding
+settings.h264_fullframe = True           # Encode full frames (required for HW accel) instead of just changed stripes
+settings.h264_streaming_mode = False     # Bypass all VNC logic and work like a normal video encoder, higher constant CPU usage for fullscreen gaming/videos
 
 # --- Hardware Acceleration ---
 # Set to >= 0 to enable VA-API on a specific /dev/dri/renderD* node.

{pixelflux-1.3.1 → pixelflux-1.3.3}/pyproject.toml

@@ -5,6 +5,10 @@ build-backend = "setuptools.build_meta"
 [tool.cibuildwheel]
 archs = [ "x86_64", "aarch64" ]
 
+# Add this new section
+[tool.cibuildwheel.environment]
+LD_LIBRARY_PATH = "/usr/local/lib:/usr/local/lib64"
+
 [tool.cibuildwheel.linux]
 before-all = """
     set -euxo pipefail
@@ -15,7 +19,6 @@ before-all = """
         dnf install -y \
             libX11-devel \
             libXext-devel \
-            libjpeg-turbo-devel \
             libev-devel \
             libXcomposite-devel \
             libva-devel \
@@ -46,6 +49,14 @@ before-all = """
                 make install); \
         fi && \
         \
+        (cd /tmp && \
+            git clone --branch 3.1.1 --depth 1 https://github.com/libjpeg-turbo/libjpeg-turbo.git && \
+            cd libjpeg-turbo && \
+            mkdir build && cd build && \
+            cmake .. -DCMAKE_INSTALL_PREFIX=/usr/local -DCMAKE_BUILD_TYPE=Release && \
+            make -j$(nproc) && \
+            make install) && \
+        \
         ldconfig
 
     elif command -v apk; then

{pixelflux-1.3.1 → pixelflux-1.3.3}/setup.py

@@ -53,7 +53,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="pixelflux",
-    version="1.3.1",
+    version="1.3.3",
     author="Linuxserver.io",
     author_email="pypi@linuxserver.io",
     description="A performant web native pixel delivery pipeline for diverse sources, blending VNC-inspired parallel processing of pixel buffers with flexible modern encoding formats.",