ok-script 0.0.84__tar.gz → 0.0.96__tar.gz

{ok-script-0.0.84 → ok-script-0.0.96}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ok-script
-Version: 0.0.84
+Version: 0.0.96
 Summary: Automation with Computer Vision for Python
 Home-page: https://github.com/ok-oldking/ok-script
 Author: ok-oldking

{ok-script-0.0.84 → ok-script-0.0.96}/ok/OK.py

@@ -37,6 +37,9 @@ class OK:
         config['debug'] = config.get("debug", False)
         self.debug = config['debug']
         try:
+            if self.debug:
+                import win32api
+                win32api.SetConsoleCtrlHandler(self.console_handler, True)
             self.config = config
             self.init_device_manager()
             from ok.gui.debug.Screenshot import Screenshot
@@ -59,6 +62,7 @@ class OK:
             if self.config.get("use_gui"):
                 if not self.init_error:
                     self.app.show_main_window()
+                logger.debug('start app.exec()')
                 self.app.exec()
             else:
                 self.task_executor.start()
@@ -97,7 +101,7 @@ class OK:
         if template_matching is not None:
             coco_feature_json = self.config.get('template_matching').get('coco_feature_json')
             from ok.feature.FeatureSet import FeatureSet
-            self.feature_set = FeatureSet(coco_feature_json,
+            self.feature_set = FeatureSet(self.debug, coco_feature_json,
                                           default_horizontal_variance=template_matching.get(
                                               'default_horizontal_variance', 0),
                                           default_vertical_variance=template_matching.get('default_vertical_variance',
@@ -110,7 +114,7 @@ class OK:
                                           trigger_tasks=self.config.get('trigger_tasks', []),
                                           scenes=self.config['scenes'],
                                           feature_set=self.feature_set,
-                                          config_folder=self.config.get("config_folder"))
+                                          config_folder=self.config.get("config_folder"), debug=self.debug)
 
         ok.gui.executor = self.task_executor
 
@@ -135,6 +139,26 @@ class OK:
         while not self.exit_event.is_set():
             time.sleep(1)
 
+    def console_handler(self, event):
+        import win32con
+        if event == win32con.CTRL_C_EVENT:
+            logger.info("CTRL+C event dump threads")
+            from ok.capture.windows.dump import dump_threads
+            dump_threads()
+            self.quit()
+        elif event == win32con.CTRL_CLOSE_EVENT:
+            logger.info("Close event quit")
+            self.quit()
+        elif event == win32con.CTRL_LOGOFF_EVENT:
+            logger.info("Logoff event quit")
+            self.quit()
+        elif event == win32con.CTRL_SHUTDOWN_EVENT:
+            logger.info("Shutdown event quit")
+            self.quit()
+        else:  # Perform clean-up tasks here
+            print("Performing clean-up...")
+        return True
+
     def quit(self):
         logger.debug('quit app')
         self.exit_event.set()

{ok-script-0.0.84 → ok-script-0.0.96}/ok/capture/BaseCaptureMethod.py

@@ -24,20 +24,10 @@ class BaseCaptureMethod:
 
     @property
     def width(self):
-        if self._size[0] == 0:
-            try:
-                self.get_frame()
-            except Exception as e:
-                logger.error('width get frame error', e)
         return self._size[0]
 
     @property
     def height(self):
-        if self._size[1] == 0:
-            try:
-                self.get_frame()
-            except Exception as e:
-                logger.error('height get frame error', e)
         return self._size[1]
 
     def get_frame(self) -> np.ndarray | None:

{ok-script-0.0.84 → ok-script-0.0.96}/ok/capture/HwndWindow.py

@@ -29,7 +29,6 @@ class HwndWindow:
     left_cut = 0
     ext_left_bounds = 0  # for BitBlt
     ext_top_bounds = 0  # for BitBlt
-    window_change_listeners = []
     frame_aspect_ratio = 0
     hwnd = None
     frame_width = 0
@@ -42,31 +41,23 @@ class HwndWindow:
     real_x_offset = 0
     real_y_offset = 0
 
-    def __init__(self, exit_event, title, exe_name=None, frame_width=0, frame_height=0):
+    def __init__(self, exit_event, title, exe_name=None, frame_width=0, frame_height=0, player_id=-1):
         super().__init__()
         self.app_exit_event = exit_event
         self.exe_name = exe_name
         self.title = title
         self.stop_event = threading.Event()
         self.visible = False
+        self.player_id = player_id
         self.update_window(title, exe_name, frame_width, frame_height)
         self.thread = threading.Thread(target=self.update_window_size, name="update_window_size")
         self.thread.start()
 
-    def update_title_and_exe(self, title, exe):
-        self.title = title
-        self.exe_name = exe
-        self.hwnd = None
-        self.visible = False
-        self.exists = False
-        self.width = 0
-        self.height = 0
-        self.do_update_window_size()
-
     def stop(self):
         self.stop_event.set()
 
-    def update_window(self, title, exe_name, frame_width, frame_height):
+    def update_window(self, title, exe_name, frame_width, frame_height, player_id=-1):
+        self.player_id = player_id
         self.title = title
         self.exe_name = exe_name
         self.update_frame_size(frame_width, frame_height)
@@ -100,7 +91,7 @@ class HwndWindow:
                 name, self.hwnd, self.exe_full_path, self.real_x_offset, self.real_y_offset, self.real_width, self.real_height = find_hwnd(
                     self.title,
                     self.exe_name,
-                    self.frame_width, self.frame_height)
+                    self.frame_width, self.frame_height, player_id=self.player_id)
                 self.exists = self.hwnd is not None
             if self.hwnd is not None:
                 self.exists = win32gui.IsWindow(self.hwnd)
@@ -168,6 +159,8 @@ def find_hwnd(title, exe_name, frame_width, frame_height, player_id=-1):
                 elif not re.search(title, text):
                     return True
             name, full_path, cmdline = get_exe_by_hwnd(hwnd)
+            if not name:
+                return True
             x, y, border, title_height, width, height, scaling, ext_left_bounds, ext_top_bounds = get_window_bounds(
                 hwnd)
             ret = (hwnd, full_path, width, height, x, y, text)
@@ -184,10 +177,9 @@ def find_hwnd(title, exe_name, frame_width, frame_height, player_id=-1):
 
     win32gui.EnumWindows(callback, None)
     if len(results) > 0:
-        biggest = results[0]
+        biggest = None
         for result in results:
-            from ok.capture.windows.BitBltCaptureMethod import bit_blt_test_hwnd
-            if (biggest is None or (result[2] * result[3]) > biggest[2] * biggest[3]) and bit_blt_test_hwnd(result[0]):
+            if biggest is None or (result[2] * result[3]) > biggest[2] * biggest[3]:
                 biggest = result
         x_offset = 0
         y_offset = 0
@@ -210,6 +202,12 @@ def get_player_id_from_cmdline(cmdline):
         if i != 0:
             if cmdline[i].isdigit():
                 return int(cmdline[i])
+    for i in range(len(cmdline)):
+        if i != 0:
+            value = re.search(r'index=(\d+)', cmdline[i])
+            # Return the value if it exists, otherwise return None
+            if value is not None:
+                return int(value.group(1))
     return 0
 
 
@@ -248,8 +246,11 @@ def get_exe_by_hwnd(hwnd):
     _, pid = win32process.GetWindowThreadProcessId(hwnd)
 
     # Get the process name and executable path
-    process = psutil.Process(pid)
-    return process.name(), process.exe(), process.cmdline()
+    if pid > 0:
+        process = psutil.Process(pid)
+        return process.name(), process.exe(), process.cmdline()
+    else:
+        return None, None, None
 
 
 if __name__ == '__main__':

{ok-script-0.0.84 → ok-script-0.0.96}/ok/capture/adb/DeviceManager.py

@@ -1,4 +1,4 @@
-from adbutils import AdbTimeout
+from adbutils import AdbTimeout, AdbError
 
 from ok.alas.platform_windows import get_emulator_exe
 from ok.capture.HwndWindow import HwndWindow, find_hwnd
@@ -53,27 +53,25 @@ class DeviceManager:
             logger.debug(f'connect adb')
         return self._adb
 
-    def adb_connect(self, addr):
+    def adb_connect(self, addr, try_connect=True):
         try:
-            for info in self.adb.list():
+            for device in self.adb.device_list():
                 if self.exit_event.is_set():
                     logger.error(f"adb_connect exit_event is set")
                     return None
-                if info.serial == addr:
-                    if info.state == 'offline':
+                if device.serial == addr:
+                    if device.info['state'] == 'offline':
                         logger.debug(f'adb_connect offline disconnect first {addr}')
                         self.adb.disconnect(addr)
                     else:
                         logger.debug(f'adb_connect already connected {addr}')
-                        return self.adb.device(addr)
-            self.adb.connect(addr, timeout=5)
-            device = self.adb.device(addr)
-            logger.debug(f'adb_connect {addr} device {device}')
-            return device
+                        return device
+            if try_connect:
+                self.adb.connect(addr, timeout=3)
+                logger.debug(f'adb_connect {addr}')
+                return self.adb_connect(addr, try_connect=False)
         except AdbTimeout as e:
             logger.error(f"adb connect error try kill server {addr}", e)
-            # self.adb.server_kill()
-            # self._adb = None
         except Exception as e:
             logger.error(f"adb connect error return none {addr}", e)
 
@@ -101,9 +99,7 @@ class DeviceManager:
 
     def do_refresh(self, current=False):
         self.update_pc_device()
-
         self.refresh_emulators(current)
-
         self.refresh_phones(current)
 
         if self.exit_event.is_set():
@@ -120,8 +116,8 @@ class DeviceManager:
             if imei is not None:
                 preferred = self.get_preferred_device()
                 if current and preferred is not None and preferred['imei'] != imei:
-                    logger.debug(f"refresh current only skip others {preferred['imei']} != imei")
-                    break
+                    logger.debug(f"refresh current only skip others {preferred['imei']} != {imei}")
+                    continue
                 found = False
                 for device in self.device_dict.values():
                     if device.get('adb_imei') == imei:
@@ -131,7 +127,7 @@ class DeviceManager:
                     width, height = self.get_resolution(adb_device)
                     logger.debug(f'refresh_phones found an phone {adb_device}')
                     phone_device = {"address": adb_device.serial, "device": "adb", "connected": True, "imei": imei,
-                                    "nick": adb_device.prop.model or imei,
+                                    "nick": adb_device.prop.model or imei, "player_id": -1,
                                     "resolution": f'{width}x{height}'}
                     self.device_dict[imei] = phone_device
 
@@ -147,13 +143,13 @@ class DeviceManager:
                 logger.debug(f"refresh current only skip others {preferred['imei']} != {emulator.name}")
                 break
             adb_device = self.adb_connect(emulator.serial)
-            width, height = self.get_resolution(adb_device)
+            width, height = self.get_resolution(adb_device) if adb_device is not None else 0, 0
             name, hwnd, full_path, x, y, width, height = find_hwnd(None,
                                                                    emulator.path, width, height, emulator.player_id)
             connected = adb_device is not None and name is not None
             emulator_device = {"address": emulator.serial, "device": "adb",
                                "full_path": emulator.path, "connected": connected,
-                               "imei": emulator.name,
+                               "imei": emulator.name, "player_id": emulator.player_id,
                                "nick": name or emulator.name, "emulator": emulator}
             if adb_device is not None:
                 emulator_device["resolution"] = f"{width}x{height}"
@@ -236,11 +232,11 @@ class DeviceManager:
         preferred = self.get_preferred_device()
         return preferred.get('hwnd')
 
-    def ensure_hwnd(self, title, exe, frame_width=0, frame_height=0):
+    def ensure_hwnd(self, title, exe, frame_width=0, frame_height=0, player_id=-1):
         if self.hwnd is None:
-            self.hwnd = HwndWindow(self.exit_event, title, exe, frame_width, frame_height)
+            self.hwnd = HwndWindow(self.exit_event, title, exe, frame_width, frame_height, player_id)
         else:
-            self.hwnd.update_window(title, exe, frame_width, frame_height)
+            self.hwnd.update_window(title, exe, frame_width, frame_height, player_id)
 
     def use_windows_capture(self, override_config=None, require_bg=False, use_bit_blt_only=False):
         if not override_config:
@@ -267,12 +263,12 @@ class DeviceManager:
             self.use_windows_capture()
             if not isinstance(self.interaction, Win32Interaction):
                 self.interaction = Win32Interaction(self.capture_method)
-            preferred['connected'] = self.capture_method.connected()
+            preferred['connected'] = self.capture_method is not None and self.capture_method.connected()
         else:
             width, height = self.get_resolution()
             if self.config.get('capture') == "windows":
-                self.ensure_hwnd(None, preferred.get('full_path'), width, height)
-                self.use_windows_capture({'can_bit_blt': True}, require_bg=True, use_bit_blt_only=True)
+                self.ensure_hwnd(None, preferred.get('full_path'), width, height, preferred['player_id'])
+                self.use_windows_capture({'can_bit_blt': True}, require_bg=True, use_bit_blt_only=False)
             else:
                 if not isinstance(self.capture_method, ADBCaptureMethod):
                     logger.debug(f'use adb capture')
@@ -281,7 +277,7 @@ class DeviceManager:
                     self.capture_method = ADBCaptureMethod(self, self.exit_event, width=width,
                                                            height=height)
                 if self.debug and preferred.get('full_path'):
-                    self.ensure_hwnd(None, preferred.get('full_path'), width, height)
+                    self.ensure_hwnd(None, preferred.get('full_path'), width, height, preferred['player_id'])
                 elif self.hwnd is not None:
                     self.hwnd.stop()
                     self.hwnd = None
@@ -341,12 +337,13 @@ class DeviceManager:
         if device is not None:
             try:
                 return device.shell(*args, **kwargs)
+            except AdbError as e:
+                logger.debug(f'shell adb error {args} {e}')
             except Exception as e:
                 addr = self.get_preferred_device()['address']
                 self.refresh_emulators()
                 new_addr = self.get_preferred_device()['address']
                 logger.error(f"shell_wrapper error occurred, try refresh_emulators {addr} {new_addr}", e)
-                return None
         else:
             raise Exception('Device is none')
 

ok-script-0.0.96/ok/capture/adb/WindowsCaptureFactory.py

@@ -0,0 +1,42 @@
+from ok.logging.Logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def update_capture_method(config, capture_method, hwnd, require_bg=False, use_bit_blt_only=False):
+    try:
+        if config.get('can_bit_blt'):
+            logger.debug(
+                f"try BitBlt method {config} {hwnd} current_type:{type(capture_method)}")
+            from ok.capture.windows.BitBltCaptureMethod import BitBltCaptureMethod
+            target_method = BitBltCaptureMethod
+            capture_method = get_capture(capture_method, target_method, hwnd)
+            if capture_method.test_is_not_pure_color():
+                return capture_method
+            else:
+                logger.info("test_is_not_pure_color failed, can't use BitBlt")
+        if use_bit_blt_only:
+            return None
+        from ok.capture.windows.WindowsGraphicsCaptureMethod import windows_graphics_available
+        if windows_graphics_available():
+            from ok.capture.windows.WindowsGraphicsCaptureMethod import WindowsGraphicsCaptureMethod
+            target_method = WindowsGraphicsCaptureMethod
+            capture_method = get_capture(capture_method, target_method, hwnd)
+            return capture_method
+
+        if not require_bg:
+            from ok.capture.windows.DesktopDuplicationCaptureMethod import DesktopDuplicationCaptureMethod
+            target_method = DesktopDuplicationCaptureMethod
+            capture_method = get_capture(capture_method, target_method, hwnd)
+            return capture_method
+    except Exception as e:
+        logger.error(f'update_capture_method exception, return None: ', e)
+
+
+def get_capture(capture_method, target_method, hwnd):
+    if not isinstance(capture_method, target_method):
+        if capture_method is not None:
+            capture_method.close()
+        capture_method = target_method(hwnd)
+    capture_method.hwnd_window = hwnd
+    return capture_method

{ok-script-0.0.84 → ok-script-0.0.96}/ok/capture/windows/BitBltCaptureMethod.py

@@ -10,7 +10,7 @@ from typing_extensions import override
 
 from ok.capture.windows.BaseWindowsCaptureMethod import BaseWindowsCaptureMethod
 from ok.capture.windows.utils import try_delete_dc, BGRA_CHANNEL_COUNT
-from ok.capture.windows.window import get_window_bounds
+from ok.color.Color import is_close_to_pure_color
 from ok.logging.Logger import get_logger
 
 # This is an undocumented nFlag value for PrintWindow
@@ -60,12 +60,17 @@ class BitBltCaptureMethod(BaseWindowsCaptureMethod):
             return False
         return True
 
-
-def bit_blt_test_hwnd(hwnd):
-    x, y, border, title_height, width, height, scaling, ext_left_bounds, ext_top_bounds = get_window_bounds(
-        hwnd)
-    frame = bit_blt_capture_frame(hwnd, border, title_height, width, height, ext_left_bounds, ext_top_bounds)
-    return frame is not None
+    def test_is_not_pure_color(self):
+        frame = self.do_get_frame()
+        if frame is None:
+            logger.error(f'Failed to test_is_not_pure_color frame is None {self.hwnd_window}')
+            return False
+        else:
+            if is_close_to_pure_color(frame):
+                logger.error(f'Failed to test_is_not_pure_color failed {self.hwnd_window}')
+                return False
+            else:
+                return True
 
 
 def bit_blt_capture_frame(hwnd, border, title_height, width, height, ext_left_bounds, ext_top_bounds,

{ok-script-0.0.84 → ok-script-0.0.96}/ok/capture/windows/WindowsGraphicsCaptureMethod.py

@@ -23,7 +23,7 @@ logger = get_logger(__name__)
 class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
     name = "Windows Graphics Capture"
     description = "fast, most compatible, capped at 60fps"
-    last_frame = None
+    last_dx_frame = None
     last_frame_time = 0
     frame_pool = None
     item = None
@@ -38,67 +38,78 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
 
     def frame_arrived_callback(self, x, y):
         try:
-            frame = self.frame_pool.TryGetNextFrame()
+            self.last_frame_time = time.time()
+            next_frame = self.frame_pool.TryGetNextFrame()
+            if next_frame is not None:
+                self.last_dx_frame = next_frame
+            else:
+                logger.warning('frame_arrived_callback TryGetNextFrame returned None')
         except Exception as e:
             logger.error(f"TryGetNextFrame error {e}")
             self.close()
             return
+
+    def convert_dx_frame(self):
+        frame = self.last_dx_frame
+        self.last_dx_frame = None
         if not frame:
+            logger.warning('convert_dx_frame self.last_dx_frame is none')
+            return None
+
+        need_reset_framepool = False
+        if frame.ContentSize.Width != self.last_size.Width or frame.ContentSize.Height != self.last_size.Height:
+            need_reset_framepool = True
+            self.last_size = frame.ContentSize
+
+        if need_reset_framepool:
+            logger.info('need_reset_framepool')
+            self.reset_framepool(frame.ContentSize)
             return
-        self.last_frame_time = time.time()
-        img = None
-        with frame:
-            need_reset_framepool = False
-            need_reset_device = False
-            if frame.ContentSize.Width != self.last_size.Width or frame.ContentSize.Height != self.last_size.Height:
-                need_reset_framepool = True
-                self.last_size = frame.ContentSize
+        need_reset_device = False
 
-            if need_reset_framepool:
-                self.reset_framepool(frame.ContentSize)
-                return
-            tex = None
+        tex = None
 
-            cputex = None
-            try:
-                from ok.rotypes.Windows.Graphics.DirectX.Direct3D11 import IDirect3DDxgiInterfaceAccess
-                from ok.rotypes.roapi import GetActivationFactory
-                tex = frame.Surface.astype(IDirect3DDxgiInterfaceAccess).GetInterface(
-                    d3d11.ID3D11Texture2D.GUID).astype(d3d11.ID3D11Texture2D)
-                desc = tex.GetDesc()
-                desc2 = d3d11.D3D11_TEXTURE2D_DESC()
-                desc2.Width = desc.Width
-                desc2.Height = desc.Height
-                desc2.MipLevels = desc.MipLevels
-                desc2.ArraySize = desc.ArraySize
-                desc2.Format = desc.Format
-                desc2.SampleDesc = desc.SampleDesc
-                desc2.Usage = d3d11.D3D11_USAGE_STAGING
-                desc2.CPUAccessFlags = d3d11.D3D11_CPU_ACCESS_READ
-                desc2.BindFlags = 0
-                desc2.MiscFlags = 0
-                cputex = self.dxdevice.CreateTexture2D(ctypes.byref(desc2), None)
-                self.immediatedc.CopyResource(cputex, tex)
-                mapinfo = self.immediatedc.Map(cputex, 0, d3d11.D3D11_MAP_READ, 0)
-                img = np.ctypeslib.as_array(ctypes.cast(mapinfo.pData, PBYTE),
-                                            (desc.Height, mapinfo.RowPitch // 4, 4))[
-                      :, :desc.Width].copy()
-                self.immediatedc.Unmap(cputex, 0)
-            except OSError as e:
-                if e.winerror == d3d11.DXGI_ERROR_DEVICE_REMOVED or e.winerror == d3d11.DXGI_ERROR_DEVICE_RESET:
-                    need_reset_framepool = True
-                    need_reset_device = True
-                else:
-                    raise
-            finally:
-                if tex is not None:
-                    tex.Release()
-                if cputex is not None:
-                    cputex.Release()
-            if need_reset_framepool:
-                self.reset_framepool(frame.ContentSize, need_reset_device)
-                return self.get_frame()
-        self.last_frame = img
+        cputex = None
+        try:
+            from ok.rotypes.Windows.Graphics.DirectX.Direct3D11 import IDirect3DDxgiInterfaceAccess
+            from ok.rotypes.roapi import GetActivationFactory
+            tex = frame.Surface.astype(IDirect3DDxgiInterfaceAccess).GetInterface(
+                d3d11.ID3D11Texture2D.GUID).astype(d3d11.ID3D11Texture2D)
+            desc = tex.GetDesc()
+            desc2 = d3d11.D3D11_TEXTURE2D_DESC()
+            desc2.Width = desc.Width
+            desc2.Height = desc.Height
+            desc2.MipLevels = desc.MipLevels
+            desc2.ArraySize = desc.ArraySize
+            desc2.Format = desc.Format
+            desc2.SampleDesc = desc.SampleDesc
+            desc2.Usage = d3d11.D3D11_USAGE_STAGING
+            desc2.CPUAccessFlags = d3d11.D3D11_CPU_ACCESS_READ
+            desc2.BindFlags = 0
+            desc2.MiscFlags = 0
+            cputex = self.dxdevice.CreateTexture2D(ctypes.byref(desc2), None)
+            self.immediatedc.CopyResource(cputex, tex)
+            mapinfo = self.immediatedc.Map(cputex, 0, d3d11.D3D11_MAP_READ, 0)
+            img = np.ctypeslib.as_array(ctypes.cast(mapinfo.pData, PBYTE),
+                                        (desc.Height, mapinfo.RowPitch // 4, 4))[
+                  :, :desc.Width].copy()
+            self.immediatedc.Unmap(cputex, 0)
+            return img
+        except OSError as e:
+            if e.winerror == d3d11.DXGI_ERROR_DEVICE_REMOVED or e.winerror == d3d11.DXGI_ERROR_DEVICE_RESET:
+                need_reset_framepool = True
+                need_reset_device = True
+                logger.error('convert_dx_frame win error', e)
+            else:
+                raise e
+        finally:
+            if tex is not None:
+                tex.Release()
+            if cputex is not None:
+                cputex.Release()
+        if need_reset_framepool:
+            self.reset_framepool(frame.ContentSize, need_reset_device)
+            return self.get_frame()
 
     @property
     def hwnd_window(self):
@@ -139,7 +150,7 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
                 self.evtoken = item.add_Closed(delegate)
                 self.frame_pool = Direct3D11CaptureFramePool.CreateFreeThreaded(self.rtdevice,
                                                                                 DirectXPixelFormat.B8G8R8A8UIntNormalized,
-                                                                                1, item.Size)
+                                                                                2, item.Size)
                 self.session = self.frame_pool.CreateCaptureSession(item)
                 pool = self.frame_pool
                 pool.add_FrameArrived(
@@ -193,10 +204,10 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
     @override
     def do_get_frame(self):
         if self.start_or_stop():
-            frame = self.last_frame
-            self.last_frame = None
+            frame = self.convert_dx_frame()
+            if frame is None:
+                return
             latency = time.time() - self.last_frame_time
-            self.last_frame_time = time.time()
 
             frame = self.crop_image(frame)
 
@@ -205,18 +216,20 @@ class WindowsGraphicsCaptureMethod(BaseWindowsCaptureMethod):
                 if new_width <= 0 or new_width <= 0:
                     logger.warning(f"get_frame size <=0 {new_width}x{new_height}")
                     frame = None
-            if latency > 1:
+            if latency > 2:
                 logger.warning(f"latency too large return None frame: {latency}")
                 return None
             else:
+                # logger.debug(f'frame latency: {latency}')
                 return frame
 
     def reset_framepool(self, size, reset_device=False):
+        logger.info(f'reset_framepool')
         from ok.rotypes.Windows.Graphics.DirectX import DirectXPixelFormat
         if reset_device:
             self.create_device()
         self.frame_pool.Recreate(self.rtdevice,
-                                 DirectXPixelFormat.B8G8R8A8UIntNormalized, 1, size)
+                                 DirectXPixelFormat.B8G8R8A8UIntNormalized, 2, size)
 
     def crop_image(self, frame):
         if frame is not None: