1# Windows (using chocolatey)
 2choco install ffmpeg
 3
 4# macOS (using homebrew)
 5brew install ffmpeg
 6
 7# Ubuntu/Debian
 8sudo apt update
 9sudo apt install ffmpeg
10
11# Verify installation
12ffmpeg -version

1# Install via pip
2pip install openai-whisper
3
4# Or install the latest development version
5pip install git+https://github.com/openai/whisper.git
6
7# Verify installation
8whisper --help

 1# Basic transcription
 2whisper audio_file.mp3
 3
 4# Specify output format
 5whisper video_file.mp4 --output_format txt
 6
 7# Choose model size (tiny, base, small, medium, large)
 8whisper audio_file.wav --model medium
 9
10# Specify language (optional, auto-detected by default)
11whisper audio_file.mp3 --language Thai

1# Extract audio as WAV (recommended for Whisper)
2ffmpeg -i input_video.mp4 -vn -acodec pcm_s16le -ar 16000 -ac 1 audio_output.wav
3
4# Extract audio as MP3
5ffmpeg -i input_video.mkv -vn -acodec mp3 -ab 128k audio_output.mp3
6
7# Extract specific time range
8ffmpeg -i input.mp4 -ss 00:01:30 -t 00:02:00 -vn -acodec pcm_s16le audio_segment.wav

1# Basic transcription
2whisper audio_output.wav
3
4# Generate multiple formats simultaneously
5whisper audio_output.wav --output_format txt,srt,vtt,json
6
7# Use specific model and language
8whisper audio_output.wav --model large --language en --output_format srt

1# Generate SRT subtitles
2whisper video.mp4 --output_format srt
3
4# Generate multiple formats
5whisper audio.wav --output_format txt,srt,vtt,json
6
7# Custom output directory
8whisper audio.mp3 --output_dir ./transcriptions --output_format srt

1# Normalize audio levels
2ffmpeg -i input.mp4 -af "dynaudnorm" -acodec pcm_s16le normalized_audio.wav
3
4# Remove background noise (basic)
5ffmpeg -i input.mp4 -af "highpass=f=200,lowpass=f=3000" filtered_audio.wav
6
7# Boost volume
8ffmpeg -i input.mp4 -af "volume=2.0" louder_audio.wav

1# List audio streams
2ffmpeg -i input.mkv
3
4# Extract specific audio track (e.g., track 1)
5ffmpeg -i input.mkv -map 0:a:1 -vn audio_track2.wav
6
7# Mix multiple audio tracks
8ffmpeg -i input.mkv -af "amix=inputs=2" mixed_audio.wav

 1# Process multiple files (bash)
 2for file in *.mp4; do
 3    ffmpeg -i "$file" -vn -acodec pcm_s16le "${file%.*}.wav"
 4    whisper "${file%.*}.wav" --output_format srt
 5done
 6
 7# Windows batch processing
 8for %f in (*.mp4) do (
 9    ffmpeg -i "%f" -vn -acodec pcm_s16le "%~nf.wav"
10    whisper "%~nf.wav" --output_format srt
11)

 1# Fast transcription (lower accuracy)
 2whisper audio.wav --model tiny
 3
 4# Balanced speed/accuracy
 5whisper audio.wav --model base
 6
 7# High accuracy (slower)
 8whisper audio.wav --model large
 9
10# English-only models (slightly better for English)
11whisper audio.wav --model base.en

1# Download with yt-dlp, extract audio, transcribe
2yt-dlp -x --audio-format mp3 "https://youtube.com/watch?v=VIDEO_ID"
3whisper "VIDEO_TITLE.mp3" --output_format srt
4
5# Or direct processing if file is compatible
6whisper "$(yt-dlp --get-filename -x --audio-format mp3 'VIDEO_URL')" --output_format srt

1# Extract and normalize audio
2ffmpeg -i podcast_episode.mp3 -af "dynaudnorm" -ar 16000 normalized_podcast.wav
3
4# Transcribe with timestamps
5whisper normalized_podcast.wav --output_format json,srt --model medium

1# Extract audio from meeting recording
2ffmpeg -i meeting_recording.mp4 -vn -ar 16000 -ac 1 meeting_audio.wav
3
4# Transcribe with word-level timestamps
5whisper meeting_audio.wav --output_format json --model base --word_timestamps True

1# Auto-detect language
2whisper foreign_audio.mp3 --model medium --output_format srt
3
4# Specify language for better accuracy
5whisper thai_audio.mp3 --language Thai --model medium --output_format srt
6
7# Translate to English while transcribing
8whisper foreign_audio.mp3 --task translate --output_format srt

1# Use GPU acceleration (if available)
2whisper audio.wav --device cuda
3
4# Specify number of CPU threads
5whisper audio.wav --threads 4
6
7# Use faster models for real-time processing
8whisper audio.wav --model tiny.en --fp16 False

1# Improve accuracy with audio preprocessing
2ffmpeg -i noisy_audio.mp3 -af "highpass=f=80,lowpass=f=8000,dynaudnorm" clean_audio.wav
3whisper clean_audio.wav --model large --temperature 0
4
5# Use temperature for consistency
6whisper audio.wav --temperature 0 --best_of 5

1# Convert unsupported formats
2ffmpeg -i input.webm -acodec pcm_s16le -ar 16000 output.wav
3ffmpeg -i input.flac -acodec mp3 output.mp3

1# Use smaller model
2whisper large_file.wav --model tiny
3
4# Process in segments
5ffmpeg -i large_file.mp4 -f segment -segment_time 300 -vn segment_%03d.wav

1# Try different models
2whisper audio.wav --model medium  # vs base or large
3
4# Specify language explicitly
5whisper audio.wav --language en
6
7# Adjust audio quality
8ffmpeg -i input.mp3 -af "volume=2.0,highpass=f=100" enhanced.wav

1# Use initial prompt for context
2whisper audio.wav --initial_prompt "This is a technical discussion about machine learning"
3
4# For names and technical terms
5whisper audio.wav --initial_prompt "Speakers: Peerasan Buranasanti. Topic: Media Streaming"

1# Suppress non-speech tokens
2whisper audio.wav --suppress_tokens "50257"
3
4# No speech threshold (adjust for silence detection)
5whisper audio.wav --no_speech_threshold 0.6
6
7# Compression ratio threshold
8whisper audio.wav --compression_ratio_threshold 2.4

1# Generate subtitle file for video editing
2whisper video.mp4 --output_format srt --model medium
3
4# Burn subtitles directly into video
5whisper video.mp4 --output_format srt
6ffmpeg -i video.mp4 -vf "subtitles=th-video.srt" video_with_subs.mp4

 1#!/bin/bash
 2# conference_transcription.sh
 3
 4INPUT_FILE="$1"
 5OUTPUT_NAME="${INPUT_FILE%.*}"
 6
 7echo "Processing: $INPUT_FILE"
 8
 9# Step 1: Extract and optimize audio
10ffmpeg -i "$INPUT_FILE" \
11    -vn \
12    -af "dynaudnorm,highpass=f=80,lowpass=f=8000" \
13    -ar 16000 \
14    -ac 1 \
15    "${OUTPUT_NAME}_processed.wav"
16
17# Step 2: Transcribe with Whisper
18whisper "${OUTPUT_NAME}_processed.wav" \
19    --model medium \
20    --output_format txt,srt,json \
21    --language Thai \
22    --initial_prompt "This is a technical conference presentation"
23
24# Step 3: Clean up
25rm "${OUTPUT_NAME}_processed.wav"
26
27echo "Transcription complete: ${OUTPUT_NAME}.txt, ${OUTPUT_NAME}.srt"

 1#!/bin/bash
 2# multilingual_transcription.sh
 3
 4INPUT_FILE="$1"
 5
 6# Extract audio
 7ffmpeg -i "$INPUT_FILE" -vn -ar 16000 temp_audio.wav
 8
 9# Detect language and transcribe
10whisper temp_audio.wav --model medium --output_format json
11
12# Also create English translation
13whisper temp_audio.wav --task translate --output_format srt --model medium
14
15# Clean up
16rm temp_audio.wav

1project/
2├── original_files/
3├── processed_audio/
4├── transcriptions/
5│   ├── txt/
6│   ├── srt/
7│   └── json/
8└── scripts/

1# Extract best quality audio
2ffmpeg -i input.mkv -q:a 0 -map a output.mp3
3
4# Convert to Whisper-optimal format
5ffmpeg -i input.mp4 -vn -ar 16000 -ac 1 -c:a pcm_s16le output.wav
6
7# Extract audio from specific timeframe
8ffmpeg -i input.mp4 -ss 00:10:00 -to 00:20:00 -vn output.wav

1# Normalize and filter
2ffmpeg -i input.mp3 -af "dynaudnorm=f=75:g=25,highpass=f=80,lowpass=f=8000" clean.wav
3
4# Reduce noise (basic)
5ffmpeg -i noisy.wav -af "afftdn" denoised.wav

1# Time the transcription
2time whisper audio.wav --model base
3
4# Monitor GPU usage (if using CUDA)
5nvidia-smi

 1#!/bin/bash
 2total_files=$(ls *.mp4 | wc -l)
 3current=0
 4
 5for file in *.mp4; do
 6    ((current++))
 7    echo "Processing file $current of $total_files: $file"
 8    
 9    ffmpeg -i "$file" -vn -ar 16000 temp.wav
10    whisper temp.wav --output_format srt --model base
11    rm temp.wav
12    
13    echo "Completed: ${file%.*}.srt"
14done

 1# Python automation example
 2import subprocess
 3import os
 4
 5def process_video(input_path, model="base"):
 6    # Extract audio
 7    audio_path = f"{os.path.splitext(input_path)[0]}.wav"
 8    subprocess.run([
 9        "ffmpeg", "-i", input_path, "-vn", 
10        "-ar", "16000", "-ac", "1", audio_path
11    ])
12    
13    # Transcribe
14    subprocess.run([
15        "whisper", audio_path, "--model", model, 
16        "--output_format", "srt,txt"
17    ])
18    
19    # Clean up
20    os.remove(audio_path)

1# Check audio properties
2ffprobe -v quiet -show_format -show_streams input.mp4
3
4# Test with sample
5ffmpeg -i input.mp4 -t 30 -vn sample.wav
6whisper sample.wav --model base

 1# Basic transcription
 2whisper file.mp4
 3
 4# High-quality subtitles
 5whisper file.mp4 --model large --output_format srt
 6
 7# Extract audio + transcribe
 8ffmpeg -i video.mp4 -vn audio.wav && whisper audio.wav --output_format srt
 9
10# Batch process current directory
11for f in *.mp4; do whisper "$f" --output_format srt; done
12
13# Foreign language with translation
14whisper foreign.mp3 --task translate --output_format srt

1# Optimize for speech recognition
2ffmpeg -i input.mp4 -af "dynaudnorm,highpass=f=80,lowpass=f=8000" -ar 16000 -ac 1 optimized.wav
3
4# Split long audio into segments
5ffmpeg -i long_audio.mp3 -f segment -segment_time 600 -c copy segment_%03d.mp3
6
7# Merge multiple audio files
8ffmpeg -f concat -safe 0 -i filelist.txt -c copy merged.mp3