lyrics-transcriber 0.43.1__py3-none-any.whl → 0.45.0__py3-none-any.whl

lyrics_transcriber/frontend/src/hooks/useManualSync.ts

@@ -0,0 +1,267 @@
+import { useState, useCallback, useEffect, useRef } from 'react'
+import { LyricsSegment, Word } from '../types'
+
+interface UseManualSyncProps {
+    editedSegment: LyricsSegment | null
+    currentTime: number
+    onPlaySegment?: (startTime: number) => void
+    updateSegment: (words: Word[]) => void
+}
+
+// Constants for tap detection
+const TAP_THRESHOLD_MS = 200 // If spacebar is pressed for less than this time, it's considered a tap
+const DEFAULT_WORD_DURATION = 1.0 // Default duration in seconds when tapping
+const OVERLAP_BUFFER = 0.01 // Buffer to prevent word overlap (10ms)
+
+export default function useManualSync({
+    editedSegment,
+    currentTime,
+    onPlaySegment,
+    updateSegment
+}: UseManualSyncProps) {
+    const [isManualSyncing, setIsManualSyncing] = useState(false)
+    const [syncWordIndex, setSyncWordIndex] = useState<number>(-1)
+    const currentTimeRef = useRef(currentTime)
+    const [isSpacebarPressed, setIsSpacebarPressed] = useState(false)
+    const wordStartTimeRef = useRef<number | null>(null)
+    const wordsRef = useRef<Word[]>([])
+    const spacebarPressTimeRef = useRef<number | null>(null)
+
+    // Keep currentTimeRef up to date
+    useEffect(() => {
+        currentTimeRef.current = currentTime
+    }, [currentTime])
+
+    // Keep wordsRef up to date
+    useEffect(() => {
+        if (editedSegment) {
+            wordsRef.current = [...editedSegment.words]
+        }
+    }, [editedSegment])
+
+    const cleanupManualSync = useCallback(() => {
+        setIsManualSyncing(false)
+        setSyncWordIndex(-1)
+        setIsSpacebarPressed(false)
+        wordStartTimeRef.current = null
+        spacebarPressTimeRef.current = null
+    }, [])
+
+    const handleKeyDown = useCallback((e: KeyboardEvent) => {
+        if (e.code !== 'Space') return
+        
+        console.log('useManualSync - Spacebar pressed down', {
+            isManualSyncing,
+            hasEditedSegment: !!editedSegment,
+            syncWordIndex,
+            currentTime: currentTimeRef.current
+        })
+
+        e.preventDefault()
+        e.stopPropagation()
+
+        if (isManualSyncing && editedSegment && !isSpacebarPressed) {
+            const currentWord = syncWordIndex < editedSegment.words.length ? editedSegment.words[syncWordIndex] : null
+            console.log('useManualSync - Recording word start time', {
+                wordIndex: syncWordIndex,
+                wordText: currentWord?.text,
+                time: currentTimeRef.current
+            })
+            
+            setIsSpacebarPressed(true)
+            
+            // Record the start time of the current word
+            wordStartTimeRef.current = currentTimeRef.current
+            
+            // Record when the spacebar was pressed (for tap detection)
+            spacebarPressTimeRef.current = Date.now()
+            
+            // Update the word's start time immediately
+            if (syncWordIndex < editedSegment.words.length) {
+                const newWords = [...wordsRef.current]
+                const currentWord = newWords[syncWordIndex]
+                
+                // Set the start time for the current word
+                currentWord.start_time = currentTimeRef.current
+                
+                // Update our ref
+                wordsRef.current = newWords
+                
+                // Update the segment
+                updateSegment(newWords)
+            }
+        } else if (!isManualSyncing && editedSegment && onPlaySegment) {
+            console.log('useManualSync - Handling segment playback')
+            // Toggle segment playback when not in manual sync mode
+            const startTime = editedSegment.start_time ?? 0
+            const endTime = editedSegment.end_time ?? 0
+
+            if (currentTimeRef.current >= startTime && currentTimeRef.current <= endTime) {
+                if (window.toggleAudioPlayback) {
+                    window.toggleAudioPlayback()
+                }
+            } else {
+                onPlaySegment(startTime)
+            }
+        }
+    }, [isManualSyncing, editedSegment, syncWordIndex, onPlaySegment, updateSegment, isSpacebarPressed])
+
+    const handleKeyUp = useCallback((e: KeyboardEvent) => {
+        if (e.code !== 'Space') return
+        
+        console.log('useManualSync - Spacebar released', {
+            isManualSyncing,
+            hasEditedSegment: !!editedSegment,
+            syncWordIndex,
+            currentTime: currentTimeRef.current,
+            wordStartTime: wordStartTimeRef.current
+        })
+
+        e.preventDefault()
+        e.stopPropagation()
+
+        if (isManualSyncing && editedSegment && isSpacebarPressed) {
+            const currentWord = syncWordIndex < editedSegment.words.length ? editedSegment.words[syncWordIndex] : null
+            const pressDuration = spacebarPressTimeRef.current ? Date.now() - spacebarPressTimeRef.current : 0
+            const isTap = pressDuration < TAP_THRESHOLD_MS
+            
+            console.log('useManualSync - Recording word end time', {
+                wordIndex: syncWordIndex,
+                wordText: currentWord?.text,
+                startTime: wordStartTimeRef.current,
+                endTime: currentTimeRef.current,
+                pressDuration: `${pressDuration}ms`,
+                isTap,
+                duration: currentWord ? (currentTimeRef.current - (wordStartTimeRef.current || 0)).toFixed(2) + 's' : 'N/A'
+            })
+            
+            setIsSpacebarPressed(false)
+            
+            if (syncWordIndex < editedSegment.words.length) {
+                const newWords = [...wordsRef.current]
+                const currentWord = newWords[syncWordIndex]
+                
+                // Set the end time for the current word based on whether it was a tap or hold
+                if (isTap) {
+                    // For a tap, set a default duration
+                    const defaultEndTime = (wordStartTimeRef.current || currentTimeRef.current) + DEFAULT_WORD_DURATION
+                    currentWord.end_time = defaultEndTime
+                    console.log('useManualSync - Tap detected, setting default duration', {
+                        defaultEndTime,
+                        duration: DEFAULT_WORD_DURATION
+                    })
+                } else {
+                    // For a hold, use the current time as the end time
+                    currentWord.end_time = currentTimeRef.current
+                }
+                
+                // Update our ref
+                wordsRef.current = newWords
+                
+                // Move to the next word
+                if (syncWordIndex === editedSegment.words.length - 1) {
+                    // If this was the last word, finish manual sync
+                    console.log('useManualSync - Completed manual sync for all words')
+                    setIsManualSyncing(false)
+                    setSyncWordIndex(-1)
+                    wordStartTimeRef.current = null
+                    spacebarPressTimeRef.current = null
+                } else {
+                    // Otherwise, move to the next word
+                    const nextWord = editedSegment.words[syncWordIndex + 1]
+                    console.log('useManualSync - Moving to next word', {
+                        nextWordIndex: syncWordIndex + 1,
+                        nextWordText: nextWord?.text
+                    })
+                    setSyncWordIndex(syncWordIndex + 1)
+                }
+                
+                // Update the segment
+                updateSegment(newWords)
+            }
+        }
+    }, [isManualSyncing, editedSegment, syncWordIndex, updateSegment, isSpacebarPressed])
+
+    // Add a handler for when the next word starts to adjust previous word's end time if needed
+    useEffect(() => {
+        if (isManualSyncing && editedSegment && syncWordIndex > 0) {
+            const newWords = [...wordsRef.current]
+            const prevWord = newWords[syncWordIndex - 1]
+            const currentWord = newWords[syncWordIndex]
+            
+            // If the previous word's end time overlaps with the current word's start time,
+            // adjust the previous word's end time
+            if (prevWord && currentWord && 
+                prevWord.end_time !== null && currentWord.start_time !== null &&
+                prevWord.end_time > currentWord.start_time) {
+                
+                console.log('useManualSync - Adjusting previous word end time to prevent overlap', {
+                    prevWordIndex: syncWordIndex - 1,
+                    prevWordText: prevWord.text,
+                    prevWordEndTime: prevWord.end_time,
+                    currentWordStartTime: currentWord.start_time,
+                    newEndTime: currentWord.start_time - OVERLAP_BUFFER
+                })
+                
+                prevWord.end_time = currentWord.start_time - OVERLAP_BUFFER
+                
+                // Update our ref
+                wordsRef.current = newWords
+                
+                // Update the segment
+                updateSegment(newWords)
+            }
+        }
+    }, [syncWordIndex, isManualSyncing, editedSegment, updateSegment])
+
+    // Combine the key handlers into a single function for external use
+    const handleSpacebar = useCallback((e: KeyboardEvent) => {
+        if (e.type === 'keydown') {
+            handleKeyDown(e)
+        } else if (e.type === 'keyup') {
+            handleKeyUp(e)
+        }
+    }, [handleKeyDown, handleKeyUp])
+
+    const startManualSync = useCallback(() => {
+        if (isManualSyncing) {
+            cleanupManualSync()
+            return
+        }
+
+        if (!editedSegment || !onPlaySegment) return
+
+        // Make sure we have the latest words
+        wordsRef.current = [...editedSegment.words]
+        
+        setIsManualSyncing(true)
+        setSyncWordIndex(0)
+        setIsSpacebarPressed(false)
+        wordStartTimeRef.current = null
+        spacebarPressTimeRef.current = null
+        // Start playing 3 seconds before segment start
+        onPlaySegment((editedSegment.start_time ?? 0) - 3)
+    }, [isManualSyncing, editedSegment, onPlaySegment, cleanupManualSync])
+
+    // Auto-stop sync if we go past the end time
+    useEffect(() => {
+        if (!editedSegment) return
+
+        const endTime = editedSegment.end_time ?? 0
+
+        if (window.isAudioPlaying && currentTimeRef.current > endTime) {
+            console.log('Stopping playback: current time exceeded end time')
+            window.toggleAudioPlayback?.()
+            cleanupManualSync()
+        }
+    }, [isManualSyncing, editedSegment, currentTimeRef, cleanupManualSync])
+
+    return {
+        isManualSyncing,
+        syncWordIndex,
+        startManualSync,
+        cleanupManualSync,
+        handleSpacebar,
+        isSpacebarPressed
+    }
+} 

lyrics_transcriber/frontend/src/main.tsx

@@ -1,6 +1,12 @@
 import ReactDOM from 'react-dom/client'
+import { ThemeProvider } from '@mui/material/styles'
+import CssBaseline from '@mui/material/CssBaseline'
 import App from './App'
+import theme from './theme'
 
 ReactDOM.createRoot(document.getElementById('root')!).render(
-  <App />
+  <ThemeProvider theme={theme}>
+    <CssBaseline />
+    <App />
+  </ThemeProvider>
 )

lyrics_transcriber/frontend/src/theme.ts

@@ -0,0 +1,177 @@
+import { createTheme } from '@mui/material/styles';
+
+// Create a theme with smaller typography and spacing
+const theme = createTheme({
+  typography: {
+    // Scale down all typography by about 20%
+    fontSize: 14, // Default is 16
+    h1: {
+      fontSize: '2.5rem', // Default is ~3rem
+    },
+    h2: {
+      fontSize: '2rem', // Default is ~2.5rem
+    },
+    h3: {
+      fontSize: '1.5rem', // Default is ~1.75rem
+    },
+    h4: {
+      fontSize: '1.2rem', // Default is ~1.5rem
+      marginBottom: '0.5rem',
+    },
+    h5: {
+      fontSize: '1rem', // Default is ~1.25rem
+    },
+    h6: {
+      fontSize: '0.9rem', // Default is ~1.1rem
+      marginBottom: '0.5rem',
+    },
+    body1: {
+      fontSize: '0.85rem', // Default is ~1rem
+    },
+    body2: {
+      fontSize: '0.75rem', // Default is ~0.875rem
+    },
+    button: {
+      fontSize: '0.8rem', // Default is ~0.875rem
+    },
+    caption: {
+      fontSize: '0.7rem', // Default is ~0.75rem
+    },
+  },
+  components: {
+    MuiButton: {
+      styleOverrides: {
+        root: {
+          padding: '3px 10px', // Further reduced from 4px 12px
+          minHeight: '30px', // Further reduced from 32px
+        },
+        sizeSmall: {
+          padding: '1px 6px', // Further reduced from 2px 8px
+          minHeight: '24px', // Further reduced from 28px
+        },
+      },
+    },
+    MuiIconButton: {
+      styleOverrides: {
+        root: {
+          padding: '4px', // Further reduced from 6px
+        },
+        sizeSmall: {
+          padding: '2px', // Further reduced from 4px
+        },
+      },
+    },
+    MuiTextField: {
+      styleOverrides: {
+        root: {
+          '& .MuiInputBase-root': {
+            minHeight: '32px', // Further reduced from 36px
+          },
+        },
+      },
+    },
+    MuiDialog: {
+      styleOverrides: {
+        paper: {
+          padding: '8px', // Further reduced from 12px
+        },
+      },
+    },
+    MuiDialogTitle: {
+      styleOverrides: {
+        root: {
+          padding: '8px 12px', // Further reduced from 12px 16px
+        },
+      },
+    },
+    MuiDialogContent: {
+      styleOverrides: {
+        root: {
+          padding: '6px 12px', // Further reduced from 8px 16px
+        },
+      },
+    },
+    MuiDialogActions: {
+      styleOverrides: {
+        root: {
+          padding: '6px 12px', // Further reduced from 8px 16px
+        },
+      },
+    },
+    MuiPaper: {
+      styleOverrides: {
+        root: {
+          padding: '8px', // Further reduced from 12px
+        },
+      },
+    },
+    MuiList: {
+      styleOverrides: {
+        root: {
+          padding: '2px 0', // Further reduced from 4px 0
+        },
+      },
+    },
+    MuiListItem: {
+      styleOverrides: {
+        root: {
+          padding: '2px 8px', // Further reduced from 4px 12px
+        },
+      },
+    },
+    MuiTableCell: {
+      styleOverrides: {
+        root: {
+          padding: '4px 8px', // Further reduced from 8px 12px
+        },
+      },
+    },
+    MuiCard: {
+      styleOverrides: {
+        root: {
+          padding: '8px',
+        },
+      },
+    },
+    MuiCardContent: {
+      styleOverrides: {
+        root: {
+          padding: '8px',
+          '&:last-child': {
+            paddingBottom: '8px',
+          },
+        },
+      },
+    },
+    MuiCardHeader: {
+      styleOverrides: {
+        root: {
+          padding: '8px',
+        },
+      },
+    },
+    MuiCardActions: {
+      styleOverrides: {
+        root: {
+          padding: '4px 8px',
+        },
+      },
+    },
+    MuiGrid: {
+      styleOverrides: {
+        container: {
+          marginTop: '-4px',
+          marginLeft: '-4px',
+          width: 'calc(100% + 8px)',
+        },
+        item: {
+          paddingTop: '4px',
+          paddingLeft: '4px',
+        },
+      },
+    },
+  },
+  spacing: (factor: number) => `${0.6 * factor}rem`, // Further reduced from 0.8 * factor
+});
+
+export default theme; 

lyrics_transcriber/frontend/src/types.ts

@@ -136,4 +136,4 @@ export interface HighlightInfo {
     correction?: WordCorrection
 }
 
-export type InteractionMode = 'highlight' | 'details' | 'edit'
+export type InteractionMode = 'highlight' | 'edit'

lyrics_transcriber/frontend/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/app.tsx","./src/api.ts","./src/main.tsx","./src/types.ts","./src/validation.ts","./src/vite-env.d.ts","./src/components/audioplayer.tsx","./src/components/correctionmetrics.tsx","./src/components/detailsmodal.tsx","./src/components/editmodal.tsx","./src/components/fileupload.tsx","./src/components/header.tsx","./src/components/lyricsanalyzer.tsx","./src/components/modeselector.tsx","./src/components/previewvideosection.tsx","./src/components/referenceview.tsx","./src/components/reviewchangesmodal.tsx","./src/components/segmentdetailsmodal.tsx","./src/components/timelineeditor.tsx","./src/components/transcriptionview.tsx","./src/components/wordeditcontrols.tsx","./src/components/shared/constants.ts","./src/components/shared/styles.ts","./src/components/shared/types.ts","./src/components/shared/components/highlightedtext.tsx","./src/components/shared/components/sourceselector.tsx","./src/components/shared/components/word.tsx","./src/components/shared/hooks/usewordclick.ts","./src/components/shared/utils/keyboardhandlers.ts","./src/components/shared/utils/localstorage.ts","./src/components/shared/utils/referencelinecalculator.ts","./src/components/shared/utils/segmentoperations.ts","./src/components/shared/utils/wordutils.ts","./src/types/global.d.ts"],"version":"5.6.3"}
+{"root":["./src/app.tsx","./src/api.ts","./src/main.tsx","./src/theme.ts","./src/types.ts","./src/validation.ts","./src/vite-env.d.ts","./src/components/addlyricsmodal.tsx","./src/components/audioplayer.tsx","./src/components/correctionmetrics.tsx","./src/components/editactionbar.tsx","./src/components/editmodal.tsx","./src/components/edittimelinesection.tsx","./src/components/editwordlist.tsx","./src/components/fileupload.tsx","./src/components/findreplacemodal.tsx","./src/components/header.tsx","./src/components/lyricsanalyzer.tsx","./src/components/modeselector.tsx","./src/components/previewvideosection.tsx","./src/components/referenceview.tsx","./src/components/reviewchangesmodal.tsx","./src/components/segmentdetailsmodal.tsx","./src/components/timelineeditor.tsx","./src/components/transcriptionview.tsx","./src/components/worddivider.tsx","./src/components/shared/constants.ts","./src/components/shared/styles.ts","./src/components/shared/types.ts","./src/components/shared/components/highlightedtext.tsx","./src/components/shared/components/sourceselector.tsx","./src/components/shared/components/word.tsx","./src/components/shared/hooks/usewordclick.ts","./src/components/shared/utils/keyboardhandlers.ts","./src/components/shared/utils/localstorage.ts","./src/components/shared/utils/referencelinecalculator.ts","./src/components/shared/utils/segmentoperations.ts","./src/components/shared/utils/wordutils.ts","./src/hooks/usemanualsync.ts","./src/types/global.d.ts"],"version":"5.6.3"}

lyrics_transcriber/lyrics/base_lyrics_provider.py

@@ -47,14 +47,14 @@ class BaseLyricsProvider(ABC):
         converted_cache_path = self._get_cache_path(cache_key, "converted")
         converted_data = self._load_from_cache(converted_cache_path)
         if converted_data:
-            self.logger.info(f"Using cached converted lyrics for {artist} - {title}")
+            self.logger.info(f"Using cached converted lyrics for {artist} - {title} from file: {converted_cache_path}")
             return LyricsData.from_dict(converted_data)
 
         # Check raw cache next
         raw_cache_path = self._get_cache_path(cache_key, "raw")
         raw_data = self._load_from_cache(raw_cache_path)
         if raw_data:
-            self.logger.info(f"Using cached raw lyrics for {artist} - {title}")
+            self.logger.info(f"Using cached raw lyrics for {artist} - {title} from file: {raw_cache_path}")
             converted_result = self._convert_result_format(raw_data)
             self._save_to_cache(converted_cache_path, converted_result.to_dict())
             return converted_result

lyrics_transcriber/lyrics/user_input_provider.py

@@ -0,0 +1,44 @@
+from typing import Optional, Dict, Any
+from lyrics_transcriber.lyrics.base_lyrics_provider import BaseLyricsProvider, LyricsProviderConfig
+from lyrics_transcriber.types import LyricsData, LyricsMetadata
+
+
+class UserInputProvider(BaseLyricsProvider):
+    """Provider for manually input lyrics text."""
+
+    def __init__(self, lyrics_text: str, source_name: str, metadata: Dict[str, Any], *args, **kwargs):
+        """Initialize with the user's input text."""
+        super().__init__(LyricsProviderConfig(), *args, **kwargs)
+        self.lyrics_text = lyrics_text
+        self.source_name = source_name
+        self.input_metadata = metadata
+
+    def _fetch_data_from_source(self, artist: str, title: str) -> Optional[Dict[str, Any]]:
+        """Return the user's input text as raw data."""
+        return {"text": self.lyrics_text, "metadata": self.input_metadata}
+
+    def _convert_result_format(self, raw_data: Dict[str, Any]) -> LyricsData:
+        """Convert the raw text into LyricsData format."""
+        # Create segments with words from the text
+        segments = self._create_segments_with_words(raw_data["text"])
+
+        # Create metadata
+        metadata = LyricsMetadata(
+            source=self.source_name,
+            track_name=raw_data["metadata"].get("title", ""),
+            artist_names=raw_data["metadata"].get("artist", ""),
+            is_synced=False,
+            lyrics_provider="manual",
+            lyrics_provider_id="",
+            album_name=None,
+            duration_ms=None,
+            explicit=None,
+            language=None,
+            provider_metadata={},
+        )
+
+        return LyricsData(segments=segments, metadata=metadata, source=self.source_name)
+
+    def get_name(self) -> str:
+        """Return the provider name."""
+        return "UserInput"

lyrics_transcriber/output/generator.py

@@ -37,6 +37,7 @@ class OutputGenerator:
         self,
         config: OutputConfig,
         logger: Optional[logging.Logger] = None,
+        preview_mode: bool = False,
     ):
         """
         Initialize OutputGenerator with configuration.
@@ -44,20 +45,12 @@ class OutputGenerator:
         Args:
             config: OutputConfig instance with required paths and settings
             logger: Optional logger instance
+            preview_mode: Boolean indicating if the generator is in preview mode
         """
         self.config = config
         self.logger = logger or logging.getLogger(__name__)
 
-        self.logger.debug(f"Initializing OutputGenerator with config: {self.config}")
-
-        # Set video resolution parameters
-        self.video_resolution_num, self.font_size, self.line_height = self._get_video_params(self.config.video_resolution)
-
-        self.segment_resizer = SegmentResizer(max_line_length=self.config.max_line_length, logger=self.logger)
-
-        # Initialize generators
-        self.plain_text = PlainTextGenerator(self.config.output_dir, self.logger)
-        self.lyrics_file = LyricsFileGenerator(self.config.output_dir, self.logger)
+        self.logger.info(f"Initializing OutputGenerator with config: {self.config}")
 
         if self.config.render_video or self.config.generate_cdg:
             # Load output styles from JSON
@@ -68,10 +61,46 @@ class OutputGenerator:
             except Exception as e:
                 raise ValueError(f"Failed to load output styles file: {str(e)}")
 
+        # Set video resolution parameters
+        self.video_resolution_num, self.font_size, self.line_height = self._get_video_params(self.config.video_resolution)
+        self.logger.info(f"Video resolution: {self.video_resolution_num}, font size: {self.font_size}, line height: {self.line_height}")
+
+        self.segment_resizer = SegmentResizer(max_line_length=self.config.max_line_length, logger=self.logger)
+
+        # Initialize generators
+        self.plain_text = PlainTextGenerator(self.config.output_dir, self.logger)
+        self.lyrics_file = LyricsFileGenerator(self.config.output_dir, self.logger)
+
         if self.config.generate_cdg:
             self.cdg = CDGGenerator(self.config.output_dir, self.logger)
 
+        self.preview_mode = preview_mode
         if self.config.render_video:
+            # Apply preview mode scaling if needed
+            if self.preview_mode:
+                # Scale down from 4K (2160p) to 360p - factor of 1/6
+                scale_factor = 1 / 6
+
+                # Scale down top padding for preview if it exists
+                if "karaoke" in self.config.styles and "top_padding" in self.config.styles["karaoke"]:
+                    self.logger.info(f"Preview mode: Found top_padding: {self.config.styles['karaoke']['top_padding']}")
+                    original_padding = self.config.styles["karaoke"]["top_padding"]
+                    if original_padding is not None:
+                        # Scale down from 4K (2160p) to 360p - factor of 1/6
+                        self.config.styles["karaoke"]["top_padding"] = original_padding * scale_factor
+                        self.logger.info(f"Preview mode: Scaled down top_padding to: {self.config.styles['karaoke']['top_padding']}")
+
+                # Scale down font size for preview if it exists
+                if "karaoke" in self.config.styles and "font_size" in self.config.styles["karaoke"]:
+                    self.logger.info(f"Preview mode: Found font_size: {self.config.styles['karaoke']['font_size']}")
+                    original_font_size = self.config.styles["karaoke"]["font_size"]
+                    if original_font_size is not None:
+                        # Scale down from 4K (2160p) to 360p - factor of 1/6
+                        self.font_size = original_font_size * scale_factor
+                        self.config.styles["karaoke"]["font_size"] = self.font_size
+                        self.logger.info(f"Preview mode: Scaled down font_size to: {self.font_size}")
+
+            # Initialize subtitle generator with potentially scaled values
             self.subtitle = SubtitlesGenerator(
                 output_dir=self.config.output_dir,
                 video_resolution=self.video_resolution_num,
@@ -102,7 +131,6 @@ class OutputGenerator:
         audio_filepath: str,
         artist: Optional[str] = None,
         title: Optional[str] = None,
-        preview_mode: bool = False,
     ) -> OutputPaths:
         """Generate all requested output formats."""
         outputs = OutputPaths()
@@ -116,7 +144,7 @@ class OutputGenerator:
                 transcription_corrected.resized_segments = resized_segments
 
                 # For preview, we only need to generate ASS and video
-                if preview_mode:
+                if self.preview_mode:
                     # Generate ASS subtitles for preview
                     outputs.ass = self.subtitle.generate_ass(transcription_corrected.resized_segments, output_prefix, audio_filepath)