GameSentenceMiner 2.8.26__py3-none-any.whl → 2.8.27__py3-none-any.whl

GameSentenceMiner/owocr/owocr/run.py

@@ -1,10 +1,3 @@
-try:
-    from .secret import *
-except ImportError:
-    pass
-from .config import Config
-from .screen_coordinate_picker import get_screen_selection
-
 try:
     import win32gui
     import win32ui
@@ -22,48 +15,117 @@ try:
     import platform
     from AppKit import NSData, NSImage, NSBitmapImageRep, NSDeviceRGBColorSpace, NSGraphicsContext, NSZeroPoint, NSZeroRect, NSCompositingOperationCopy
     from Quartz import CGWindowListCreateImageFromArray, kCGWindowImageBoundsIgnoreFraming, CGRectMake, CGRectNull, CGMainDisplayID, CGWindowListCopyWindowInfo, \
-                       CGWindowListCreateDescriptionFromArray, kCGWindowListOptionOnScreenOnly, kCGWindowListExcludeDesktopElements, kCGWindowName, kCGNullWindowID, \
-                       CGImageGetWidth, CGImageGetHeight, CGDataProviderCopyData, CGImageGetDataProvider, CGImageGetBytesPerRow
+        CGWindowListCreateDescriptionFromArray, kCGWindowListOptionOnScreenOnly, kCGWindowListExcludeDesktopElements, kCGWindowName, kCGNullWindowID, \
+        CGImageGetWidth, CGImageGetHeight, CGDataProviderCopyData, CGImageGetDataProvider, CGImageGetBytesPerRow
     from ScreenCaptureKit import SCContentFilter, SCScreenshotManager, SCShareableContent, SCStreamConfiguration, SCCaptureResolutionBest
 except ImportError:
     pass
 
-
+import signal
 import threading
+from pathlib import Path
+import queue
+import io
+import re
+import logging
+import inspect
+
 import pyperclipfix
 import mss
 import asyncio
 import websockets
 import socketserver
 import queue
-import time
 
 from datetime import datetime
-from PIL import Image, ImageDraw
-from PIL import UnidentifiedImageError
+from PIL import Image, ImageDraw, UnidentifiedImageError
+from loguru import logger
 from pynput import keyboard
 from desktop_notifier import DesktopNotifierSync
 import psutil
 
 import inspect
 from .ocr import *
+try:
+    from .secret import *
+except ImportError:
+    pass
+from .config import Config
+from .screen_coordinate_picker import get_screen_selection
+from ...configuration import get_temporary_directory
 
 
 config = None
 
 
-class WindowsClipboardThread(threading.Thread):
+class ClipboardThread(threading.Thread):
     def __init__(self):
         super().__init__(daemon=True)
+        self.ignore_flag = config.get_general('ignore_flag')
+        self.delay_secs = config.get_general('delay_secs')
         self.last_update = time.time()
 
+    def are_images_identical(self, img1, img2):
+        if None in (img1, img2):
+            return img1 == img2
+
+        img1 = np.array(img1)
+        img2 = np.array(img2)
+
+        return (img1.shape == img2.shape) and (img1 == img2).all()
+
+    def normalize_macos_clipboard(self, img):
+        ns_data = NSData.dataWithBytes_length_(img, len(img))
+        ns_image = NSImage.alloc().initWithData_(ns_data)
+
+        new_image = NSBitmapImageRep.alloc().initWithBitmapDataPlanes_pixelsWide_pixelsHigh_bitsPerSample_samplesPerPixel_hasAlpha_isPlanar_colorSpaceName_bytesPerRow_bitsPerPixel_(
+            None,  # Set to None to create a new bitmap
+            int(ns_image.size().width),
+            int(ns_image.size().height),
+            8,  # Bits per sample
+            4,  # Samples per pixel (R, G, B, A)
+            True,  # Has alpha
+            False,  # Is not planar
+            NSDeviceRGBColorSpace,
+            0,  # Automatically compute bytes per row
+            32  # Bits per pixel (8 bits per sample * 4 samples per pixel)
+        )
+
+        context = NSGraphicsContext.graphicsContextWithBitmapImageRep_(new_image)
+        NSGraphicsContext.setCurrentContext_(context)
+
+        ns_image.drawAtPoint_fromRect_operation_fraction_(
+            NSZeroPoint,
+            NSZeroRect,
+            NSCompositingOperationCopy,
+            1.0
+        )
+
+        return bytes(new_image.TIFFRepresentation())
+
     def process_message(self, hwnd: int, msg: int, wparam: int, lparam: int):
         WM_CLIPBOARDUPDATE = 0x031D
         timestamp = time.time()
         if msg == WM_CLIPBOARDUPDATE and timestamp - self.last_update > 1 and not paused:
-            if win32clipboard.IsClipboardFormatAvailable(win32con.CF_BITMAP):
-                clipboard_event.set()
-                self.last_update = timestamp
+            self.last_update = timestamp
+            while True:
+                try:
+                    win32clipboard.OpenClipboard()
+                    break
+                except pywintypes.error:
+                    pass
+                time.sleep(0.1)
+            try:
+                if win32clipboard.IsClipboardFormatAvailable(win32con.CF_BITMAP) and win32clipboard.IsClipboardFormatAvailable(win32clipboard.CF_DIB):
+                    clipboard_text = ''
+                    if win32clipboard.IsClipboardFormatAvailable(win32clipboard.CF_UNICODETEXT):
+                        clipboard_text = win32clipboard.GetClipboardData(win32clipboard.CF_UNICODETEXT)
+                    if self.ignore_flag or clipboard_text != '*ocr_ignore*':
+                        img = win32clipboard.GetClipboardData(win32clipboard.CF_DIB)
+                        image_queue.put((img, False))
+                win32clipboard.CloseClipboard()
+            except pywintypes.error:
+                pass
         return 0
 
     def create_window(self):
@@ -76,10 +138,93 @@ class WindowsClipboardThread(threading.Thread):
         return win32gui.CreateWindow(class_atom, className, 0, 0, 0, 0, 0, 0, 0, wc.hInstance, None)
 
     def run(self):
-        hwnd = self.create_window()
-        self.thread_id = win32api.GetCurrentThreadId()
-        ctypes.windll.user32.AddClipboardFormatListener(hwnd)
-        win32gui.PumpMessages()
+        if sys.platform == 'win32':
+            hwnd = self.create_window()
+            self.thread_id = win32api.GetCurrentThreadId()
+            ctypes.windll.user32.AddClipboardFormatListener(hwnd)
+            win32gui.PumpMessages()
+        else:
+            is_macos = sys.platform == 'darwin'
+            if is_macos:
+                from AppKit import NSPasteboard, NSPasteboardTypeTIFF, NSPasteboardTypeString
+                pasteboard = NSPasteboard.generalPasteboard()
+                count = pasteboard.changeCount()
+            else:
+                from PIL import ImageGrab
+            process_clipboard = False
+            img = None
+
+            while not terminated:
+                if paused:
+                    sleep_time = 0.5
+                    process_clipboard = False
+                else:
+                    sleep_time = self.delay_secs
+                    if is_macos:
+                        with objc.autorelease_pool():
+                            old_count = count
+                            count = pasteboard.changeCount()
+                            if process_clipboard and count != old_count:
+                                while len(pasteboard.types()) == 0:
+                                    time.sleep(0.1)
+                                if NSPasteboardTypeTIFF in pasteboard.types():
+                                    clipboard_text = ''
+                                    if NSPasteboardTypeString in pasteboard.types():
+                                        clipboard_text = pasteboard.stringForType_(NSPasteboardTypeString)
+                                    if self.ignore_flag or clipboard_text != '*ocr_ignore*':
+                                        img = self.normalize_macos_clipboard(pasteboard.dataForType_(NSPasteboardTypeTIFF))
+                                        image_queue.put((img, False))
+                    else:
+                        old_img = img
+                        try:
+                            img = ImageGrab.grabclipboard()
+                        except Exception:
+                            pass
+                        else:
+                            if (process_clipboard and isinstance(img, Image.Image) and \
+                                    (self.ignore_flag or pyperclipfix.paste() != '*ocr_ignore*') and \
+                                    (not self.are_images_identical(img, old_img))):
+                                image_queue.put((img, False))
+
+                    process_clipboard = True
+
+                if not terminated:
+                    time.sleep(sleep_time)
+
+
+class DirectoryWatcher(threading.Thread):
+    def __init__(self, path):
+        super().__init__(daemon=True)
+        self.path = path
+        self.delay_secs = config.get_general('delay_secs')
+        self.last_update = time.time()
+        self.allowed_extensions = ('.png', '.jpg', '.jpeg', '.bmp', '.gif', '.webp')
+
+    def get_path_key(self, path):
+        return path, path.lstat().st_mtime
+
+    def run(self):
+        old_paths = set()
+        for path in self.path.iterdir():
+            if path.suffix.lower() in self.allowed_extensions:
+                old_paths.add(get_path_key(path))
+
+        while not terminated:
+            if paused:
+                sleep_time = 0.5
+            else:
+                sleep_time = self.delay_secs
+                for path in self.path.iterdir():
+                    if path.suffix.lower() in self.allowed_extensions:
+                        path_key = self.get_path_key(path)
+                        if path_key not in old_paths:
+                            old_paths.add(path_key)
+
+                            if not paused:
+                                image_queue.put((path, False))
+
+            if not terminated:
+                time.sleep(sleep_time)
 
 
 class WebsocketServerThread(threading.Thread):
@@ -104,7 +249,7 @@ class WebsocketServerThread(threading.Thread):
         try:
             async for message in websocket:
                 if self.read and not paused:
-                    websocket_queue.put(message)
+                    image_queue.put((message, False))
                     try:
                         await websocket.send('True')
                     except websockets.exceptions.ConnectionClosedOK:
@@ -153,145 +298,12 @@ class RequestHandler(socketserver.BaseRequestHandler):
             pass
 
         if not paused:
-            unixsocket_queue.put(img)
+            image_queue.put((img, False))
             conn.sendall(b'True')
         else:
             conn.sendall(b'False')
 
 
-class MacOSWindowTracker(threading.Thread):
-    def __init__(self, window_id):
-        super().__init__(daemon=True)
-        self.stop = False
-        self.window_id = window_id
-        self.window_active = False
-
-    def run(self):
-        found = True
-        while found and not self.stop:
-            found = False
-            is_active = False
-            with objc.autorelease_pool():
-                window_list = CGWindowListCopyWindowInfo(kCGWindowListOptionOnScreenOnly, kCGNullWindowID)
-                for i, window in enumerate(window_list):
-                    if found and window.get(kCGWindowName, '') == 'Fullscreen Backdrop':
-                        is_active = True
-                        break
-                    if self.window_id == window['kCGWindowNumber']:
-                        found = True
-                        if i == 0 or window_list[i-1].get(kCGWindowName, '') in ('Dock', 'Color Enforcer Window'):
-                            is_active = True
-                            break
-                if not found:
-                    window_list = CGWindowListCreateDescriptionFromArray([self.window_id])
-                    if len(window_list) > 0:
-                        found = True
-            if found and self.window_active != is_active:
-                on_window_activated(is_active)
-                self.window_active = is_active
-            time.sleep(0.2)
-        if not found:
-            on_window_closed(False)
-
-
-class WindowsWindowTracker(threading.Thread):
-    def __init__(self, window_handle, only_active):
-        super().__init__(daemon=True)
-        self.stop = False
-        self.window_handle = window_handle
-        self.only_active = only_active
-        self.window_active = False
-        self.window_minimized = False
-
-    def run(self):
-        found = True
-        while not self.stop:
-            found = win32gui.IsWindow(self.window_handle)
-            if not found:
-                break
-            if self.only_active:
-                is_active = self.window_handle == win32gui.GetForegroundWindow()
-                if self.window_active != is_active:
-                    on_window_activated(is_active)
-                    self.window_active = is_active
-            else:
-                is_minimized = win32gui.IsIconic(self.window_handle)
-                if self.window_minimized != is_minimized:
-                    on_window_minimized(is_minimized)
-                    self.window_minimized = is_minimized
-            time.sleep(0.2)
-        if not found:
-            on_window_closed(False)
-
-
-def capture_macos_window_screenshot(window_id):
-    def shareable_content_completion_handler(shareable_content, error):
-        if error:
-            screencapturekit_queue.put(None)
-            return
-
-        target_window = None
-        for window in shareable_content.windows():
-            if window.windowID() == window_id:
-                target_window = window
-                break
-
-        if not target_window:
-            screencapturekit_queue.put(None)
-            return
-
-        with objc.autorelease_pool():
-            content_filter = SCContentFilter.alloc().initWithDesktopIndependentWindow_(target_window)
-
-            frame = content_filter.contentRect()
-            scale = content_filter.pointPixelScale()
-            width = frame.size.width * scale
-            height = frame.size.height * scale
-            configuration = SCStreamConfiguration.alloc().init()
-            configuration.setSourceRect_(CGRectMake(0, 0, frame.size.width, frame.size.height))
-            configuration.setWidth_(width)
-            configuration.setHeight_(height)
-            configuration.setShowsCursor_(False)
-            configuration.setCaptureResolution_(SCCaptureResolutionBest)
-            configuration.setIgnoreGlobalClipSingleWindow_(True)
-
-            SCScreenshotManager.captureImageWithFilter_configuration_completionHandler_(
-                content_filter, configuration, capture_image_completion_handler
-            )
-
-    def capture_image_completion_handler(image, error):
-        if error:
-            screencapturekit_queue.put(None)
-            return
-
-        screencapturekit_queue.put(image)
-
-    SCShareableContent.getShareableContentWithCompletionHandler_(
-        shareable_content_completion_handler
-    )
-
-
-def get_windows_window_handle(window_title):
-    def callback(hwnd, window_title_part):
-        window_title = win32gui.GetWindowText(hwnd)
-        if window_title_part in window_title:
-            handles.append((hwnd, window_title))
-        return True
-
-    handle = win32gui.FindWindow(None, window_title)
-    if handle:
-        return (handle, window_title)
-
-    handles = []
-    win32gui.EnumWindows(callback, window_title)
-    for handle in handles:
-        _, pid = win32process.GetWindowThreadProcessId(handle[0])
-        if psutil.Process(pid).name().lower() not in ('cmd.exe', 'powershell.exe', 'windowsterminal.exe'):
-            return handle
-
-    return (None, None)
-
-
 class TextFiltering:
     accurate_filtering = False
 
@@ -315,6 +327,7 @@ class TextFiltering:
         try:
             from transformers import pipeline, AutoTokenizer
             import torch
+            logging.getLogger('transformers').setLevel(logging.ERROR)
 
             model_ckpt = 'papluca/xlm-roberta-base-language-detection'
             tokenizer = AutoTokenizer.from_pretrained(
@@ -386,19 +399,330 @@ class TextFiltering:
                         break
         else:
             for block in new_blocks:
-                if self.classify(block)[0] == lang:
+                if lang not in ["ja", "zh"] or self.classify(block)[0] == lang:
                     final_blocks.append(block)
 
         text = '\n'.join(final_blocks)
         return text, orig_text_filtered
 
 
+class ScreenshotClass:
+    def __init__(self, screen_capture_area, screen_capture_window, screen_capture_exclusions, screen_capture_only_active_windows):
+        self.macos_window_tracker_instance = None
+        self.windows_window_tracker_instance = None
+        self.screencapture_window_active = True
+        self.screencapture_window_visible = True
+        self.custom_left = None
+        self.screen_capture_exclusions = screen_capture_exclusions
+        self.screen_capture_window = screen_capture_window
+        if screen_capture_area == '':
+            self.screencapture_mode = 0
+        elif screen_capture_area.startswith('screen_'):
+            parts = screen_capture_area.split('_')
+            if len(parts) != 2 or not parts[1].isdigit():
+                raise ValueError('Invalid screen_capture_area')
+            screen_capture_monitor = int(parts[1])
+            self.screencapture_mode = 1
+        elif len(screen_capture_area.split(',')) == 4:
+            self.screencapture_mode = 3
+        else:
+            self.screencapture_mode = 2
+            self.screen_capture_window = screen_capture_area
+        if self.screen_capture_window:
+            self.screencapture_mode = 2
+
+        if self.screencapture_mode != 2:
+            self.sct = mss.mss()
+
+            if self.screencapture_mode == 1:
+                mon = self.sct.monitors
+                if len(mon) <= screen_capture_monitor:
+                    raise ValueError('Invalid monitor number in screen_capture_area')
+                coord_left = mon[screen_capture_monitor]['left']
+                coord_top = mon[screen_capture_monitor]['top']
+                coord_width = mon[screen_capture_monitor]['width']
+                coord_height = mon[screen_capture_monitor]['height']
+            elif self.screencapture_mode == 3:
+                coord_left, coord_top, coord_width, coord_height = [int(c.strip()) for c in screen_capture_area.split(',')]
+            else:
+                logger.opt(ansi=True).info('Launching screen coordinate picker')
+                screen_selection = get_screen_selection()
+                if not screen_selection:
+                    raise ValueError('Picker window was closed or an error occurred')
+                screen_capture_monitor = screen_selection['monitor']
+                x, y, coord_width, coord_height = screen_selection['coordinates']
+                if coord_width > 0 and coord_height > 0:
+                    coord_top = screen_capture_monitor['top'] + y
+                    coord_left = screen_capture_monitor['left'] + x
+                else:
+                    logger.opt(ansi=True).info('Selection is empty, selecting whole screen')
+                    coord_left = screen_capture_monitor['left']
+                    coord_top = screen_capture_monitor['top']
+                    coord_width = screen_capture_monitor['width']
+                    coord_height = screen_capture_monitor['height']
+
+            self.sct_params = {'top': coord_top, 'left': coord_left, 'width': coord_width, 'height': coord_height}
+            logger.opt(ansi=True).info(f'Selected coordinates: {coord_left},{coord_top},{coord_width},{coord_height}')
+        if len(screen_capture_area.split(',')) == 4:
+            self.custom_left, self.custom_top, self.custom_width, self.custom_height = [int(c.strip()) for c in
+                                                                    screen_capture_area.split(',')]
+
+
+        if self.screencapture_mode == 2 or self.screen_capture_window:
+            self.screen_capture_only_active_windows = screen_capture_only_active_windows
+            area_invalid_error = '"screen_capture_area" must be empty, "screen_N" where N is a screen number starting from 1, a valid set of coordinates, or a valid window name'
+            if sys.platform == 'darwin':
+                if config.get_general('screen_capture_old_macos_api') or int(platform.mac_ver()[0].split('.')[0]) < 14:
+                    self.old_macos_screenshot_api = True
+                else:
+                    self.old_macos_screenshot_api = False
+                    self.screencapturekit_queue = queue.Queue()
+                    CGMainDisplayID()
+                window_list = CGWindowListCopyWindowInfo(kCGWindowListExcludeDesktopElements, kCGNullWindowID)
+                window_titles = []
+                window_ids = []
+                window_index = None
+                for i, window in enumerate(window_list):
+                    window_title = window.get(kCGWindowName, '')
+                    if psutil.Process(window['kCGWindowOwnerPID']).name() not in ('Terminal', 'iTerm2'):
+                        window_titles.append(window_title)
+                        window_ids.append(window['kCGWindowNumber'])
+
+                if screen_capture_window in window_titles:
+                    window_index = window_titles.index(screen_capture_window)
+                else:
+                    for t in window_titles:
+                        if screen_capture_window in t:
+                            window_index = window_titles.index(t)
+                            break
+
+                if not window_index:
+                    raise ValueError(area_invalid_error)
+
+                self.window_id = window_ids[window_index]
+                window_title = window_titles[window_index]
+
+                if self.screen_capture_only_active_windows:
+                    self.macos_window_tracker_instance = threading.Thread(target=self.macos_window_tracker)
+                    self.macos_window_tracker_instance.start()
+                logger.opt(ansi=True).info(f'Selected window: {window_title}')
+            elif sys.platform == 'win32':
+                self.window_handle, window_title = self.get_windows_window_handle(screen_capture_window)
+
+                if not self.window_handle:
+                    raise ValueError(area_invalid_error)
+
+                ctypes.windll.shcore.SetProcessDpiAwareness(1)
+
+                self.windows_window_tracker_instance = threading.Thread(target=self.windows_window_tracker)
+                self.windows_window_tracker_instance.start()
+                logger.opt(ansi=True).info(f'Selected window: {window_title}')
+            else:
+                raise ValueError('Window capture is only currently supported on Windows and macOS')
+
+    def __del__(self):
+        if self.macos_window_tracker_instance:
+            self.macos_window_tracker_instance.join()
+        elif self.windows_window_tracker_instance:
+            self.windows_window_tracker_instance.join()
+
+    def get_windows_window_handle(self, window_title):
+        def callback(hwnd, window_title_part):
+            window_title = win32gui.GetWindowText(hwnd)
+            if window_title_part in window_title:
+                handles.append((hwnd, window_title))
+            return True
+
+        handle = win32gui.FindWindow(None, window_title)
+        if handle:
+            return (handle, window_title)
+
+        handles = []
+        win32gui.EnumWindows(callback, window_title)
+        for handle in handles:
+            _, pid = win32process.GetWindowThreadProcessId(handle[0])
+            if psutil.Process(pid).name().lower() not in ('cmd.exe', 'powershell.exe', 'windowsterminal.exe'):
+                return handle
+
+        return (None, None)
+
+    def windows_window_tracker(self):
+        found = True
+        while not terminated:
+            found = win32gui.IsWindow(self.window_handle)
+            if not found:
+                break
+            if self.screen_capture_only_active_windows:
+                self.screencapture_window_active = self.window_handle == win32gui.GetForegroundWindow()
+            else:
+                self.screencapture_window_visible = not win32gui.IsIconic(self.window_handle)
+            time.sleep(0.2)
+        if not found:
+            on_window_closed(False)
+
+    def capture_macos_window_screenshot(self, window_id):
+        def shareable_content_completion_handler(shareable_content, error):
+            if error:
+                self.screencapturekit_queue.put(None)
+                return
+
+            target_window = None
+            for window in shareable_content.windows():
+                if window.windowID() == window_id:
+                    target_window = window
+                    break
+
+            if not target_window:
+                self.screencapturekit_queue.put(None)
+                return
+
+            with objc.autorelease_pool():
+                content_filter = SCContentFilter.alloc().initWithDesktopIndependentWindow_(target_window)
+
+                frame = content_filter.contentRect()
+                scale = content_filter.pointPixelScale()
+                width = frame.size.width * scale
+                height = frame.size.height * scale
+                configuration = SCStreamConfiguration.alloc().init()
+                configuration.setSourceRect_(CGRectMake(0, 0, frame.size.width, frame.size.height))
+                configuration.setWidth_(width)
+                configuration.setHeight_(height)
+                configuration.setShowsCursor_(False)
+                configuration.setCaptureResolution_(SCCaptureResolutionBest)
+                configuration.setIgnoreGlobalClipSingleWindow_(True)
+
+                SCScreenshotManager.captureImageWithFilter_configuration_completionHandler_(
+                    content_filter, configuration, capture_image_completion_handler
+                )
+
+        def capture_image_completion_handler(image, error):
+            if error:
+                self.screencapturekit_queue.put(None)
+                return
+
+            self.screencapturekit_queue.put(image)
+
+        SCShareableContent.getShareableContentWithCompletionHandler_(
+            shareable_content_completion_handler
+        )
+
+    def macos_window_tracker(self):
+        found = True
+        while found and not terminated:
+            found = False
+            is_active = False
+            with objc.autorelease_pool():
+                window_list = CGWindowListCopyWindowInfo(kCGWindowListOptionOnScreenOnly, kCGNullWindowID)
+                for i, window in enumerate(window_list):
+                    if found and window.get(kCGWindowName, '') == 'Fullscreen Backdrop':
+                        is_active = True
+                        break
+                    if self.window_id == window['kCGWindowNumber']:
+                        found = True
+                        if i == 0 or window_list[i-1].get(kCGWindowName, '') in ('Dock', 'Color Enforcer Window'):
+                            is_active = True
+                            break
+                if not found:
+                    window_list = CGWindowListCreateDescriptionFromArray([self.window_id])
+                    if len(window_list) > 0:
+                        found = True
+            if found:
+                self.screencapture_window_active = is_active
+            time.sleep(0.2)
+        if not found:
+            on_window_closed(False)
+
+    def __call__(self):
+        if self.screencapture_mode == 2 or self.screen_capture_window:
+            if sys.platform == 'darwin':
+                with objc.autorelease_pool():
+                    if self.old_macos_screenshot_api:
+                        cg_image = CGWindowListCreateImageFromArray(CGRectNull, [self.window_id], kCGWindowImageBoundsIgnoreFraming)
+                    else:
+                        self.capture_macos_window_screenshot(self.window_id)
+                        try:
+                            cg_image = self.screencapturekit_queue.get(timeout=0.5)
+                        except queue.Empty:
+                            cg_image = None
+                    if not cg_image:
+                        return 0
+                    width = CGImageGetWidth(cg_image)
+                    height = CGImageGetHeight(cg_image)
+                    raw_data = CGDataProviderCopyData(CGImageGetDataProvider(cg_image))
+                    bpr = CGImageGetBytesPerRow(cg_image)
+                img = Image.frombuffer('RGBA', (width, height), raw_data, 'raw', 'BGRA', bpr, 1)
+            else:
+                try:
+                    coord_left, coord_top, right, bottom = win32gui.GetWindowRect(self.window_handle)
+                    coord_width = right - coord_left
+                    coord_height = bottom - coord_top
+
+                    hwnd_dc = win32gui.GetWindowDC(self.window_handle)
+                    mfc_dc = win32ui.CreateDCFromHandle(hwnd_dc)
+                    save_dc = mfc_dc.CreateCompatibleDC()
+
+                    save_bitmap = win32ui.CreateBitmap()
+                    save_bitmap.CreateCompatibleBitmap(mfc_dc, coord_width, coord_height)
+                    save_dc.SelectObject(save_bitmap)
+
+                    result = ctypes.windll.user32.PrintWindow(self.window_handle, save_dc.GetSafeHdc(), 2)
+
+                    bmpinfo = save_bitmap.GetInfo()
+                    bmpstr = save_bitmap.GetBitmapBits(True)
+                except pywintypes.error:
+                    return 0
+                img = Image.frombuffer('RGB', (bmpinfo['bmWidth'], bmpinfo['bmHeight']), bmpstr, 'raw', 'BGRX', 0, 1)
+                try:
+                    win32gui.DeleteObject(save_bitmap.GetHandle())
+                except:
+                    pass
+                try:
+                    save_dc.DeleteDC()
+                except:
+                    pass
+                try:
+                    mfc_dc.DeleteDC()
+                except:
+                    pass
+                try:
+                    win32gui.ReleaseDC(self.window_handle, hwnd_dc)
+                except:
+                    pass
+        else:
+            sct_img = self.sct.grab(self.sct_params)
+            img = Image.frombytes('RGB', sct_img.size, sct_img.bgra, 'raw', 'BGRX')
+
+        # import random  # Ensure this is imported at the top of the file if not already
+        # rand_int = random.randint(1, 10)  # Executes only once out of 10 times
+
+        # if rand_int == 1:  # Executes only once out of 10 times
+        #     img.show()
+
+        if self.screen_capture_exclusions:
+            img = img.convert("RGBA")
+            draw = ImageDraw.Draw(img)
+            for exclusion in self.screen_capture_exclusions:
+                left, top, width, height = exclusion
+                draw.rectangle((left, top, left + width, top + height), fill=(0, 0, 0, 0))
+
+        if self.custom_left:
+            img = img.crop((self.custom_left, self.custom_top, self.custom_left + self.custom_width, self.custom_top + self.custom_height))
+
+        # if rand_int == 1:
+        #     img.show()
+
+        return img
+
+
 class AutopauseTimer:
     def __init__(self, timeout):
         self.stop_event = threading.Event()
         self.timeout = timeout
         self.timer_thread = None
 
+    def __del__(self):
+        self.stop()
+
     def start(self):
         self.stop()
         self.stop_event.clear()
@@ -411,28 +735,22 @@ class AutopauseTimer:
             self.timer_thread.join()
 
     def _countdown(self):
-        seconds = self.timeout if self.timeout else 1
-        while seconds > 0 and not self.stop_event.is_set():
+        seconds = self.timeout
+        while seconds > 0 and not self.stop_event.is_set() and not terminated:
             time.sleep(1)
             seconds -= 1
         if not self.stop_event.is_set():
             self.stop_event.set()
-            if not paused:
+            if not (paused or terminated):
                 pause_handler(True)
 
 
 def pause_handler(is_combo=True):
     global paused
-    global just_unpaused
-    if paused:
-        message = 'Unpaused!'
-        just_unpaused = True
-    else:
-        message = 'Paused!'
+    message = 'Unpaused!' if paused else 'Paused!'
 
     if auto_pause_handler:
         auto_pause_handler.stop()
-
     if is_combo:
         notifier.send(title='owocr', message=message)
     logger.info(message)
@@ -450,7 +768,6 @@ def engine_change_handler(user_input='s', is_combo=True):
             engine_index += 1
     elif user_input.lower() != '' and user_input.lower() in engine_keys:
         engine_index = engine_keys.index(user_input.lower())
-
     if engine_index != old_engine_index:
         new_engine_name = engine_instances[engine_index].readable_name
         if is_combo:
@@ -497,15 +814,6 @@ def user_input_thread_run():
             termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
 
 
-def on_screenshot_combo():
-    if not paused:
-        screenshot_event.set()
-
-def on_screenshot_bus():
-    if not paused:
-        screenshot_event.set()
-
-
 def signal_handler(sig, frame):
     global terminated
     logger.info('Terminated!')
@@ -519,9 +827,10 @@ def on_window_closed(alive):
         terminated = True
 
 
-def on_window_activated(active):
-    global screencapture_window_active
-    screencapture_window_active = active
+def on_screenshot_combo():
+    if not paused:
+        img = take_screenshot()
+        image_queue.put((img, True))
 
 
 def on_window_minimized(minimized):
@@ -529,47 +838,7 @@ def on_window_minimized(minimized):
     screencapture_window_visible = not minimized
 
 
-def normalize_macos_clipboard(img):
-    ns_data = NSData.dataWithBytes_length_(img, len(img))
-    ns_image = NSImage.alloc().initWithData_(ns_data)
-
-    new_image = NSBitmapImageRep.alloc().initWithBitmapDataPlanes_pixelsWide_pixelsHigh_bitsPerSample_samplesPerPixel_hasAlpha_isPlanar_colorSpaceName_bytesPerRow_bitsPerPixel_(
-        None,  # Set to None to create a new bitmap
-        int(ns_image.size().width),
-        int(ns_image.size().height),
-        8,  # Bits per sample
-        4,  # Samples per pixel (R, G, B, A)
-        True,  # Has alpha
-        False,  # Is not planar
-        NSDeviceRGBColorSpace,
-        0,  # Automatically compute bytes per row
-        32  # Bits per pixel (8 bits per sample * 4 samples per pixel)
-    )
-
-    context = NSGraphicsContext.graphicsContextWithBitmapImageRep_(new_image)
-    NSGraphicsContext.setCurrentContext_(context)
-
-    ns_image.drawAtPoint_fromRect_operation_fraction_(
-        NSZeroPoint,
-        NSZeroRect,
-        NSCompositingOperationCopy,
-        1.0
-    )
-
-    return new_image.TIFFRepresentation()
-
-
-def are_images_identical(img1, img2):
-    if None in (img1, img2):
-        return img1 == img2
-
-    img1 = np.array(img1)
-    img2 = np.array(img2)
-
-    return (img1.shape == img2.shape) and (img1 == img2).all()
-
-
-def process_and_write_results(img_or_path, write_to, notifications, last_result, filtering, engine=None, rectangle=None, start_time=None):
+def process_and_write_results(img_or_path, write_to=None, last_result=None, filtering=None, notify=None, engine=None, rectangle=None, ocr_start_time=None):
     global engine_index
     if auto_pause_handler:
         auto_pause_handler.stop()
@@ -583,9 +852,9 @@ def process_and_write_results(img_or_path, write_to, notifications, last_result,
     else:
         engine_instance = engine_instances[engine_index]
 
-    t0 = time.time()
+    start_time = time.time()
     res, text = engine_instance(img_or_path)
-    t1 = time.time()
+    end_time = time.time()
 
     orig_text = []
     engine_color = config.get_general('engine_color')
@@ -594,13 +863,16 @@ def process_and_write_results(img_or_path, write_to, notifications, last_result,
     #
     # print(lang)
 
+    # print(last_result)
+    # print(engine_index)
+
     if res:
         if filtering:
             text, orig_text = filtering(text, last_result)
         if lang == "ja" or lang == "zh":
             text = post_process(text)
-        logger.opt(ansi=True).info(f'Text recognized in {t1 - t0:0.03f}s using <{engine_color}>{engine_instance.readable_name}</{engine_color}>: {text}')
-        if notifications:
+        logger.opt(ansi=True).info(f'Text recognized in {end_time - start_time:0.03f}s using <{engine_color}>{engine_instance.readable_name}</{engine_color}>: {text}')
+        if notify and config.get_general('notifications'):
             notifier.send(title='owocr', message='Text recognized: ' + text)
 
         if write_to == 'websocket':
@@ -608,7 +880,7 @@ def process_and_write_results(img_or_path, write_to, notifications, last_result,
         elif write_to == 'clipboard':
             pyperclipfix.copy(text)
         elif write_to == "callback":
-            txt_callback(text, orig_text, rectangle, start_time, img_or_path)
+            txt_callback(text, orig_text, rectangle, ocr_start_time, img_or_path)
         elif write_to:
             with Path(write_to).open('a', encoding='utf-8') as f:
                 f.write(text + '\n')
@@ -616,7 +888,7 @@ def process_and_write_results(img_or_path, write_to, notifications, last_result,
         if auto_pause_handler and not paused:
             auto_pause_handler.start()
     else:
-        logger.opt(ansi=True).info(f'<{engine_color}>{engine_instance.readable_name}</{engine_color}> reported an error after {t1 - t0:0.03f}s: {text}')
+        logger.opt(ansi=True).info(f'<{engine_color}>{engine_instance.readable_name}</{engine_color}> reported an error after {end_time - start_time:0.03f}s: {text}')
 
     # print(orig_text)
     # print(text)
@@ -743,7 +1015,7 @@ def run(read_from=None,
     for _, engine_class in sorted(inspect.getmembers(sys.modules[__name__],
                                                      lambda x: hasattr(x, '__module__') and x.__module__ and (
                                                              __package__ + '.ocr' in x.__module__ or __package__ + '.secret' in x.__module__) and inspect.isclass(
-                                                             x))):
+                                                         x))):
         if len(config_engines) == 0 or engine_class.name in config_engines:
             if config.get_engine(engine_class.name) == None:
                 engine_instance = engine_class()
@@ -767,6 +1039,8 @@ def run(read_from=None,
     global first_pressed
     global notifier
     global auto_pause_handler
+    global websocket_server_thread
+    global image_queue
     custom_left = None
     terminated = False
     paused = pause_at_startup
@@ -777,14 +1051,31 @@ def run(read_from=None,
     engine_color = config.get_general('engine_color')
     prefix_to_use = ""
     delay_secs = config.get_general('delay_secs')
+
+    non_path_inputs = ('screencapture', 'clipboard', 'websocket', 'unixsocket')
+    read_from_secondary = config.get_general('read_from_secondary')
+    read_from_path = None
+    read_from_readable = []
+    terminated = False
+    paused = config.get_general('pause_at_startup')
+    auto_pause = config.get_general('auto_pause')
+    clipboard_thread = None
+    websocket_server_thread = None
+    directory_watcher_thread = None
+    unix_socket_server = None
+    key_combo_listener = None
+    filtering = None
+    auto_pause_handler = None
+    engine_index = engine_keys.index(default_engine) if default_engine != '' else 0
+    engine_color = config.get_general('engine_color')
+    combo_pause = config.get_general('combo_pause')
+    combo_engine_switch = config.get_general('combo_engine_switch')
     screen_capture_on_combo = False
     notifier = DesktopNotifierSync()
+    image_queue = queue.Queue()
     key_combos = {}
 
-    if read_from != 'screencapture' and auto_pause != 0:
-        auto_pause_handler = AutopauseTimer(auto_pause)
-
-    if combo_pause:
+    if combo_pause != '':
         key_combos[combo_pause] = pause_handler
     if combo_engine_switch:
         if combo_pause:
@@ -792,190 +1083,51 @@ def run(read_from=None,
         else:
             raise ValueError('combo_pause must also be specified')
 
-    if read_from == 'websocket' or write_to == 'websocket':
-        global websocket_server_thread
-        websocket_server_thread = WebsocketServerThread(read_from == 'websocket')
+    if 'websocket' in (read_from, read_from_secondary) or write_to == 'websocket':
+        websocket_server_thread = WebsocketServerThread('websocket' in (read_from, read_from_secondary))
         websocket_server_thread.start()
 
     if write_to == "callback" and text_callback:
         global txt_callback
         txt_callback = text_callback
 
-    if read_from == 'websocket':
-        global websocket_queue
-        websocket_queue = queue.Queue()
-        read_from_readable = 'websocket'
-    elif read_from == 'unixsocket':
+    if 'screencapture' in (read_from, read_from_secondary):
+        global take_screenshot
+        screen_capture_combo = config.get_general('screen_capture_combo')
+        last_screenshot_time = 0
+        last_result = ([], engine_index)
+        if screen_capture_combo != '':
+            screen_capture_on_combo = True
+            key_combos[screen_capture_combo] = on_screenshot_combo
+        take_screenshot = ScreenshotClass(screen_capture_area, screen_capture_window, screen_capture_exclusions, screen_capture_only_active_windows)
+        filtering = TextFiltering()
+        read_from_readable.append('screen capture')
+    if 'websocket' in (read_from, read_from_secondary):
+        read_from_readable.append('websocket')
+    if 'unixsocket' in (read_from, read_from_secondary):
         if sys.platform == 'win32':
             raise ValueError('"unixsocket" is not currently supported on Windows')
-
-        global unixsocket_queue
-        unixsocket_queue = queue.Queue()
         socket_path = Path('/tmp/owocr.sock')
         if socket_path.exists():
             socket_path.unlink()
         unix_socket_server = socketserver.ThreadingUnixStreamServer(str(socket_path), RequestHandler)
         unix_socket_server_thread = threading.Thread(target=unix_socket_server.serve_forever, daemon=True)
         unix_socket_server_thread.start()
-        read_from_readable = 'unix socket'
-    elif read_from == 'clipboard':
-        macos_clipboard_polling = False
-        windows_clipboard_polling = False
-        img = None
-
-        if sys.platform == 'darwin':
-            from AppKit import NSPasteboard, NSPasteboardTypeTIFF, NSPasteboardTypeString
-            pasteboard = NSPasteboard.generalPasteboard()
-            count = pasteboard.changeCount()
-            macos_clipboard_polling = True
-        elif sys.platform == 'win32':
-            global clipboard_event
-            clipboard_event = threading.Event()
-            windows_clipboard_thread = WindowsClipboardThread()
-            windows_clipboard_thread.start()
-            windows_clipboard_polling = True
-        else:
-            from PIL import ImageGrab
-
-        read_from_readable = 'clipboard'
-    elif read_from == 'screencapture':
-        if screen_capture_combo:
-            screen_capture_on_combo = True
-            global screenshot_event
-            screenshot_event = threading.Event()
-            key_combos[screen_capture_combo] = on_screenshot_combo
-        if screen_capture_event_bus:
-            screen_capture_on_combo = True
-            screenshot_event = threading.Event()
-            screen_capture_event_bus = on_screenshot_bus
-        if type(screen_capture_area) == tuple:
-            screen_capture_area = ','.join(map(str, screen_capture_area))
-        global screencapture_window_active
-        global screencapture_window_visible
-        screencapture_mode = None
-        screencapture_window_active = True
-        screencapture_window_visible = True
-        last_result = ([], engine_index)
-        if screen_capture_area == '':
-            screencapture_mode = 0
-        elif screen_capture_area.startswith('screen_'):
-            parts = screen_capture_area.split('_')
-            if len(parts) != 2 or not parts[1].isdigit():
-                raise ValueError('Invalid screen_capture_area')
-            screen_capture_monitor = int(parts[1])
-            screencapture_mode = 1
-        elif len(screen_capture_area.split(',')) == 4:
-            screencapture_mode = 3
-        else:
-            screencapture_mode = 2
-            screen_capture_window = screen_capture_area
-        if screen_capture_window:
-            screencapture_mode = 2
-
-        if screencapture_mode != 2:
-            sct = mss.mss()
-
-            if screencapture_mode == 1:
-                mon = sct.monitors
-                if len(mon) <= screen_capture_monitor:
-                    raise ValueError('Invalid monitor number in screen_capture_area')
-                coord_left = mon[screen_capture_monitor]['left']
-                coord_top = mon[screen_capture_monitor]['top']
-                coord_width = mon[screen_capture_monitor]['width']
-                coord_height = mon[screen_capture_monitor]['height']
-            elif screencapture_mode == 3:
-                coord_left, coord_top, coord_width, coord_height = [int(c.strip()) for c in screen_capture_area.split(',')]
-            else:
-                logger.opt(ansi=True).info('Launching screen coordinate picker')
-                screen_selection = get_screen_selection()
-                if not screen_selection:
-                    raise ValueError('Picker window was closed or an error occurred')
-                screen_capture_monitor = screen_selection['monitor']
-                x, y, coord_width, coord_height = screen_selection['coordinates']
-                if coord_width > 0 and coord_height > 0:
-                    coord_top = screen_capture_monitor['top'] + y
-                    coord_left = screen_capture_monitor['left'] + x
-                else:
-                    logger.opt(ansi=True).info('Selection is empty, selecting whole screen')
-                    coord_left = screen_capture_monitor['left']
-                    coord_top = screen_capture_monitor['top']
-                    coord_width = screen_capture_monitor['width']
-                    coord_height = screen_capture_monitor['height']
-
-            sct_params = {'top': coord_top, 'left': coord_left, 'width': coord_width, 'height': coord_height}
-            logger.opt(ansi=True).info(f'Selected coordinates: {coord_left},{coord_top},{coord_width},{coord_height}')
-        if len(screen_capture_area.split(',')) == 4:
-            custom_left, custom_top, custom_width, custom_height = [int(c.strip()) for c in screen_capture_area.split(',')]
-        if screencapture_mode == 2 or screen_capture_window:
-            area_invalid_error = '"screen_capture_area" must be empty, "screen_N" where N is a screen number starting from 1, a valid set of coordinates, or a valid window name'
-            if sys.platform == 'darwin':
-                if int(platform.mac_ver()[0].split('.')[0]) < 14:
-                    old_macos_screenshot_api = True
-                else:
-                    global screencapturekit_queue
-                    screencapturekit_queue = queue.Queue()
-                    CGMainDisplayID()
-                    old_macos_screenshot_api = False
-
-                window_list = CGWindowListCopyWindowInfo(kCGWindowListExcludeDesktopElements, kCGNullWindowID)
-                window_titles = []
-                window_ids = []
-                window_index = None
-                for i, window in enumerate(window_list):
-                    window_title = window.get(kCGWindowName, '')
-                    if psutil.Process(window['kCGWindowOwnerPID']).name() not in ('Terminal', 'iTerm2'):
-                        window_titles.append(window_title)
-                        window_ids.append(window['kCGWindowNumber'])
-
-                if screen_capture_area in window_titles:
-                    window_index = window_titles.index(screen_capture_window)
-                else:
-                    for t in window_titles:
-                        if screen_capture_area in t:
-                            window_index = window_titles.index(t)
-                            break
-
-                if not window_index:
-                    raise ValueError(area_invalid_error)
-
-                window_id = window_ids[window_index]
-                window_title = window_titles[window_index]
-
-                if screen_capture_only_active_windows:
-                    screencapture_window_active = False
-                    macos_window_tracker = MacOSWindowTracker(window_id)
-                    macos_window_tracker.start()
-                logger.opt(ansi=True).info(f'Selected window: {window_title}')
-            elif sys.platform == 'win32':
-                window_handle, window_title = get_windows_window_handle(screen_capture_window)
-
-                if not window_handle:
-                    raise ValueError(area_invalid_error)
-
-                ctypes.windll.shcore.SetProcessDpiAwareness(1)
-
-                if screen_capture_only_active_windows:
-                    screencapture_window_active = False
-                windows_window_tracker = WindowsWindowTracker(window_handle, screen_capture_only_active_windows)
-                windows_window_tracker.start()
-                logger.opt(ansi=True).info(f'Selected window: {window_title}')
-            else:
-                raise ValueError('Window capture is only currently supported on Windows and macOS')
-
-        filtering = TextFiltering()
-        read_from_readable = 'screen capture'
-    else:
-        read_from = Path(read_from)
-        if not read_from.is_dir():
-            raise ValueError('read_from must be either "websocket", "unixsocket", "clipboard", "screencapture", or a path to a directory')
-
-        allowed_extensions = ('.png', '.jpg', '.jpeg', '.bmp', '.gif', '.webp')
-        old_paths = set()
-        for path in read_from.iterdir():
-            if path.suffix.lower() in allowed_extensions:
-                old_paths.add(get_path_key(path))
-
-        read_from_readable = f'directory {read_from}'
+        read_from_readable.append('unix socket')
+    if 'clipboard' in (read_from, read_from_secondary):
+        clipboard_thread = ClipboardThread()
+        clipboard_thread.start()
+        read_from_readable.append('clipboard')
+    if any(i and i not in non_path_inputs for i in (read_from, read_from_secondary)):
+        if all(i and i not in non_path_inputs for i in (read_from, read_from_secondary)):
+            raise ValueError("read_from and read_from_secondary can't both be directory paths")
+        delete_images = config.get_general('delete_images')
+        read_from_path = Path(read_from) if read_from not in non_path_inputs else Path(read_from_secondary)
+        if not read_from_path.is_dir():
+            raise ValueError('read_from and read_from_secondary must be either "websocket", "unixsocket", "clipboard", "screencapture", or a path to a directory')
+        directory_watcher_thread = DirectoryWatcher(read_from_path)
+        directory_watcher_thread.start()
+        read_from_readable.append(f'directory {read_from_path}')
 
     if len(key_combos) > 0:
         key_combo_listener = keyboard.GlobalHotKeys(key_combos)
@@ -988,214 +1140,66 @@ def run(read_from=None,
             raise ValueError('write_to must be either "websocket", "clipboard" or a path to a text file')
         write_to_readable = f'file {write_to}'
 
-    # signal.signal(signal.SIGINT, signal_handler)
+    process_queue = (any(i in ('clipboard', 'websocket', 'unixsocket') for i in (read_from, read_from_secondary)) or read_from_path or screen_capture_on_combo)
+    process_screenshots = 'screencapture' in (read_from, read_from_secondary) and not screen_capture_on_combo
+    if threading.current_thread() == threading.main_thread():
+        signal.signal(signal.SIGINT, signal_handler)
+    if (not process_screenshots) and auto_pause != 0:
+        auto_pause_handler = AutopauseTimer(auto_pause)
     user_input_thread = threading.Thread(target=user_input_thread_run, daemon=True)
     user_input_thread.start()
-    logger.opt(ansi=True).info(f"Reading from {read_from_readable}, writing to {write_to_readable} using <{engine_color}>{engine_instances[engine_index].readable_name}</{engine_color}>{' (paused)' if paused else ''}")
+    logger.opt(ansi=True).info(f"Reading from {' and '.join(read_from_readable)}, writing to {write_to_readable} using <{engine_color}>{engine_instances[engine_index].readable_name}</{engine_color}>{' (paused)' if paused else ''}")
 
-    while not terminated and not stop_running_flag:
-        start_time = datetime.now()
-        if read_from == 'websocket':
-            while True:
-                try:
-                    item = websocket_queue.get(timeout=delay_secs)
-                except queue.Empty:
-                    break
-                else:
-                    if not paused:
-                        img = Image.open(io.BytesIO(item))
-                        process_and_write_results(img, write_to, notifications, None, None, start_time=start_time)
-        elif read_from == 'unixsocket':
-            while True:
-                try:
-                    item = unixsocket_queue.get(timeout=delay_secs)
-                except queue.Empty:
-                    break
-                else:
-                    if not paused:
-                        img = Image.open(io.BytesIO(item))
-                        process_and_write_results(img, write_to, notifications, None, None, start_time=start_time)
-        elif read_from == 'clipboard':
-            process_clipboard = False
-            if windows_clipboard_polling:
-                if clipboard_event.wait(delay_secs):
-                    clipboard_event.clear()
-                    while True:
-                        try:
-                            win32clipboard.OpenClipboard()
-                            break
-                        except pywintypes.error:
-                            pass
-                        time.sleep(0.1)
-                    if win32clipboard.IsClipboardFormatAvailable(win32clipboard.CF_DIB):
-                        clipboard_text = ''
-                        if win32clipboard.IsClipboardFormatAvailable(win32clipboard.CF_UNICODETEXT):
-                            clipboard_text = win32clipboard.GetClipboardData(win32clipboard.CF_UNICODETEXT)
-                        if ignore_flag or clipboard_text != '*ocr_ignore*':
-                            img = Image.open(io.BytesIO(win32clipboard.GetClipboardData(win32clipboard.CF_DIB)))
-                            process_clipboard = True
-                    win32clipboard.CloseClipboard()
-            elif macos_clipboard_polling:
-                if not paused:
-                    with objc.autorelease_pool():
-                        old_count = count
-                        count = pasteboard.changeCount()
-                        if not just_unpaused and count != old_count and NSPasteboardTypeTIFF in pasteboard.types():
-                            clipboard_text = ''
-                            if NSPasteboardTypeString in pasteboard.types():
-                                clipboard_text = pasteboard.stringForType_(NSPasteboardTypeString)
-                            if ignore_flag or clipboard_text != '*ocr_ignore*':
-                                img = normalize_macos_clipboard(pasteboard.dataForType_(NSPasteboardTypeTIFF))
-                                img = Image.open(io.BytesIO(img))
-                                process_clipboard = True
-            else:
-                if not paused:
-                    old_img = img
-                    try:
-                        img = ImageGrab.grabclipboard()
-                    except Exception:
-                        pass
-                    else:
-                        if ((not just_unpaused) and isinstance(img, Image.Image) and \
-                            (ignore_flag or pyperclipfix.paste() != '*ocr_ignore*') and \
-                            (not are_images_identical(img, old_img))):
-                            process_clipboard = True
-
-            if process_clipboard:
-                process_and_write_results(img, write_to, notifications, None, None, start_time=start_time)
-
-            just_unpaused = False
-
-            if not windows_clipboard_polling:
-                time.sleep(delay_secs)
-        elif read_from == 'screencapture':
-            if screen_capture_on_combo:
-                take_screenshot = screenshot_event.wait(delay_secs)
-                if take_screenshot:
-                    screenshot_event.clear()
-            else:
-                take_screenshot = screencapture_window_active and not paused
-
-            if take_screenshot and screencapture_window_visible:
-                if screencapture_mode == 2:
-                    if sys.platform == 'darwin':
-                        with objc.autorelease_pool():
-                            if old_macos_screenshot_api:
-                                cg_image = CGWindowListCreateImageFromArray(CGRectNull, [window_id], kCGWindowImageBoundsIgnoreFraming)
-                            else:
-                                capture_macos_window_screenshot(window_id)
-                                try:
-                                    cg_image = screencapturekit_queue.get(timeout=0.5)
-                                except queue.Empty:
-                                    cg_image = None
-                            if not cg_image:
-                                on_window_closed(False)
-                                break
-                            width = CGImageGetWidth(cg_image)
-                            height = CGImageGetHeight(cg_image)
-                            raw_data = CGDataProviderCopyData(CGImageGetDataProvider(cg_image))
-                            bpr = CGImageGetBytesPerRow(cg_image)
-                        img = Image.frombuffer('RGBA', (width, height), raw_data, 'raw', 'BGRA', bpr, 1)
-                    else:
-                        try:
-                            coord_left, coord_top, right, bottom = win32gui.GetWindowRect(window_handle)
-
-                            coord_width = right - coord_left
-                            coord_height = bottom - coord_top
-
-                            hwnd_dc = win32gui.GetWindowDC(window_handle)
-                            mfc_dc = win32ui.CreateDCFromHandle(hwnd_dc)
-                            save_dc = mfc_dc.CreateCompatibleDC()
-
-                            save_bitmap = win32ui.CreateBitmap()
-                            save_bitmap.CreateCompatibleBitmap(mfc_dc, coord_width, coord_height)
-                            save_dc.SelectObject(save_bitmap)
-
-                            result = ctypes.windll.user32.PrintWindow(window_handle, save_dc.GetSafeHdc(), 2)
-
-                            bmpinfo = save_bitmap.GetInfo()
-                            bmpstr = save_bitmap.GetBitmapBits(True)
-                        except pywintypes.error:
-                            on_window_closed(False)
-                            break
-
-                        # rand = random.randint(1, 10)
-
-                        img = Image.frombuffer('RGB', (bmpinfo['bmWidth'], bmpinfo['bmHeight']), bmpstr, 'raw', 'BGRX', 0, 1)
-
-                        # if rand == 1:
-                        #     img.show()
+    while not terminated:
+        ocr_start_time = datetime.now()
+        start_time = time.time()
+        img = None
+        filter_img = False
 
-                        if custom_left:
-                            img = img.crop((custom_left, custom_top, custom_left + custom_width, custom_top + custom_height))
+        if process_queue:
+            try:
+                img, filter_img = image_queue.get(timeout=0.1)
+                notify = True
+            except queue.Empty:
+                pass
 
-                        # if rand == 1:
-                        #     img.show()
+        if (not img) and process_screenshots:
+            if (not paused) and take_screenshot.screencapture_window_active and take_screenshot.screencapture_window_visible and (time.time() - last_screenshot_time) > screen_capture_delay_secs:
+                img = take_screenshot()
+                filter_img = True
+                notify = False
+                last_screenshot_time = time.time()
 
-                        win32gui.DeleteObject(save_bitmap.GetHandle())
-                        save_dc.DeleteDC()
-                        mfc_dc.DeleteDC()
-                        win32gui.ReleaseDC(window_handle, hwnd_dc)
-                else:
-                    sct_img = sct.grab(sct_params)
-                    img = Image.frombytes('RGB', sct_img.size, sct_img.bgra, 'raw', 'BGRX')
-                # img.save(os.path.join(get_temporary_directory(), 'screencapture_before.png'), 'png')
-                if screen_capture_exclusions:
-                    img = img.convert("RGBA")
-                    draw = ImageDraw.Draw(img)
-                    for exclusion in screen_capture_exclusions:
-                        left, top, width, height = exclusion
-                        draw.rectangle((left, top, left + width, top + height), fill=(0, 0, 0, 0))
-                        # draw.rectangle((left, top, right, bottom), fill=(0, 0, 0))
-                # img.save(os.path.join(get_temporary_directory(), 'screencapture.png'), 'png')
-                res, _ = process_and_write_results(img, write_to, notifications, last_result, filtering, rectangle=rectangle, start_time=start_time)
+        if img == 0:
+            on_window_closed(False)
+            terminated = True
+            break
+        elif img:
+            if filter_img:
+                res, _ = process_and_write_results(img, write_to, last_result, filtering, notify, rectangle=rectangle, ocr_start_time=ocr_start_time)
                 if res:
                     last_result = (res, engine_index)
-                delay = screen_capture_delay_secs
             else:
-                delay = delay_secs
+                process_and_write_results(img, None, None, notify)
+            if isinstance(img, Path):
+                if delete_images:
+                    Path.unlink(img)
 
-            if not screen_capture_on_combo and delay:
-                time.sleep(delay)
-        else:
-            for path in read_from.iterdir():
-                if path.suffix.lower() in allowed_extensions:
-                    path_key = get_path_key(path)
-                    if path_key not in old_paths:
-                        old_paths.add(path_key)
-
-                        if not paused:
-                            try:
-                                img = Image.open(path)
-                                img.load()
-                            except (UnidentifiedImageError, OSError) as e:
-                                logger.warning(f'Error while reading file {path}: {e}')
-                            else:
-                                process_and_write_results(img, write_to, notifications, None, None, start_time=start_time)
-                                img.close()
-                                if delete_images:
-                                    Path.unlink(path)
-
-            time.sleep(delay_secs)
-
-    if read_from == 'websocket' or write_to == 'websocket':
+        elapsed_time = time.time() - start_time
+        if (not terminated) and elapsed_time < 0.1:
+            time.sleep(0.1 - elapsed_time)
+
+    if websocket_server_thread:
         websocket_server_thread.stop_server()
         websocket_server_thread.join()
-    if read_from == 'clipboard' and windows_clipboard_polling:
-        win32api.PostThreadMessage(windows_clipboard_thread.thread_id, win32con.WM_QUIT, 0, 0)
-        windows_clipboard_thread.join()
-    elif read_from == 'screencapture' and screencapture_mode == 2:
-        if sys.platform == 'darwin':
-            if screen_capture_only_active_windows:
-                macos_window_tracker.stop = True
-                macos_window_tracker.join()
-        else:
-            windows_window_tracker.stop = True
-            windows_window_tracker.join()
-    elif read_from == 'unixsocket':
+    if clipboard_thread:
+        if sys.platform == 'win32':
+            win32api.PostThreadMessage(clipboard_thread.thread_id, win32con.WM_QUIT, 0, 0)
+        clipboard_thread.join()
+    if directory_watcher_thread:
+        directory_watcher_thread.join()
+    if unix_socket_server:
         unix_socket_server.shutdown()
         unix_socket_server_thread.join()
-    if len(key_combos) > 0:
+    if key_combo_listener:
         key_combo_listener.stop()
-    if auto_pause_handler:
-        auto_pause_handler.stop()