pixelflux 1.4.3__tar.gz → 1.4.5__tar.gz

{pixelflux-1.4.3/pixelflux.egg-info → pixelflux-1.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pixelflux
-Version: 1.4.3
+Version: 1.4.5
 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
@@ -32,6 +32,7 @@ This module relies on a native C++ extension that is compiled during installatio
     sudo apt-get update && \
     sudo apt-get install -y \
       g++ \
+      libavcodec-dev \
       libdrm-dev \
       libjpeg-turbo8-dev \
       libva-dev \

{pixelflux-1.4.3 → pixelflux-1.4.5}/README.md

@@ -18,6 +18,7 @@ This module relies on a native C++ extension that is compiled during installatio
     sudo apt-get update && \
     sudo apt-get install -y \
       g++ \
+      libavcodec-dev \
       libdrm-dev \
       libjpeg-turbo8-dev \
       libva-dev \

{pixelflux-1.4.3 → pixelflux-1.4.5}/pixelflux/screen_capture_module.cpp

@@ -148,6 +148,19 @@ struct VaapiEncoderState {
     unsigned int frame_count = 0;
 };
 
+
+/**
+ * @brief Custom X11 error handler specifically for the XShmAttach call.
+ * This function is temporarily installed as the X11 error handler. It catches
+ * any error, sets the g_shm_attach_failed flag to true, and returns 0 to
+ * signal that the error has been "handled," preventing program termination.
+ */
+static bool g_shm_attach_failed = false;
+static int shm_attach_error_handler(Display* dpy, XErrorEvent* ev) {
+    g_shm_attach_failed = true;
+    return 0;
+}
+
 /**
  * @brief Manages a pool of H.264 encoders and associated picture buffers.
  * This struct provides thread-safe storage and management for x264 encoder
@@ -1577,37 +1590,39 @@ StripeEncodeResult ScreenCaptureModule::encode_fullframe_vaapi(int width, int he
     if (ret < 0) {
         throw std::runtime_error("VAAPI_ENCODE_ERROR: Failed to send frame to encoder: " + std::to_string(ret));
     }
-    ret = avcodec_receive_packet(vaapi_state_.codec_ctx, vaapi_state_.packet);
-    if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
-        return {}; 
-    } else if (ret < 0) {
-        throw std::runtime_error("VAAPI_ENCODE_ERROR: Failed to receive packet from encoder: " + std::to_string(ret));
-    }
-    StripeEncodeResult result;
-    result.type = StripeDataType::H264;
-    result.stripe_y_start = 0;
-    result.stripe_height = height;
-    result.frame_id = frame_counter;
-    if (vaapi_state_.packet->size > 0) {
-        const unsigned char TAG = 0x04;
-        unsigned char type_hdr = (vaapi_state_.packet->flags & AV_PKT_FLAG_KEY) ? 0x01 : 0x00;
-        int header_sz = 10;
-        result.data = new unsigned char[vaapi_state_.packet->size + header_sz];
-        result.size = vaapi_state_.packet->size + header_sz;
-        result.data[0] = TAG;
-        result.data[1] = type_hdr;
-        uint16_t net_val = htons(static_cast<uint16_t>(result.frame_id % 65536));
-        std::memcpy(result.data + 2, &net_val, 2);
-        net_val = htons(static_cast<uint16_t>(result.stripe_y_start));
-        std::memcpy(result.data + 4, &net_val, 2);
-        net_val = htons(static_cast<uint16_t>(width));
-        std::memcpy(result.data + 6, &net_val, 2);
-        net_val = htons(static_cast<uint16_t>(height));
-        std::memcpy(result.data + 8, &net_val, 2);
-        std::memcpy(result.data + header_sz, vaapi_state_.packet->data, vaapi_state_.packet->size);
-    }
-    av_packet_unref(vaapi_state_.packet);
-    return result;
+    while (true) {
+        ret = avcodec_receive_packet(vaapi_state_.codec_ctx, vaapi_state_.packet);
+        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
+            return {};
+        } else if (ret < 0) {
+            throw std::runtime_error("VAAPI_ENCODE_ERROR: Failed to receive packet from encoder: " + std::to_string(ret));
+        }
+        StripeEncodeResult result;
+        result.type = StripeDataType::H264;
+        result.stripe_y_start = 0;
+        result.stripe_height = height;
+        result.frame_id = frame_counter;
+        if (vaapi_state_.packet->size > 0) {
+            const unsigned char TAG = 0x04;
+            unsigned char type_hdr = (vaapi_state_.packet->flags & AV_PKT_FLAG_KEY) ? 0x01 : 0x00;
+            int header_sz = 10;
+            result.data = new unsigned char[vaapi_state_.packet->size + header_sz];
+            result.size = vaapi_state_.packet->size + header_sz;
+            result.data[0] = TAG;
+            result.data[1] = type_hdr;
+            uint16_t net_val = htons(static_cast<uint16_t>(result.frame_id % 65536));
+            std::memcpy(result.data + 2, &net_val, 2);
+            net_val = htons(static_cast<uint16_t>(result.stripe_y_start));
+            std::memcpy(result.data + 4, &net_val, 2);
+            net_val = htons(static_cast<uint16_t>(width));
+            std::memcpy(result.data + 6, &net_val, 2);
+            net_val = htons(static_cast<uint16_t>(height));
+            std::memcpy(result.data + 8, &net_val, 2);
+            std::memcpy(result.data + header_sz, vaapi_state_.packet->data, vaapi_state_.packet->size);
+        }
+        av_packet_unref(vaapi_state_.packet);
+        return result;
+    }
 }
 
 /**
@@ -1871,16 +1886,21 @@ void ScreenCaptureModule::capture_loop() {
     auto next_frame_time =
       std::chrono::high_resolution_clock::now() + target_frame_duration_seconds;
 
+    const int MAX_ATTACH_ATTEMPTS = 5;
+    const int RETRY_BACKOFF_MS = 500;
     char* display_env = std::getenv("DISPLAY");
     const char* display_name = display_env ? display_env : ":0";
     Display* display = XOpenDisplay(display_name);
+
     if (!display) {
       std::cerr << "Error: Failed to open X display " << display_name << std::endl;
       return;
     }
+
     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;
@@ -1905,6 +1925,7 @@ void ScreenCaptureModule::capture_loop() {
       XCloseDisplay(display);
       return;
     }
+
     std::cout << "X Shared Memory Extension available." << std::endl;
 
     if (local_current_capture_cursor) {
@@ -1913,55 +1934,73 @@ void ScreenCaptureModule::capture_loop() {
         XCloseDisplay(display);
         return;
       }
-
       std::cout << "XFixes Extension available." << std::endl;
     }
 
     XShmSegmentInfo shminfo;
-    memset(&shminfo, 0, sizeof(shminfo));
     XImage* shm_image = nullptr;
+    bool shm_setup_complete = false;
 
-    shm_image = XShmCreateImage(
-      display, DefaultVisual(display, screen), DefaultDepth(display, screen),
-      ZPixmap, nullptr, &shminfo, local_capture_width_actual,
-      local_capture_height_actual);
-    if (!shm_image) {
-      std::cerr << "Error: XShmCreateImage failed for "
-                << local_capture_width_actual << "x"
-                << local_capture_height_actual << std::endl;
-      XCloseDisplay(display);
-      return;
-    }
+    for (int attempt = 1; attempt <= MAX_ATTACH_ATTEMPTS; ++attempt) {
+        memset(&shminfo, 0, sizeof(shminfo));
+        shm_image = XShmCreateImage(display, DefaultVisual(display, screen), DefaultDepth(display, screen),
+                                    ZPixmap, nullptr, &shminfo, local_capture_width_actual,
+                                    local_capture_height_actual);
+        if (!shm_image) {
+            std::cerr << "Attempt " << attempt << ": XShmCreateImage failed." << std::endl;
+            if (attempt < MAX_ATTACH_ATTEMPTS) std::this_thread::sleep_for(std::chrono::milliseconds(RETRY_BACKOFF_MS));
+            continue;
+        }
 
-    shminfo.shmid = shmget(IPC_PRIVATE,
-                           static_cast<size_t>(shm_image->bytes_per_line) * shm_image->height,
-                           IPC_CREAT | 0600);
-    if (shminfo.shmid < 0) {
-      perror("shmget");
-      XDestroyImage(shm_image);
-      XCloseDisplay(display);
-      return;
-    }
+        shminfo.shmid = shmget(IPC_PRIVATE, static_cast<size_t>(shm_image->bytes_per_line) * shm_image->height, IPC_CREAT | 0600);
+        if (shminfo.shmid < 0) {
+            perror("shmget");
+            XDestroyImage(shm_image);
+            if (attempt < MAX_ATTACH_ATTEMPTS) std::this_thread::sleep_for(std::chrono::milliseconds(RETRY_BACKOFF_MS));
+            continue;
+        }
 
-    shminfo.shmaddr = (char*)shmat(shminfo.shmid, nullptr, 0);
-    if (shminfo.shmaddr == (char*)-1) {
-      perror("shmat");
-      shmctl(shminfo.shmid, IPC_RMID, 0);
-      XDestroyImage(shm_image);
-      XCloseDisplay(display);
-      return;
+        shminfo.shmaddr = (char*)shmat(shminfo.shmid, nullptr, 0);
+        if (shminfo.shmaddr == (char*)-1) {
+            perror("shmat");
+            shmctl(shminfo.shmid, IPC_RMID, 0);
+            XDestroyImage(shm_image);
+            if (attempt < MAX_ATTACH_ATTEMPTS) std::this_thread::sleep_for(std::chrono::milliseconds(RETRY_BACKOFF_MS));
+            continue;
+        }
+
+        shminfo.readOnly = False;
+        shm_image->data = shminfo.shmaddr;
+        g_shm_attach_failed = false;
+        XErrorHandler old_handler = XSetErrorHandler(shm_attach_error_handler);
+        XShmAttach(display, &shminfo);
+        XSync(display, False);
+        XSetErrorHandler(old_handler);
+
+        if (g_shm_attach_failed) {
+            std::cerr << "Attempt " << attempt << "/" << MAX_ATTACH_ATTEMPTS << ": XShmAttach failed with an X server error." << std::endl;
+            shmdt(shminfo.shmaddr);
+            shmctl(shminfo.shmid, IPC_RMID, 0);
+            XDestroyImage(shm_image);
+            if (attempt < MAX_ATTACH_ATTEMPTS) {
+                std::this_thread::sleep_for(std::chrono::milliseconds(RETRY_BACKOFF_MS));
+            }
+            continue;
+        }
+        
+        shm_setup_complete = true;
+        break;
     }
-    shminfo.readOnly = False;
-    shm_image->data = shminfo.shmaddr;
 
-    if (!XShmAttach(display, &shminfo)) {
-      std::cerr << "Error: XShmAttach failed" << std::endl;
-      shmdt(shminfo.shmaddr);
-      shmctl(shminfo.shmid, IPC_RMID, 0);
-      XDestroyImage(shm_image);
-      XCloseDisplay(display);
-      return;
+    if (!shm_setup_complete) {
+        std::cerr << "ERROR: Failed to set up XShm after " << MAX_ATTACH_ATTEMPTS << " attempts. Exiting capture thread." << std::endl;
+        if (display) {
+            XCloseDisplay(display);
+            display = nullptr;
+        }
+        return;
     }
+
     std::cout << "XShm setup complete for " << local_capture_width_actual
               << "x" << local_capture_height_actual << "." << std::endl;
 

{pixelflux-1.4.3 → pixelflux-1.4.5/pixelflux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pixelflux
-Version: 1.4.3
+Version: 1.4.5
 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
@@ -32,6 +32,7 @@ This module relies on a native C++ extension that is compiled during installatio
     sudo apt-get update && \
     sudo apt-get install -y \
       g++ \
+      libavcodec-dev \
       libdrm-dev \
       libjpeg-turbo8-dev \
       libva-dev \

{pixelflux-1.4.3 → pixelflux-1.4.5}/setup.py

@@ -48,7 +48,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
     long_description = fh.read()
 setup(
     name="pixelflux",
-    version="1.4.3",
+    version="1.4.5",
     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.",