GameSentenceMiner 2.19.6__py3-none-any.whl → 2.19.7__py3-none-any.whl

GameSentenceMiner/anki.py

@@ -28,7 +28,7 @@ import re
 import platform
 import sys
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Dict, Any, List
 
 # Global variables to track state
@@ -58,6 +58,8 @@ class MediaAssets:
     final_prev_screenshot_path: str = ''
     final_video_path: str = ''
 
+    extra_tags: List[str] = field(default_factory=list)
+
 
 def _determine_update_conditions(last_note: 'AnkiCard') -> (bool, bool):
     """Determine if audio and picture fields should be updated."""
@@ -83,7 +85,10 @@ def _generate_media_files(reuse_audio: bool, game_line: 'GameLine', video_path:
         assets.screenshot_in_anki = anki_result.screenshot_in_anki
         assets.prev_screenshot_in_anki = anki_result.prev_screenshot_in_anki
         assets.video_in_anki = anki_result.video_in_anki
+        assets.extra_tags = anki_result.extra_tags
         return assets
+    
+    assets.extra_tags = []
 
     # --- Generate new media files ---
     if config.anki.picture_field and config.screenshot.enabled:
@@ -242,7 +247,7 @@ def update_anki_card(last_note: 'AnkiCard', note=None, audio_path='', video_path
         
         # Add NSFW tag if checkbox was selected
         if add_nsfw_tag:
-            tags.append("NSFW")
+            assets.extra_tags.append("NSFW")
 
     # 5. If creating new media, store files in Anki's collection. Then update note fields.
     if not use_existing_files:
@@ -266,6 +271,9 @@ def update_anki_card(last_note: 'AnkiCard', note=None, audio_path='', video_path
         if config.audio.external_tool and config.audio.external_tool_enabled:
             anki_media_audio_path = os.path.join(config.audio.anki_media_collection, assets.audio_in_anki)
             open_audio_in_external(anki_media_audio_path)
+            
+    for extra_tag in assets.extra_tags:
+        tags.append(extra_tag)
 
     # 6. Asynchronously update the note in Anki
     run_new_thread(lambda: check_and_update_note(last_note, note, tags))
@@ -284,7 +292,8 @@ def update_anki_card(last_note: 'AnkiCard', note=None, audio_path='', video_path
             multi_line=bool(selected_lines and len(selected_lines) > 1),
             video_in_anki=assets.video_in_anki or '',
             word_path=word_path,
-            word=tango
+            word=tango,
+            extra_tags=assets.extra_tags
         )
     
     # 9. Update the local application database with final paths

GameSentenceMiner/locales/en_us.json

@@ -358,6 +358,10 @@
           "hotkey_updates_anki": {
             "label": "Screenshot Hotkey Updates Anki:",
             "tooltip": "Enable to allow Screenshot hotkey/button to update the latest anki card."
+          },
+          "trim_black_bars": {
+            "label": "Trim Black Bars:",
+            "tooltip": "Automatically trim black bars from screenshots. Useful for games with letterboxing/pillarboxing (e.g., 4:3 games on 16:9 displays)."
           }
         },
         "audio": {

GameSentenceMiner/locales/ja_jp.json

@@ -357,6 +357,10 @@
           "hotkey_updates_anki": {
             "label": "ホットキーでAnkiを更新:",
             "tooltip": "撮影ホットキーで最新のAnkiカードを更新できるようにします。"
+          },
+          "trim_black_bars": {
+            "label": "黒帯をトリミング:",
+            "tooltip": "スクリーンショットから黒帯を自動的にトリミングします。レターボックス/ピラーボックスのあるゲーム（16:9ディスプレイ上の4:3ゲームなど）に便利です。"
           }
         },
         "audio": {

GameSentenceMiner/locales/zh_cn.json

@@ -358,6 +358,10 @@
           "hotkey_updates_anki": {
             "label": "截图热键更新 Anki:",
             "tooltip": "允许截图热键/按钮更新最新的 Anki 卡片。"
+          },
+          "trim_black_bars": {
+            "label": "裁剪黑边:",
+            "tooltip": "自动裁剪截图中的黑边。适用于有信箱/柱状框的游戏（例如在 16:9 显示器上的 4:3 游戏）。"
           }
         },
         "audio": {

GameSentenceMiner/obs.py

@@ -565,6 +565,24 @@ def get_active_source():
         return None
     return get_source_from_scene(current_game)
 
+def get_active_video_sources():
+    current_game = get_current_game()
+    if not current_game:
+        return None
+    scene_items_response = []
+    try:
+        with connection_pool.get_client() as client:
+            client: obs.ReqClient
+            response = client.get_scene_item_list(name=current_game)
+            scene_items_response = response.scene_items if response else []
+    except Exception as e:
+        logger.error(f"Error getting scene items for active video source: {e}")
+        return None
+    if not scene_items_response:
+        return None
+    video_sources = ['window_capture', 'game_capture', 'monitor_capture']
+    return [item for item in scene_items_response if item.get('inputKind') in video_sources]
+
 def get_record_directory():
     try:
         with connection_pool.get_client() as client:
@@ -709,32 +727,143 @@ def get_screenshot_base64(compression=75, width=None, height=None):
         return None
     
 
-def get_screenshot_PIL(source_name=None, compression=75, img_format='png', width=None, height=None, retry=3):
+def get_screenshot_PIL_from_source(source_name, compression=75, img_format='png', width=None, height=None, retry=3):
+    """
+    Get a PIL Image screenshot from a specific OBS source.
+    
+    Args:
+        source_name: The name of the OBS source to capture
+        compression: Image quality (0-100)
+        img_format: Image format ('png' or 'jpg')
+        width: Optional width to resize
+        height: Optional height to resize
+        retry: Number of retry attempts
+        
+    Returns:
+        PIL.Image or None if failed
+    """
     import io
     import base64
     from PIL import Image
+    
     if not source_name:
-        source_name = get_active_source().get('sourceName', None)
-    if not source_name:
-        logger.error("No active source found in the current scene.")
+        logger.error("No source name provided.")
         return None
-    while True:
-        with connection_pool.get_client() as client:
-            client: obs.ReqClient
-            response = client.get_source_screenshot(name=source_name, img_format=img_format, quality=compression, width=width, height=height)
+        
+    for attempt in range(retry):
         try:
-            response.image_data = response.image_data.split(',', 1)[-1]  # Remove data:image/png;base64, prefix if present
+            with connection_pool.get_client() as client:
+                client: obs.ReqClient
+                response = client.get_source_screenshot(name=source_name, img_format=img_format, quality=compression, width=width, height=height)
+            
+            if response and hasattr(response, 'image_data') and response.image_data:
+                image_data = response.image_data.split(',', 1)[-1]  # Remove data:image/png;base64, prefix if present
+                image_data = base64.b64decode(image_data)
+                img = Image.open(io.BytesIO(image_data)).convert("RGBA")
+                return img
         except AttributeError:
-            retry -= 1
-            if retry <= 0:
-                logger.error(f"Error getting screenshot: {response}")
+            if attempt >= retry - 1:
+                logger.error(f"Error getting screenshot from source '{source_name}': Invalid response")
                 return None
+            time.sleep(0.1)
+        except Exception as e:
+            logger.error(f"Error getting screenshot from source '{source_name}': {e}")
+            return None
+    
+    return None
+
+
+def get_best_source_for_screenshot():
+    """
+    Get the best available video source dict based on priority and image validation.
+    
+    Priority order: window_capture > game_capture > monitor_capture
+    
+    Returns:
+        The source dict of the best available source, or None if no valid source found.
+    """
+    return get_screenshot_PIL(return_source_dict=True)
+
+
+def get_screenshot_PIL(source_name=None, compression=75, img_format='png', width=None, height=None, retry=3, return_source_dict=False):
+    """
+    Get a PIL Image screenshot. If no source_name is provided, automatically selects
+    the best available source based on priority and validates it has actual image data.
+    
+    Priority order: window_capture > game_capture > monitor_capture
+    
+    Args:
+        source_name: Optional specific OBS source name. If None, auto-selects best source.
+        compression: Image quality (0-100)
+        img_format: Image format ('png' or 'jpg')
+        width: Optional width to resize
+        height: Optional height to resize
+        retry: Number of retry attempts
+        return_source_dict: If True, returns only the source dict. If False, returns only the PIL.Image.
+        
+    Returns:
+        PIL.Image if return_source_dict=False, or source dict if return_source_dict=True.
+        Returns None if failed.
+    """
+    import io
+    import base64
+    from PIL import Image
+    
+    # If source_name is provided, use it directly
+    if source_name:
+        if return_source_dict:
+            # Need to find the source dict for this source_name
+            current_sources = get_active_video_sources()
+            if current_sources:
+                for src in current_sources:
+                    if src.get('sourceName') == source_name:
+                        return src
+            return None
+        img = get_screenshot_PIL_from_source(source_name, compression, img_format, width, height, retry)
+        return img
+    
+    # Get all available video sources
+    current_sources = get_active_video_sources()
+    if not current_sources:
+        logger.error("No active video sources found in the current scene.")
+        return None
+    
+    # Priority: window_capture (0) > game_capture (1) > monitor_capture (2)
+    priority_map = {'window_capture': 0, 'game_capture': 1, 'monitor_capture': 2}
+    
+    # Sort sources by priority
+    sorted_sources = sorted(
+        current_sources,
+        key=lambda x: priority_map.get(x.get('inputKind'), 999)
+    )
+    
+    # Try each source in priority order
+    for source in sorted_sources:
+        found_source_name = source.get('sourceName')
+        if not found_source_name:
             continue
-        if response and response.image_data:
-            image_data = response.image_data.split(',', 1)[-1]  # Remove data:image/png;base64, prefix if present
-            image_data = base64.b64decode(image_data)
-            img = Image.open(io.BytesIO(image_data)).convert("RGBA")
-            return img
+            
+        img = get_screenshot_PIL_from_source(found_source_name, compression, img_format, width, height, retry)
+        
+        if img:
+            # Validate that the image has actual content (not completely empty/black)
+            try:
+                extrema = img.getextrema()
+                if isinstance(extrema[0], tuple):
+                    is_empty = all(e[0] == e[1] for e in extrema)
+                else:
+                    is_empty = extrema[0] == extrema[1]
+                
+                if not is_empty:
+                    return source if return_source_dict else img
+                else:
+                    logger.debug(f"Source '{found_source_name}' returned an empty image, trying next source")
+            except Exception as e:
+                logger.warning(f"Failed to validate image from source '{found_source_name}': {e}")
+                # If validation fails, still return the image as it might be valid
+                return source if return_source_dict else img
+    
+    logger.error("No active source with valid image data found.")
     return None
 
     
@@ -915,6 +1044,13 @@ def create_scene():
 if __name__ == '__main__':
     logging.basicConfig(level=logging.INFO)
     connect_to_obs_sync()
+    try:
+        with connection_pool.get_client() as client:
+            client: obs.ReqClient
+            resp = client.get_scene_item_list(get_current_scene())
+            print(resp.scene_items)
+    except Exception as e:
+        print(f"Error: {e}")
     
     # outputs = get_output_list()
     # print(outputs)

GameSentenceMiner/ocr/owocr_area_selector.py

@@ -54,8 +54,11 @@ class ScreenSelector:
             raise RuntimeError("mss is required for screen selection.")
 
         if self.use_obs_screenshot:
-            print("Using OBS screenshot as target.")
-            self.screenshot_img = obs.get_screenshot_PIL(compression=75)
+            sources = obs.get_active_video_sources()
+            best_source = obs.get_best_source_for_screenshot()
+            if len(sources) > 1:
+                logger.warning(f"Warning: Multiple active video sources found in OBS. Using '{best_source.get('sourceName')}' for screenshot. Please ensure only one source is active for best results.")
+            self.screenshot_img = obs.get_screenshot_PIL(compression=100, img_format='jpg')
             # print(screenshot_base64)
             if not self.screenshot_img:
                 raise RuntimeError("Failed to get OBS screenshot.")

GameSentenceMiner/ocr/owocr_helper.py

@@ -391,7 +391,7 @@ def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering
                     stable_time = last_meiki_crop_time
                     previous_img_local = previous_img
                     pre_crop_image = previous_img_local
-                    ocr2_image = get_ocr2_image(crop_coords, og_image=previous_img_local, ocr2_engine=get_ocr_ocr2())
+                    ocr2_image = get_ocr2_image(crop_coords, og_image=previous_img_local, ocr2_engine=get_ocr_ocr2(), extra_padding=10)
                     # Use the earlier timestamp for when the stable crop started if available
                     # ocr2_image.show()
                     second_ocr_queue.put((text, stable_time, ocr2_image, filtering, pre_crop_image))
@@ -482,22 +482,54 @@ done = False
 # Create a queue for tasks
 second_ocr_queue = queue.Queue()
 
-def get_ocr2_image(crop_coords, og_image: Image.Image, ocr2_engine=None):
+def get_ocr2_image(crop_coords, og_image: Image.Image, ocr2_engine=None, extra_padding=0):
     """
     Returns the image to use for the second OCR pass, cropping and scaling as needed.
     Logic is unchanged, but code is refactored for clarity and maintainability.
     """
     def return_original_image():
+        """Return a (possibly cropped) PIL.Image based on the original image and padding."""
         logger.debug("Returning original image for OCR2 (no cropping or optimization).")
+        # Convert bytes to PIL.Image if necessary
+        img = og_image
+        if isinstance(og_image, (bytes, bytearray)):
+            try:
+                img = Image.open(io.BytesIO(og_image)).convert('RGB')
+            except Exception:
+                # If conversion fails, just return og_image as-is
+                return og_image
+
         if not crop_coords or not get_ocr_optimize_second_scan():
-            return og_image
+            return img
+
         x1, y1, x2, y2 = crop_coords
-        x1 = min(max(0, x1), og_image.width)
-        y1 = min(max(0, y1), og_image.height)
-        x2 = min(max(0, x2), og_image.width)
-        y2 = min(max(0, y2), og_image.height)
-        og_image.save(os.path.join(get_temporary_directory(), "pre_oneocrcrop.png"))
-        return og_image.crop((x1, y1, x2, y2))
+        # Apply integer padding (can be negative to shrink)
+        pad = int(extra_padding or 0)
+        x1 = x1 - pad
+        y1 = y1 - pad
+        x2 = x2 + pad
+        y2 = y2 + pad
+
+        # Clamp coordinates to image bounds
+        x1 = min(max(0, int(x1)), img.width)
+        y1 = min(max(0, int(y1)), img.height)
+        x2 = min(max(0, int(x2)), img.width)
+        y2 = min(max(0, int(y2)), img.height)
+
+        # Ensure at least a 1-pixel width/height
+        if x2 <= x1:
+            x2 = min(img.width, x1 + 1)
+            x1 = max(0, x2 - 1)
+        if y2 <= y1:
+            y2 = min(img.height, y1 + 1)
+            y1 = max(0, y2 - 1)
+
+        try:
+            img.save(os.path.join(get_temporary_directory(), "pre_oneocrcrop.png"))
+        except Exception:
+            # don't fail just because we couldn't save a debug image
+            logger.debug("Could not save pre_oneocrcrop.png for debugging")
+        return img.crop((x1, y1, x2, y2))
     
     # TODO Get rid of this check, and just always convert to full res
     LOCAL_OCR_ENGINES = ['easyocr', 'oneocr', 'rapidocr', 'mangaocr', 'winrtocr']
@@ -541,16 +573,33 @@ def get_ocr2_image(crop_coords, og_image: Image.Image, ocr2_engine=None):
     x2 = int(crop_coords[2] * width_ratio)
     y2 = int(crop_coords[3] * height_ratio)
 
+    # Scale padding separately for X and Y
+    pad_x = int(round((extra_padding or 0) * width_ratio))
+    pad_y = int(round((extra_padding or 0) * height_ratio))
+
+    x1 = x1 - pad_x
+    y1 = y1 - pad_y
+    x2 = x2 + pad_x
+    y2 = y2 + pad_y
+
     # Clamp coordinates to image bounds
-    x1 = min(max(0, x1), img.width)
-    y1 = min(max(0, y1), img.height)
-    x2 = min(max(0, x2), img.width)
-    y2 = min(max(0, y2), img.height)
-    
+    x1 = min(max(0, int(x1)), img.width)
+    y1 = min(max(0, int(y1)), img.height)
+    x2 = min(max(0, int(x2)), img.width)
+    y2 = min(max(0, int(y2)), img.height)
+
+    # Ensure at least a 1-pixel width/height
+    if x2 <= x1:
+        x2 = min(img.width, x1 + 1)
+        x1 = max(0, x2 - 1)
+    if y2 <= y1:
+        y2 = min(img.height, y1 + 1)
+        y1 = max(0, y2 - 1)
+
     logger.debug(f"Scaled crop coordinates: {(x1, y1, x2, y2)}")
-    
+
     img = run.apply_ocr_config_to_image(img, ocr_config_local, is_secondary=False)
-    
+
     ret = img.crop((x1, y1, x2, y2))
     return ret
 
@@ -763,7 +812,7 @@ if __name__ == "__main__":
             try:
                 while not done:
                     time.sleep(1)
-            except KeyboardInterrupt as e:
+            except KeyboardInterrupt:
                 pass
         else:
             print("Failed to load OCR configuration. Please check the logs.")

GameSentenceMiner/owocr/owocr/run.py

@@ -1038,7 +1038,8 @@ class OBSScreenshotThread(threading.Thread):
     def init_config(self, source=None, scene=None):
         import GameSentenceMiner.obs as obs
         obs.update_current_game()
-        self.current_source = source if source else obs.get_active_source()
+        current_sources = obs.get_active_video_sources()
+        self.current_source = source if source else obs.get_best_source_for_screenshot()
         logger.debug(f"Current OBS source: {self.current_source}")
         self.source_width = self.current_source.get(
             "sceneItemTransform").get("sourceWidth") or self.width
@@ -1056,6 +1057,8 @@ class OBSScreenshotThread(threading.Thread):
                 f"Using source dimensions: {self.width}x{self.height}")
         self.current_source_name = self.current_source.get(
             "sourceName") or None
+        if len(current_sources) > 1:
+            logger.error(f"Multiple active video sources found in OBS. Using {self.current_source_name} for Screenshot. Please ensure only one source is active for best results.")
         self.current_scene = scene if scene else obs.get_current_game()
         self.ocr_config = get_scene_ocr_config(refresh=True)
         if not self.ocr_config:
@@ -1394,7 +1397,7 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
     if res:
         if 'provider' in text:
             if write_to == 'callback':
-                logger.opt(ansi=True).info(f"{len(text['boxes'])} text boxes recognized using Meiki:")
+                logger.opt(ansi=True).info(f"{len(text['boxes'])} text boxes recognized in {end_time - start_time:0.03f}s using Meiki:")
                 txt_callback('', '', ocr_start_time,
                              img_or_path, is_second_ocr, filtering, text.get('crop_coords', None), meiki_boxes=text.get('boxes', []))
                 return str(text), str(text)

GameSentenceMiner/ui/config_gui.py

@@ -449,6 +449,7 @@ class ConfigApp:
         self.screenshot_timing_value = tk.StringVar(value=self.settings.screenshot.screenshot_timing_setting)
         self.use_screenshot_selector_value = tk.BooleanVar(value=self.settings.screenshot.use_screenshot_selector)
         self.animated_screenshot_value = tk.BooleanVar(value=self.settings.screenshot.animated)
+        self.trim_black_bars_value = tk.BooleanVar(value=self.settings.screenshot.trim_black_bars_wip)
 
         # Audio Settings
         self.audio_enabled_value = tk.BooleanVar(value=self.settings.audio.enabled)
@@ -703,6 +704,7 @@ class ConfigApp:
                 seconds_after_line=float(self.seconds_after_line_value.get()) if self.seconds_after_line_value.get() else 0.0,
                 screenshot_timing_setting=self.screenshot_timing_value.get(),
                 use_screenshot_selector=self.use_screenshot_selector_value.get(),
+                trim_black_bars_wip=self.trim_black_bars_value.get(),
             ),
             audio=Audio(
                 enabled=self.audio_enabled_value.get(),
@@ -771,6 +773,7 @@ class ConfigApp:
                 use_canned_context_prompt=self.use_canned_context_prompt_value.get(),
                 custom_prompt=self.custom_prompt.get("1.0", tk.END).strip(),
                 dialogue_context_length=int(self.ai_dialogue_context_length_value.get()),
+                custom_texthooker_prompt=self.custom_texthooker_prompt.get("1.0", tk.END).strip(),
             ),
             overlay=Overlay(
                 websocket_port=int(self.overlay_websocket_port_value.get()),
@@ -1765,6 +1768,14 @@ class ConfigApp:
             row=self.current_row, column=1, sticky='W', pady=2)
         self.current_row += 1
 
+        trim_black_bars_i18n = ss_i18n.get('trim_black_bars', {})
+        HoverInfoLabelWidget(screenshot_frame, text=trim_black_bars_i18n.get('label', '...'),
+                             tooltip=trim_black_bars_i18n.get('tooltip', '...'),
+                             row=self.current_row, column=0)
+        ttk.Checkbutton(screenshot_frame, variable=self.trim_black_bars_value, bootstyle="round-toggle").grid(
+            row=self.current_row, column=1, sticky='W', pady=2)
+        self.current_row += 1
+
         self.add_reset_button(screenshot_frame, "screenshot", self.current_row, 0, self.create_screenshot_tab)
 
         for col in range(3):
@@ -2299,6 +2310,16 @@ class ConfigApp:
         self.custom_prompt.insert(tk.END, self.settings.ai.custom_prompt)
         self.custom_prompt.grid(row=self.current_row, column=1, sticky='EW', pady=2)
         self.current_row += 1
+        
+        custom_texthooker_prompt_i18n = ai_i18n.get('custom_texthooker_prompt', {})
+        HoverInfoLabelWidget(ai_frame, text=custom_texthooker_prompt_i18n.get('label', 'Custom Texthooker Prompt:'), tooltip=custom_texthooker_prompt_i18n.get('tooltip', 'Custom Prompt to use for Texthooker Translate Button.'),
+                             row=self.current_row, column=0)
+        self.custom_texthooker_prompt = scrolledtext.ScrolledText(ai_frame, width=50, height=5, font=("TkDefaultFont", 9),
+                                                                   relief="solid", borderwidth=1,
+                                                                   highlightbackground=ttk.Style().colors.border)
+        self.custom_texthooker_prompt.insert(tk.END, self.settings.ai.custom_texthooker_prompt)
+        self.custom_texthooker_prompt.grid(row=self.current_row, column=1, sticky='EW', pady=2)
+        self.current_row += 1
 
         self.add_reset_button(ai_frame, "ai", self.current_row, 0, self.create_ai_tab)
 

GameSentenceMiner/ui/screenshot_selector.py

@@ -1,4 +1,6 @@
+import math
 import os
+import re
 import subprocess
 import json
 import tkinter as tk
@@ -6,8 +8,9 @@ from tkinter import messagebox
 import ttkbootstrap as ttk
 from PIL import Image, ImageTk
 
+from GameSentenceMiner.util import ffmpeg
 from GameSentenceMiner.util.gsm_utils import sanitize_filename
-from GameSentenceMiner.util.configuration import get_temporary_directory, logger, ffmpeg_base_command_list, get_ffprobe_path
+from GameSentenceMiner.util.configuration import get_config, get_temporary_directory, logger, ffmpeg_base_command_list, get_ffprobe_path, ffmpeg_base_command_list_info
 
 
 class ScreenshotSelectorDialog(tk.Toplevel):
@@ -65,7 +68,7 @@ class ScreenshotSelectorDialog(tk.Toplevel):
         # Force always on top to ensure visibility
 
     def _extract_frames(self, video_path, timestamp, mode):
-        """Extracts frames using ffmpeg. Encapsulated from the original script."""
+        """Extracts frames using ffmpeg, with automatic black bar removal."""
         temp_dir = os.path.join(
             get_temporary_directory(False),
             "screenshot_frames",
@@ -87,17 +90,36 @@ class ScreenshotSelectorDialog(tk.Toplevel):
             logger.warning(f"Timestamp {timestamp_number} exceeds video duration {video_duration}.")
             return [], None
 
+        video_filters = []
+
+        if get_config().screenshot.trim_black_bars_wip:
+            crop_filter = ffmpeg.find_black_bars(video_path, timestamp_number)
+            if crop_filter:
+                video_filters.append(crop_filter)
+
+        # Always add the frame extraction filter
+        video_filters.append(f"fps=1/{0.25}")
+
         try:
+            # Build the final command for frame extraction
             command = ffmpeg_base_command_list + [
-                "-y",
+                "-y",                          # Overwrite output files without asking
                 "-ss", str(timestamp_number),
-                "-i", video_path,
-                "-vf", f"fps=1/{0.25}",
+                "-i", video_path
+            ]
+            
+            # Chain all collected filters (crop and fps) together with a comma
+            command.extend(["-vf", ",".join(video_filters)])
+            
+            command.extend([
                 "-vframes", "20",
                 os.path.join(temp_dir, "frame_%02d.png")
-            ]
+            ])
+            
+            logger.debug(f"Executing frame extraction command: {' '.join(command)}")
             subprocess.run(command, check=True, capture_output=True, text=True)
 
+            # The rest of your logic remains the same
             for i in range(1, 21):
                 frame_path = os.path.join(temp_dir, f"frame_{i:02d}.png")
                 if os.path.exists(frame_path):
@@ -122,7 +144,7 @@ class ScreenshotSelectorDialog(tk.Toplevel):
         except Exception as e:
             logger.error(f"An unexpected error occurred during frame extraction: {e}")
             return [], None
-
+        
     def _build_image_grid(self, image_paths, golden_frame):
         """Creates and displays the grid of selectable images."""
         self.images = [] # Keep a reference to images to prevent garbage collection

GameSentenceMiner/util/configuration.py

@@ -12,7 +12,7 @@ from logging.handlers import RotatingFileHandler
 from os.path import expanduser
 from sys import platform
 import time
-from typing import List, Dict
+from typing import Any, List, Dict
 import sys
 from enum import Enum
 
@@ -59,6 +59,28 @@ supported_formats = {
     'm4a': 'aac',
 }
 
+KNOWN_ASPECT_RATIOS = [
+    # --- Classic / Legacy ---
+    {"name": "4:3 (SD / Retro Games)", "ratio": 4 / 3},
+    {"name": "5:4 (Old PC Monitors)", "ratio": 5 / 4},
+    {"name": "3:2 (Handheld / GBA / DS / DSLR)", "ratio": 3 / 2},
+
+    # --- Modern Displays ---
+    {"name": "16:10 (PC Widescreen)", "ratio": 16 / 10},
+    {"name": "16:9 (Standard HD / 1080p / 4K)", "ratio": 16 / 9},
+    {"name": "18:9 (Mobile / Some Modern Laptops)", "ratio": 18 / 9},
+    {"name": "19.5:9 (Modern Smartphones)", "ratio": 19.5 / 9},
+    {"name": "21:9 (UltraWide)", "ratio": 21 / 9},
+    {"name": "24:10 (UltraWide+)", "ratio": 24 / 10},
+    {"name": "32:9 (Super UltraWide)", "ratio": 32 / 9},
+
+    # --- Vertical / Mobile ---
+    {"name": "9:16 (Portrait Mode)", "ratio": 9 / 16},
+    {"name": "3:4 (Portrait 4:3)", "ratio": 3 / 4},
+    {"name": "1:1 (Square / UI Capture)", "ratio": 1 / 1},
+]
+
+KNOWN_ASPECT_RATIOS_DICT = {item["name"]: item["ratio"] for item in KNOWN_ASPECT_RATIOS}
 
 def is_linux():
     return platform == 'linux'
@@ -490,6 +512,7 @@ class Screenshot:
     use_new_screenshot_logic: bool = False
     screenshot_timing_setting: str = 'beginning'  # 'middle', 'end'
     use_screenshot_selector: bool = False
+    trim_black_bars_wip: bool = True
 
     def __post_init__(self):
         if not self.screenshot_timing_setting and self.use_beginning_of_line_as_screenshot:
@@ -632,6 +655,7 @@ class Ai:
     use_canned_translation_prompt: bool = True
     use_canned_context_prompt: bool = False
     custom_prompt: str = ''
+    custom_texthooker_prompt: str = ''
     dialogue_context_length: int = 10
 
     def __post_init__(self):
@@ -1321,10 +1345,11 @@ class AnkiUpdateResult:
     video_in_anki: str = ''
     word_path: str = ''
     word: str = ''
+    extra_tags: List[str] = field(default_factory=list)
 
     @staticmethod
     def failure():
-        return AnkiUpdateResult(success=False, audio_in_anki='', screenshot_in_anki='', prev_screenshot_in_anki='', sentence_in_anki='', multi_line=False, video_in_anki='', word_path='', word='')
+        return AnkiUpdateResult(success=False, audio_in_anki='', screenshot_in_anki='', prev_screenshot_in_anki='', sentence_in_anki='', multi_line=False, video_in_anki='', word_path='', word='', extra_tags=[])
 
 
 @dataclass_json
@@ -1376,6 +1401,8 @@ def get_ffprobe_path():
 
 ffmpeg_base_command_list = [get_ffmpeg_path(), "-hide_banner", "-loglevel", "error", '-nostdin']
 
+ffmpeg_base_command_list_info = [get_ffmpeg_path(), "-hide_banner", "-loglevel", "info", '-nostdin']
+
 
 # logger.debug(f"Running in development mode: {is_dev}")
 # logger.debug(f"Running on Beangate's PC: {is_beangate}")