Don't send is_old_image boolean from get_frame

Author: Avasam

src/AutoSplit.py

@@ -252,7 +252,7 @@ def __update_live_image_details(self, capture: MatLike | None, called_from_timer
         if called_from_timer:
             if self.is_running or self.start_image:
                 return
-            capture, _ = self.capture_method.get_frame()
+            capture = self.capture_method.get_frame()
 
         # Update title from target window or Capture Device name
         capture_region_window_label = (
@@ -310,7 +310,7 @@ def __start_image_function(self):
         self.start_image_status_value_label.setText("ready")
         self.__update_split_image(self.start_image)
 
-        capture, _ = self.__get_capture_for_comparison()
+        capture = self.__get_capture_for_comparison()
         start_image_threshold = self.start_image.get_similarity_threshold(self)
         start_image_similarity = self.start_image.compare_with_capture(self, capture)
 
@@ -390,7 +390,7 @@ def __take_screenshot(self):
             screenshot_index += 1
 
         # Grab screenshot of capture region
-        capture, _ = self.capture_method.get_frame()
+        capture = self.capture_method.get_frame()
         if not is_valid_image(capture):
             error_messages.region()
             return
@@ -415,14 +415,16 @@ def __check_fps(self):
 
         # run X iterations of screenshotting capture region + comparison + displaying.
         t0 = time()
+        last_capture: MatLike | None = None
         for image in images:
             count = 0
             while count < CHECK_FPS_ITERATIONS:
-                capture, is_old_image = self.__get_capture_for_comparison()
-                _ = image.compare_with_capture(self, capture)
-                # TODO: If is_old_image=true is always returned, this becomes an infinite loop
-                if not is_old_image:
+                new_capture = self.__get_capture_for_comparison()
+                _ = image.compare_with_capture(self, new_capture)
+                # TODO: If an old image is always returned, this becomes an infinite loop
+                if new_capture is not last_capture:
                     count += 1
+                last_capture = new_capture
 
         # calculate FPS
         t1 = time()
@@ -641,7 +643,7 @@ def __similarity_threshold_loop(self, number_of_split_images: int, dummy_splits_
 
         start = time()
         while True:
-            capture, _ = self.__get_capture_for_comparison()
+            capture = self.__get_capture_for_comparison()
 
             if self.__reset_if_should(capture):
                 return True
@@ -710,7 +712,7 @@ def __pause_loop(self, stop_time: float, message: str):
         pause_split_image_number = self.split_image_number
         while True:
             # Calculate similarity for Reset Image
-            if self.__reset_if_should(self.__get_capture_for_comparison()[0]):
+            if self.__reset_if_should(self.__get_capture_for_comparison()):
                 return True
 
             time_delta = time() - start_time
@@ -785,7 +787,7 @@ def gui_changes_on_reset(self, safe_to_reload_start_image: bool = False):
 
     def __get_capture_for_comparison(self):
         """Grab capture region and resize for comparison."""
-        capture, is_old_image = self.capture_method.get_frame()
+        capture = self.capture_method.get_frame()
 
         # This most likely means we lost capture
         # (ie the captured window was closed, crashed, lost capture device, etc.)
@@ -800,10 +802,10 @@ def __get_capture_for_comparison(self):
                 self.live_image.setText(message)
                 recovered = self.capture_method.recover_window(self.settings_dict["captured_window_title"])
                 if recovered:
-                    capture, _ = self.capture_method.get_frame()
+                    capture = self.capture_method.get_frame()
 
         self.__update_live_image_details(capture)
-        return capture, is_old_image
+        return capture
 
     def __reset_if_should(self, capture: MatLike | None):
         """Checks if we should reset, resets if it's the case, and returns the result."""

src/capture_method/BitBltCaptureMethod.py

@@ -36,13 +36,13 @@ class BitBltCaptureMethod(CaptureMethodBase):
     _render_full_content = False
 
     @override
-    def get_frame(self) -> tuple[MatLike | None, bool]:
+    def get_frame(self) -> MatLike | None:
         selection = self._autosplit_ref.settings_dict["capture_region"]
         hwnd = self._autosplit_ref.hwnd
         image: MatLike | None = None
 
         if not self.check_selected_region_exists():
-            return None, False
+            return None
 
         # If the window closes while it's being manipulated, it could cause a crash
         try:
@@ -70,7 +70,7 @@ def get_frame(self) -> tuple[MatLike | None, bool]:
             image = np.frombuffer(bitmap.GetBitmapBits(True), dtype=np.uint8)
         except (win32ui.error, pywintypes.error):
             # Invalid handle or the window was closed while it was being manipulated
-            return None, False
+            return None
 
         if is_blank(image):
             image = None
@@ -82,7 +82,7 @@ def get_frame(self) -> tuple[MatLike | None, bool]:
         try_delete_dc(compatible_dc)
         win32gui.ReleaseDC(hwnd, window_dc)
         win32gui.DeleteObject(bitmap.GetHandle())
-        return image, False
+        return image
 
     @override
     def recover_window(self, captured_window_title: str):

src/capture_method/CaptureMethodBase.py

@@ -27,14 +27,14 @@ def close(self):
         # Some capture methods don't need an initialization process
         pass
 
-    def get_frame(self) -> tuple[MatLike | None, bool]:  # noqa: PLR6301
+    def get_frame(self) -> MatLike | None:  # noqa: PLR6301
         """
         Captures an image of the region for a window matching the given
         parameters of the bounding box.
 
         @return: The image of the region in the window in BGRA format
         """
-        return None, False
+        return None
 
     def recover_window(self, captured_window_title: str) -> bool:  # noqa: PLR6301
         return False

src/capture_method/DesktopDuplicationCaptureMethod.py

@@ -39,7 +39,7 @@ def get_frame(self):
         hwnd = self._autosplit_ref.hwnd
         hmonitor = ctypes.windll.user32.MonitorFromWindow(hwnd, win32con.MONITOR_DEFAULTTONEAREST)
         if not hmonitor or not self.check_selected_region_exists():
-            return None, False
+            return None
 
         left_bounds, top_bounds, *_ = get_window_bounds(hwnd)
         self.desktop_duplication.display = next(
@@ -59,5 +59,5 @@ def get_frame(self):
             self.desktop_duplication.screenshot((left, top, right, bottom)),
         )
         if screenshot is None:
-            return None, False
-        return cv2.cvtColor(screenshot, cv2.COLOR_RGB2BGRA), False
+            return None
+        return cv2.cvtColor(screenshot, cv2.COLOR_RGB2BGRA)

src/capture_method/VideoCaptureDeviceCaptureMethod.py

@@ -43,6 +43,7 @@ class VideoCaptureDeviceCaptureMethod(CaptureMethodBase):
     capture_thread: Thread | None = None
     stop_thread: Event
     last_captured_frame: MatLike | None = None
+    last_converted_frame: MatLike | None = None
     is_old_image = False
 
     def __read_loop(self):
@@ -121,13 +122,16 @@ def close(self):
     @override
     def get_frame(self):
         if not self.check_selected_region_exists():
-            return None, False
+            return None
 
         image = self.last_captured_frame
         is_old_image = self.is_old_image
         self.is_old_image = True
         if not is_valid_image(image):
-            return None, is_old_image
+            return None
+
+        if is_old_image:
+            return self.last_converted_frame
 
         selection = self._autosplit_ref.settings_dict["capture_region"]
         # Ensure we can't go OOB of the image
@@ -137,7 +141,8 @@ def get_frame(self):
             y: y + selection["height"],
             x: x + selection["width"],
         ]
-        return cv2.cvtColor(image, cv2.COLOR_BGR2BGRA), is_old_image
+        self.last_converted_frame = cv2.cvtColor(image, cv2.COLOR_BGR2BGRA)
+        return self.last_converted_frame
 
     @override
     def check_selected_region_exists(self):

src/capture_method/WindowsGraphicsCaptureMethod.py

@@ -38,7 +38,7 @@ class WindowsGraphicsCaptureMethod(CaptureMethodBase):
     frame_pool: Direct3D11CaptureFramePool | None = None
     session: GraphicsCaptureSession | None = None
     """This is stored to prevent session from being garbage collected"""
-    last_captured_frame: MatLike | None = None
+    last_converted_frame: MatLike | None = None
 
     def __init__(self, autosplit: "AutoSplit"):
         super().__init__(autosplit)
@@ -82,25 +82,25 @@ def close(self):
             self.session = None
 
     @override
-    def get_frame(self) -> tuple[MatLike | None, bool]:
+    def get_frame(self) -> MatLike | None:
         selection = self._autosplit_ref.settings_dict["capture_region"]
         # We still need to check the hwnd because WGC will return a blank black image
         if not (
             self.check_selected_region_exists()
             # Only needed for the type-checker
             and self.frame_pool
         ):
-            return None, False
+            return None
 
         try:
             frame = self.frame_pool.try_get_next_frame()
         # Frame pool is closed
         except OSError:
-            return None, False
+            return None
 
         # We were too fast and the next frame wasn't ready yet
         if not frame:
-            return self.last_captured_frame, True
+            return self.last_converted_frame
 
         async def coroutine():
             return await SoftwareBitmap.create_copy_from_surface_async(frame.surface)
@@ -110,13 +110,13 @@ async def coroutine():
         except SystemError as exception:
             # HACK: can happen when closing the GraphicsCapturePicker
             if str(exception).endswith("returned a result with an error set"):
-                return self.last_captured_frame, True
+                return self.last_converted_frame
             raise
 
         if not software_bitmap:
             # HACK: Can happen when starting the region selector
             # TODO: Validate if this is still true
-            return self.last_captured_frame, True
+            return self.last_converted_frame
             # raise ValueError("Unable to convert Direct3D11CaptureFrame to SoftwareBitmap.")
         bitmap_buffer = software_bitmap.lock_buffer(BitmapBufferAccessMode.READ_WRITE)
         if not bitmap_buffer:
@@ -128,8 +128,8 @@ async def coroutine():
             selection["y"]: selection["y"] + selection["height"],
             selection["x"]: selection["x"] + selection["width"],
         ]
-        self.last_captured_frame = image
-        return image, False
+        self.last_converted_frame = image
+        return image
 
     @override
     def recover_window(self, captured_window_title: str):

src/region_selection.py

@@ -201,7 +201,7 @@ def align_region(autosplit: "AutoSplit"):
 
     # Obtaining the capture of a region which contains the
     # subregion being searched for to align the image.
-    capture, _ = autosplit.capture_method.get_frame()
+    capture = autosplit.capture_method.get_frame()
 
     if not is_valid_image(capture):
         error_messages.region()