Audio and Video Processing Guide¶

brew install ffmpeg

sudo apt update
sudo apt install ffmpeg

choco install ffmpeg

pip install -e ".[audio]"

python -c "from faster_whisper import WhisperModel; print('✓ Audio transcription ready')"

fo organize ~/Downloads ~/Organized --transcribe-audio

fo organize ~/Downloads ~/Organized --transcribe-audio --whisper-model small

fo organize ~/Downloads ~/Organized --transcribe-audio --max-transcribe-seconds 1800

from file_organizer.models.audio_model import AudioModel

model = AudioModel(AudioModel.get_default_config("whisper:base"))
model.initialize()
try:
    result = model.transcribe("meeting.m4a")
    print(result.text, result.language)
    text = model.generate("meeting.m4a")
finally:
    model.safe_cleanup()

from pathlib import Path
from file_organizer.services.audio.transcriber import AudioTranscriber, ModelSize, ComputeType

transcriber = AudioTranscriber(
    model_size=ModelSize.SMALL,
    compute_type=ComputeType.FLOAT16,
    device="cuda"
)

audio_file = Path("~/Downloads/podcast-episode.mp3")
result = transcriber.transcribe(audio_file)

print(f"Language: {result.language}")
print(f"Duration: {result.duration:.1f} seconds")
print(f"Text: {result.text}")

for segment in result.segments:
    print(f"[{segment.start:.2f}s - {segment.end:.2f}s] {segment.text}")

from file_organizer.services.audio.transcriber import (
    AudioTranscriber,
    TranscriptionOptions,
    ModelSize,
    ComputeType
)

options = TranscriptionOptions(
    language="en",
    word_timestamps=True,
    beam_size=5,
    best_of=5,
    temperature=0.0,
    vad_filter=True,
    initial_prompt="This is a technical podcast."
)

transcriber = AudioTranscriber(
    model_size=ModelSize.MEDIUM,
    compute_type=ComputeType.INT8_FLOAT16
)

result = transcriber.transcribe("interview.wav", options=options)

for segment in result.segments:
    if segment.words:
        for word in segment.words:
            print(f"{word.word} [{word.start:.2f}s]")

result = transcriber.transcribe("audio.mp3")
print(f"Detected: {result.language}")

options = TranscriptionOptions(language="es")
result = transcriber.transcribe_with_options("audio.mp3", options)

from file_organizer.core.types import AUDIO_EXTENSIONS

file_path = "my-file.mp3"
is_supported = any(file_path.endswith(ext) for ext in AUDIO_EXTENSIONS)
print(f"Supported: {is_supported}")

import torch

print(f"CUDA available: {torch.cuda.is_available()}")

transcriber = AudioTranscriber(
    model_size=ModelSize.SMALL,
    compute_type=ComputeType.FLOAT16,
    device="cuda",
    num_workers=4
)

transcriber = AudioTranscriber(
    model_size=ModelSize.TINY,
    compute_type=ComputeType.INT8,
    device="cpu",
    num_workers=1
)

from pathlib import Path

audio_files = list(Path("~/Podcasts").glob("*.mp3"))

for audio_file in audio_files:
    try:
        result = transcriber.transcribe(audio_file)
        output_file = audio_file.with_suffix(".txt")
        output_file.write_text(result.text)
        print(f"✓ {audio_file.name}: {result.language}")
    except Exception as e:
        print(f"✗ {audio_file.name}: {e}")

from file_organizer.services.audio.organizer import AudioOrganizer
from file_organizer.services.audio.classifier import AudioClassifier
from file_organizer.services.audio.metadata_extractor import AudioMetadataExtractor

metadata_extractor = AudioMetadataExtractor()
metadata = metadata_extractor.extract("podcast.mp3")

transcriber = AudioTranscriber(model_size=ModelSize.SMALL)
transcription = transcriber.transcribe("podcast.mp3")

classifier = AudioClassifier()
classification = classifier.classify(
    metadata=metadata,
    transcription=transcription
)

print(f"Type: {classification.audio_type}")

organizer = AudioOrganizer()
plan = organizer.preview_organization(
    files=[(Path("podcast.mp3"), classification.audio_type, metadata)],
    base_path=Path("~/Audio").expanduser(),
)
print(f"Planned moves: {len(plan.planned_moves)}")

file-organizer tui

ffmpeg -version

RuntimeError: CUDA out of memory

transcriber = AudioTranscriber(model_size=ModelSize.TINY)
transcriber = AudioTranscriber(compute_type=ComputeType.INT8)
transcriber = AudioTranscriber(device="cpu")

audio:
  transcription:
    enabled: true
    model_size: small
    compute_type: float16
    device: cuda
    language: null
    word_timestamps: false
    vad_filter: true
    beam_size: 5
    best_of: 5
    temperature: 0.0

brew install ffmpeg

sudo apt update
sudo apt install ffmpeg

choco install ffmpeg

pip install -e ".[video]"

python -c "import cv2; import scenedetect; print('✓ Video analysis ready')"

from pathlib import Path
from file_organizer.services.video.scene_detector import SceneDetector, DetectionMethod

detector = SceneDetector(
    method=DetectionMethod.CONTENT,
    threshold=27.0,
    min_scene_length=1.0
)

video_file = Path("~/Videos/movie.mp4")
result = detector.detect_scenes(video_file)

print(f"Video: {result.video_path.name}")
print(f"Duration: {result.total_duration:.1f} seconds")
print(f"Detected {len(result.scenes)} scenes")

for scene in result.scenes:
    print(f"Scene {scene.scene_number}: {scene.start_time:.2f}s - {scene.end_time:.2f}s")

from file_organizer.services.video.scene_detector import SceneDetector, DetectionMethod

detector = SceneDetector(
    method=DetectionMethod.ADAPTIVE,
    threshold=15.0,
    min_scene_length=0.5
)

result = detector.detect_scenes("interview.mp4")

from pathlib import Path
from file_organizer.services.video.scene_detector import SceneDetector

detector = SceneDetector()
result = detector.detect_scenes("video.mp4")

output_dir = Path("~/Videos/thumbnails")
SceneDetector.extract_scene_thumbnails(
    video_path="video.mp4",
    result=result,
    output_dir=output_dir,
    frame_offset=0.5
)

from file_organizer.services.video.scene_detector import SceneDetector

detector = SceneDetector()
result = detector.detect_scenes("video.mp4")

SceneDetector.save_scene_list(result, "scenes.csv")

from pathlib import Path
from file_organizer.services.video.metadata_extractor import VideoMetadataExtractor

extractor = VideoMetadataExtractor()
video_file = Path("~/Videos/movie.mp4")
metadata = extractor.extract(video_file)

print(f"File: {metadata.file_path.name}")
print(f"Format: {metadata.format}")
print(f"Duration: {metadata.duration:.1f} seconds")
print(f"Resolution: {metadata.width}x{metadata.height}")

from file_organizer.services.video.metadata_extractor import resolution_label

label = resolution_label(1920, 1080)
print(label)

label = resolution_label(3840, 2160)
print(label)

from pathlib import Path
from file_organizer.services.video.scene_detector import SceneDetector

detector = SceneDetector()
video_files = list(Path("~/Videos").glob("*.mp4"))

results = detector.detect_scenes_batch(video_files)

for result in results:
    output_csv = result.video_path.with_suffix(".scenes.csv")
    SceneDetector.save_scene_list(result, output_csv)

from pathlib import Path
from file_organizer.services.video.organizer import VideoOrganizer
from file_organizer.services.video.scene_detector import SceneDetector
from file_organizer.services.video.metadata_extractor import VideoMetadataExtractor

detector = SceneDetector()
scene_result = detector.detect_scenes("video.mp4")

if len(scene_result.scenes) > 50:
    category = "long-form"
elif scene_result.total_duration < 60:
    category = "short-clips"
else:
    category = "standard"

print(f"Category: {category}")

from file_organizer.services.video.organizer import is_screen_recording

if is_screen_recording("Screen Recording 2025-01-15 at 3.45.22 PM.mp4"):
    print("Screen recording detected")

pip install opencv-python>=4.8.0

pip install scenedetect[opencv]>=0.6.0

detector = SceneDetector(
    method=DetectionMethod.THRESHOLD,
    threshold=30.0
)

from file_organizer.services.video.metadata_extractor import VideoMetadataExtractor
extractor = VideoMetadataExtractor()
metadata = extractor.extract("video.mp4")

detector = SceneDetector(
    method=DetectionMethod.ADAPTIVE,
    min_scene_length=0.5
)

video:
  scene_detection:
    enabled: true
    method: content
    threshold: 27.0
    min_scene_length: 1.0
  metadata:
    use_ffprobe: true
    extract_thumbnails: false
  organization:
    detect_screen_recordings: true
    short_clip_threshold: 60.0

python3 --version
ffmpeg -version
pip --version

python -c "from faster_whisper import WhisperModel; print('✓ faster-whisper installed')"
python -c "import torch; print('✓ PyTorch installed')"
python -c "import mutagen; import tinytag; print('✓ Audio metadata libraries installed')"

cat > test_audio.py << 'EOF'
from file_organizer.services.audio.transcriber import AudioTranscriber, ModelSize, ComputeType
from pathlib import Path
import sys

try:
    transcriber = AudioTranscriber(
        model_size=ModelSize.TINY,
        compute_type=ComputeType.INT8,
        device="cpu"
    )
    print("✓ Transcriber initialized successfully")
except Exception as e:
    print(f"✗ Error: {e}")
EOF

python test_audio.py

cat > test_audio_metadata.py << 'EOF'
from file_organizer.services.audio.metadata_extractor import AudioMetadataExtractor
from pathlib import Path
import sys

if len(sys.argv) < 2:
    print("Usage: python test_audio_metadata.py <audio_file>")
    sys.exit(0)

try:
    extractor = AudioMetadataExtractor()
    audio_file = Path(sys.argv[1])
    metadata = extractor.extract(audio_file)
    print("✓ Metadata extraction successful")
except Exception as e:
    print(f"✗ Error: {e}")
EOF

python -c "import cv2; print('✓ OpenCV installed')"
python -c "import scenedetect; print('✓ PySceneDetect installed')"

cat > test_video.py << 'EOF'
from file_organizer.services.video.scene_detector import SceneDetector, DetectionMethod

try:
    detector = SceneDetector(
        method=DetectionMethod.CONTENT,
        threshold=27.0
    )
    print("✓ Scene detector initialized successfully")
except Exception as e:
    print(f"✗ Error: {e}")
EOF

python test_video.py

cat > test_video_metadata.py << 'EOF'
from file_organizer.services.video.metadata_extractor import VideoMetadataExtractor
from pathlib import Path
import sys

if len(sys.argv) < 2:
    print("Usage: python test_video_metadata.py <video_file>")
    sys.exit(0)

try:
    extractor = VideoMetadataExtractor()
    video_file = Path(sys.argv[1])
    metadata = extractor.extract(video_file)
    print("✓ Metadata extraction successful")
except Exception as e:
    print(f"✗ Error: {e}")
EOF

rm -f test_audio.py test_audio_metadata.py test_video.py test_video_metadata.py test_integration.py