321 lines
9.4 KiB
Python
321 lines
9.4 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Process meeting recordings to extract audio + screen content.
|
|
Combines Whisper transcripts with OCR from screen shares.
|
|
"""
|
|
import argparse
|
|
from pathlib import Path
|
|
import sys
|
|
import json
|
|
import logging
|
|
import subprocess
|
|
import shutil
|
|
|
|
from meetus.frame_extractor import FrameExtractor
|
|
from meetus.ocr_processor import OCRProcessor
|
|
from meetus.transcript_merger import TranscriptMerger
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def setup_logging(verbose: bool = False):
|
|
"""
|
|
Configure logging for the application.
|
|
|
|
Args:
|
|
verbose: If True, set DEBUG level, otherwise INFO
|
|
"""
|
|
level = logging.DEBUG if verbose else logging.INFO
|
|
|
|
# Configure root logger
|
|
logging.basicConfig(
|
|
level=level,
|
|
format='%(asctime)s - %(levelname)s - %(message)s',
|
|
datefmt='%H:%M:%S'
|
|
)
|
|
|
|
# Suppress verbose output from libraries
|
|
logging.getLogger('PIL').setLevel(logging.WARNING)
|
|
logging.getLogger('easyocr').setLevel(logging.WARNING)
|
|
logging.getLogger('paddleocr').setLevel(logging.WARNING)
|
|
|
|
|
|
def run_whisper(video_path: Path, model: str = "base", output_dir: str = "output") -> Path:
|
|
"""
|
|
Run Whisper transcription on video file.
|
|
|
|
Args:
|
|
video_path: Path to video file
|
|
model: Whisper model to use (tiny, base, small, medium, large)
|
|
output_dir: Directory to save output
|
|
|
|
Returns:
|
|
Path to generated JSON transcript
|
|
"""
|
|
# Check if whisper is installed
|
|
if not shutil.which("whisper"):
|
|
logger.error("Whisper is not installed. Install it with: pip install openai-whisper")
|
|
sys.exit(1)
|
|
|
|
logger.info(f"Running Whisper transcription (model: {model})...")
|
|
logger.info("This may take a few minutes depending on video length...")
|
|
|
|
# Run whisper command
|
|
cmd = [
|
|
"whisper",
|
|
str(video_path),
|
|
"--model", model,
|
|
"--output_format", "json",
|
|
"--output_dir", output_dir
|
|
]
|
|
|
|
try:
|
|
result = subprocess.run(
|
|
cmd,
|
|
check=True,
|
|
capture_output=True,
|
|
text=True
|
|
)
|
|
|
|
# Whisper outputs to <output_dir>/<video_stem>.json
|
|
transcript_path = Path(output_dir) / f"{video_path.stem}.json"
|
|
|
|
if transcript_path.exists():
|
|
logger.info(f"✓ Whisper transcription completed: {transcript_path}")
|
|
return transcript_path
|
|
else:
|
|
logger.error("Whisper completed but transcript file not found")
|
|
sys.exit(1)
|
|
|
|
except subprocess.CalledProcessError as e:
|
|
logger.error(f"Whisper failed: {e.stderr}")
|
|
sys.exit(1)
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(
|
|
description="Extract screen content from meeting recordings and merge with transcripts",
|
|
formatter_class=argparse.RawDescriptionHelpFormatter,
|
|
epilog="""
|
|
Examples:
|
|
# Run Whisper + full processing in one command
|
|
python process_meeting.py samples/meeting.mkv --run-whisper
|
|
|
|
# Process video with existing Whisper transcript
|
|
python process_meeting.py samples/meeting.mkv --transcript output/meeting.json
|
|
|
|
# Use scene detection instead of interval
|
|
python process_meeting.py samples/meeting.mkv --run-whisper --scene-detection
|
|
|
|
# Use different Whisper model and OCR engine
|
|
python process_meeting.py samples/meeting.mkv --run-whisper --whisper-model small --ocr-engine easyocr
|
|
|
|
# Extract frames only (no transcript)
|
|
python process_meeting.py samples/meeting.mkv --extract-only
|
|
"""
|
|
)
|
|
|
|
parser.add_argument(
|
|
'video',
|
|
help='Path to video file'
|
|
)
|
|
|
|
parser.add_argument(
|
|
'--transcript', '-t',
|
|
help='Path to Whisper transcript (JSON or TXT)',
|
|
default=None
|
|
)
|
|
|
|
parser.add_argument(
|
|
'--run-whisper',
|
|
action='store_true',
|
|
help='Run Whisper transcription before processing'
|
|
)
|
|
|
|
parser.add_argument(
|
|
'--whisper-model',
|
|
choices=['tiny', 'base', 'small', 'medium', 'large'],
|
|
help='Whisper model to use (default: base)',
|
|
default='base'
|
|
)
|
|
|
|
parser.add_argument(
|
|
'--output', '-o',
|
|
help='Output file for enhanced transcript (default: output/<video>_enhanced.txt)',
|
|
default=None
|
|
)
|
|
|
|
parser.add_argument(
|
|
'--output-dir',
|
|
help='Directory for output files (default: output/)',
|
|
default='output'
|
|
)
|
|
|
|
parser.add_argument(
|
|
'--frames-dir',
|
|
help='Directory to save extracted frames (default: frames/)',
|
|
default='frames'
|
|
)
|
|
|
|
parser.add_argument(
|
|
'--interval',
|
|
type=int,
|
|
help='Extract frame every N seconds (default: 5)',
|
|
default=5
|
|
)
|
|
|
|
parser.add_argument(
|
|
'--scene-detection',
|
|
action='store_true',
|
|
help='Use scene detection instead of interval extraction'
|
|
)
|
|
|
|
parser.add_argument(
|
|
'--ocr-engine',
|
|
choices=['tesseract', 'easyocr', 'paddleocr'],
|
|
help='OCR engine to use (default: tesseract)',
|
|
default='tesseract'
|
|
)
|
|
|
|
parser.add_argument(
|
|
'--no-deduplicate',
|
|
action='store_true',
|
|
help='Disable text deduplication'
|
|
)
|
|
|
|
parser.add_argument(
|
|
'--extract-only',
|
|
action='store_true',
|
|
help='Only extract frames and OCR, skip transcript merging'
|
|
)
|
|
|
|
parser.add_argument(
|
|
'--format',
|
|
choices=['detailed', 'compact'],
|
|
help='Output format style (default: detailed)',
|
|
default='detailed'
|
|
)
|
|
|
|
parser.add_argument(
|
|
'--verbose', '-v',
|
|
action='store_true',
|
|
help='Enable verbose logging (DEBUG level)'
|
|
)
|
|
|
|
args = parser.parse_args()
|
|
|
|
# Setup logging
|
|
setup_logging(args.verbose)
|
|
|
|
# Validate video path
|
|
video_path = Path(args.video)
|
|
if not video_path.exists():
|
|
logger.error(f"Video file not found: {args.video}")
|
|
sys.exit(1)
|
|
|
|
# Create output directory
|
|
output_dir = Path(args.output_dir)
|
|
output_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
# Set default output path
|
|
if args.output is None:
|
|
args.output = str(output_dir / f"{video_path.stem}_enhanced.txt")
|
|
|
|
# Run Whisper if requested
|
|
if args.run_whisper:
|
|
logger.info("=" * 80)
|
|
logger.info("STEP 0: Running Whisper Transcription")
|
|
logger.info("=" * 80)
|
|
transcript_path = run_whisper(video_path, args.whisper_model, str(output_dir))
|
|
args.transcript = str(transcript_path)
|
|
logger.info("")
|
|
|
|
logger.info("=" * 80)
|
|
logger.info("MEETING PROCESSOR")
|
|
logger.info("=" * 80)
|
|
logger.info(f"Video: {video_path.name}")
|
|
logger.info(f"OCR Engine: {args.ocr_engine}")
|
|
logger.info(f"Frame extraction: {'Scene detection' if args.scene_detection else f'Every {args.interval}s'}")
|
|
if args.transcript:
|
|
logger.info(f"Transcript: {args.transcript}")
|
|
logger.info("=" * 80)
|
|
|
|
# Step 1: Extract frames
|
|
logger.info("Step 1: Extracting frames from video...")
|
|
extractor = FrameExtractor(str(video_path), args.frames_dir)
|
|
|
|
if args.scene_detection:
|
|
frames_info = extractor.extract_scene_changes()
|
|
else:
|
|
frames_info = extractor.extract_by_interval(args.interval)
|
|
|
|
if not frames_info:
|
|
logger.error("No frames extracted")
|
|
sys.exit(1)
|
|
|
|
logger.info(f"✓ Extracted {len(frames_info)} frames")
|
|
|
|
# Step 2: Run OCR on frames
|
|
logger.info("Step 2: Running OCR on extracted frames...")
|
|
try:
|
|
ocr = OCRProcessor(engine=args.ocr_engine)
|
|
screen_segments = ocr.process_frames(
|
|
frames_info,
|
|
deduplicate=not args.no_deduplicate
|
|
)
|
|
logger.info(f"✓ Processed {len(screen_segments)} frames with text content")
|
|
|
|
except ImportError as e:
|
|
logger.error(f"{e}")
|
|
logger.error(f"To install {args.ocr_engine}:")
|
|
logger.error(f" pip install {args.ocr_engine}")
|
|
sys.exit(1)
|
|
|
|
# Save OCR results as JSON
|
|
ocr_output = output_dir / f"{video_path.stem}_ocr.json"
|
|
with open(ocr_output, 'w', encoding='utf-8') as f:
|
|
json.dump(screen_segments, f, indent=2, ensure_ascii=False)
|
|
logger.info(f"✓ Saved OCR results to: {ocr_output}")
|
|
|
|
if args.extract_only:
|
|
logger.info("Done! (extract-only mode)")
|
|
return
|
|
|
|
# Step 3: Merge with transcript (if provided)
|
|
merger = TranscriptMerger()
|
|
|
|
if args.transcript:
|
|
logger.info("Step 3: Merging with Whisper transcript...")
|
|
transcript_path = Path(args.transcript)
|
|
|
|
if not transcript_path.exists():
|
|
logger.warning(f"Transcript not found: {args.transcript}")
|
|
logger.info("Proceeding with screen content only...")
|
|
audio_segments = []
|
|
else:
|
|
audio_segments = merger.load_whisper_transcript(str(transcript_path))
|
|
logger.info(f"✓ Loaded {len(audio_segments)} audio segments")
|
|
else:
|
|
logger.info("No transcript provided, using screen content only...")
|
|
audio_segments = []
|
|
|
|
# Merge and format
|
|
merged = merger.merge_transcripts(audio_segments, screen_segments)
|
|
formatted = merger.format_for_claude(merged, format_style=args.format)
|
|
|
|
# Save output
|
|
merger.save_transcript(formatted, args.output)
|
|
|
|
logger.info("=" * 80)
|
|
logger.info("✓ PROCESSING COMPLETE!")
|
|
logger.info("=" * 80)
|
|
logger.info(f"Enhanced transcript: {args.output}")
|
|
logger.info(f"OCR data: {ocr_output}")
|
|
logger.info(f"Frames: {args.frames_dir}/")
|
|
logger.info("")
|
|
logger.info("You can now use the enhanced transcript with Claude for summarization!")
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|