Python, OpenAI Whisper ve FFmpeg Kullanarak Videolara Otomatik Altyazı Ekleme: Kapsamlı Bir Rehber

Python, OpenAI Whisper ve FFmpeg Kullanarak Videolara Otomatik Altyazı Ekleme: Kapsamlı Bir Rehber

Giriş: Neden Otomatik Altyazı?

Günümüzün dijital çağında video içeriği, bilgi aktarımının, eğlencenin ve iletişimin temel taşlarından biri haline gelmiştir. YouTube, TikTok, eğitim platformları ve kurumsal sunumlar gibi çeşitli alanlarda videoların önemi her geçen gün artmaktadır. Bu videoların erişilebilirliğini, etkileşimini ve küresel erişimini artırmanın en etkili yollarından biri ise altyazı eklemektir.

Altyazılar sadece işitme engelli bireyler için bir zorunluluk olmakla kalmaz, aynı zamanda gürültülü ortamlarda video izleyenler, farklı dilleri konuşan izleyiciler ve hatta içeriği daha iyi anlamak isteyen herkes için büyük kolaylık sağlar. Ayrıca, arama motoru optimizasyonu (SEO) açısından da altyazılar, video içeriğinin metin olarak taranabilmesini sağlayarak keşfedilebilirliğini artırır.

Geleneksel olarak altyazı oluşturma süreci oldukça zahmetli ve zaman alıcıydı. Videoyu manuel olarak dinleyip, her kelimeyi yazıp, zaman damgalarını ayarlamak büyük bir emek gerektiriyordu. Ancak yapay zeka ve güçlü medya işleme araçlarının gelişimiyle birlikte bu süreç artık otomatikleştirilebilir ve çok daha verimli hale getirilebilir.

Bu teknik makalede, Python programlama dilinin esnekliğini, OpenAI’ın son teknoloji ürünü konuşmadan metne (Speech-to-Text) dönüştürme modeli Whisper’ın gücünü ve medya işleme konusunda endüstri standardı olan FFmpeg’in yeteneklerini birleştirerek videolara nasıl otomatik altyazı oluşturulacağını ve ekleneceğini adım adım inceleyeceğiz. Amacımız, bu üç güçlü aracı kullanarak karmaşık görünen bu süreci anlaşılır ve uygulanabilir bir rehbere dönüştürmektir.

Bölüm 1: Kullanacağımız Araçları Tanıyalım

Bu projenin temelini oluşturan üç ana bileşeni derinlemesine anlayarak işe başlayalım. Her bir aracın ne işe yaradığını, neden tercih edildiğini ve projemizdeki rolünü kavrayalım.

Python: Esnek ve Güçlü Bir Programlama Dili

Python, basit sözdizimi, geniş kütüphane ekosistemi ve farklı platformlarda çalışabilme yeteneği sayesinde veri bilimi, yapay zeka, web geliştirme ve otomasyon gibi birçok alanda popülerliğini koruyan çok yönlü bir programlama dilidir. Projemizde Python’ı tercih etmemizin başlıca nedenleri şunlardır:

• Kolay Öğrenilebilirlik ve Okunabilirlik: Python’ın temiz ve sezgisel sözdizimi, karmaşık görevleri bile anlaşılır kodlarla ifade etmeyi kolaylaştırır.
• Geniş Kütüphane Desteği: Whisper API’sini kullanmak, dosya işlemleri yapmak ve FFmpeg komutlarını çalıştırmak için zengin kütüphane seçenekleri sunar (örneğin, openai, ffmpeg-python, subprocess).
• Otomasyon Yeteneği: Video işleme ve altyazı oluşturma adımlarını bir araya getiren bir otomasyon betiği yazmak için ideal bir dildir.
• Platform Bağımsızlığı: Yazdığımız kodun Windows, macOS veya Linux gibi farklı işletim sistemlerinde sorunsuz çalışmasını sağlar.

Projemizde Python, tüm iş akışını yönetecek, Whisper modelini çağıracak, FFmpeg komutlarını tetikleyecek ve dosya işlemlerini koordine edecek orkestratör görevi görecektir.

OpenAI Whisper: Devrim Niteliğinde Konuşmadan Metne Dönüştürme Modeli

OpenAI tarafından geliştirilen Whisper, insan konuşmasını metne dönüştürme (Automatic Speech Recognition – ASR) konusunda çığır açan bir yapay zeka modelidir. Geniş ve çeşitli bir veri kümesi üzerinde eğitilmiş olması sayesinde, birçok dilde yüksek doğrulukta transkripsiyon yapabilme yeteneğine sahiptir.

Whisper’ın Temel Özellikleri:

• Yüksek Doğruluk: Farklı aksanlar, arka plan gürültüsü ve teknik terimler karşısında bile etkileyici bir doğruluk sergiler.
• Çok Dillilik: Sadece İngilizce değil, onlarca farklı dilde (Türkçe dahil) transkripsiyon yapabilir ve hatta diller arası çeviri yeteneğine sahiptir.
• Zaman Damgaları: Konuşmanın metne dönüştürülmesinin yanı sıra, her kelimenin veya cümlenin videodaki başlangıç ve bitiş zamanlarını da sağlayarak altyazı dosyaları için kritik olan zaman damgalarını otomatik olarak oluşturur.
• Farklı Model Boyutları: tiny, base, small, medium, large gibi farklı boyutlarda modeller sunar. Bu modeller, doğruluk ve hız arasında bir denge sunar. Daha küçük modeller daha hızlı çalışırken, daha büyük modeller daha doğru sonuçlar verir ve genellikle GPU gerektirir.

Projemizde Whisper, videodan ayrıştırılan ses dosyasını alacak ve bu sesi otomatik olarak metne (ve SRT formatına uygun zaman damgalarına) dönüştürecektir.

FFmpeg: Medya İşleme İçin İsviçre Çakısı

FFmpeg, ses ve video dosyalarını işlemek için kullanılan açık kaynaklı, komut satırı tabanlı güçlü bir çerçevedir. Medya dönüştürme, akış, filtreleme ve kodlama gibi sayısız işlemi gerçekleştirebilir. Medya dünyasında bir “İsviçre çakısı” olarak kabul edilir.

FFmpeg’in Projemizdeki Rolü:

• Ses Ayrıştırma: Videodan sadece ses parçasını (genellikle MP3 veya WAV formatında) ayıklamak için kullanılacaktır. Whisper’ın doğrudan video dosyalarıyla çalışmak yerine ses dosyalarını tercih etmesi nedeniyle bu adım kritik öneme sahiptir.
• Altyazı Entegrasyonu (Hardcode): Oluşturulan altyazı dosyasını (SRT) videoya kalıcı olarak “yakmak” (hardcode etmek) için kullanılacaktır. Bu sayede altyazılar videonun bir parçası haline gelir ve herhangi bir oynatıcıda otomatik olarak görünür.
• Video Format Dönüştürme (Opsiyonel): Gerekirse, farklı video formatları arasında dönüştürme yapmak veya video çözünürlüğünü ayarlamak için de kullanılabilir.

FFmpeg’in komut satırı arayüzü sayesinde, Python betiğimizden kolayca çağrılarak medya işleme görevlerini otomatikleştirebiliriz.

Bölüm 2: Ortam Kurulumu

Projemize başlamadan önce gerekli tüm yazılımları ve kütüphaneleri sistemimize kurmamız gerekmektedir. Bu bölüm, adım adım kurulum sürecini anlatmaktadır.

2.1 Python ve Pip Kurulumu

Python’ın sisteminizde kurulu olduğundan emin olun. Genellikle modern işletim sistemlerinde Python ön yüklü olarak gelir. Ancak güncel bir sürüme sahip olmak önemlidir (Python 3.8 veya üzeri önerilir).
Komut istemcinizi (CMD, PowerShell, Terminal) açarak Python sürümünüzü kontrol edebilirsiniz:

python --version
pip --version

Eğer Python kurulu değilse, resmi python.org adresinden işletim sisteminize uygun kurulum dosyasını indirip kurun. Kurulum sırasında “Add Python to PATH” seçeneğini işaretlemeyi unutmayın. Pip (Python’ın paket yöneticisi) genellikle Python ile birlikte gelir.

2.2 Sanal Ortam Oluşturma (Önerilen)

Python projelerinde bağımlılık çakışmalarını önlemek için sanal ortamlar kullanmak en iyi uygulamadır. Bu, projenize özel bir izole Python ortamı oluşturmanızı sağlar.

# Proje klasörünüze gidin
cd /yol/to/proje_klasoru

Sanal ortam oluşturun (venv adı isteğe bağlıdır)
python -m venv venv

Sanal ortamı etkinleştirin
Windows için:
.\venv\Scripts\activate
macOS/Linux için:
source venv/bin/activate

Sanal ortam etkinleştirildiğinde, komut istemcinizin başında (venv) gibi bir ibare göreceksiniz. Artık kuracağınız tüm Python paketleri bu sanal ortam içinde izole edilecektir.

2.3 FFmpeg Kurulumu

FFmpeg, komut satırı tabanlı bir araç olduğundan, sisteminizin PATH değişkenine eklenmesi gerekir.

Windows için:

1. FFmpeg’in resmi sitesinden (ffmpeg.org/download.html) en son sürümü indirin. Genellikle “Builds” bölümünden gyan.dev veya BtbN gibi kaynaklardan ffmpeg-master-latest-win64-gpl.zip gibi bir dosya indirilir.
2. İndirilen ZIP dosyasını açın ve içindeki bin klasörünü (örneğin, C:\ffmpeg\bin) kolayca erişilebilecek bir yere taşıyın.
3. Bu bin klasörünün yolunu sisteminizin PATH değişkenine ekleyin:
   • “Başlat” menüsünü açın ve “ortam değişkenleri” yazın.
   • “Sistem ortam değişkenlerini düzenleyin” seçeneğini seçin.
   • “Ortam Değişkenleri…” butonuna tıklayın.
   • “Sistem değişkenleri” altında Path değişkenini bulun ve “Düzenle”ye tıklayın.
   • “Yeni”ye tıklayın ve FFmpeg bin klasörünün tam yolunu yapıştırın (örneğin, C:\ffmpeg\bin).
   • Tüm pencereleri “Tamam” diyerek kapatın.
4. Yeni bir komut istemcisi açarak FFmpeg’in doğru kurulup kurulmadığını kontrol edin:

   ffmpeg -version

macOS için:

Homebrew kullanıyorsanız kurulum çok daha basittir:

brew install ffmpeg

Homebrew kurulu değilse, [brew.sh](https://brew.sh/) adresinden kurulum talimatlarını takip edebilirsiniz.

Linux için (Ubuntu/Debian tabanlı):

sudo apt update
sudo apt install ffmpeg

Diğer Linux dağıtımları için kendi paket yöneticinizi kullanın (örneğin, Fedora için sudo dnf install ffmpeg).

2.4 Gerekli Python Kütüphanelerini Kurma

Sanal ortamınız etkinleştirilmişken, Whisper modelini ve FFmpeg komutlarını Python’dan yönetmek için gerekli kütüphaneleri kuralım:

pip install openai-whisper # veya sadece pip install whisper
pip install ffmpeg-python
pip install tqdm # İlerleme çubuğu için, opsiyonel ama kullanışlı
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 # GPU desteği için (CUDA 11.8 örneği), CPU için sadece pip install torch

* openai-whisper: OpenAI Whisper modelini kullanmak için ana kütüphane.
* ffmpeg-python: Python’dan FFmpeg komutlarını daha Pythonik bir şekilde çalıştırmayı sağlayan bir sarmalayıcı (wrapper). subprocess modülüyle de çalışılabilir ancak ffmpeg-python daha kullanışlıdır.
* tqdm: Döngülerde veya uzun süren işlemlerde ilerleme çubuğu göstermek için kullanılır, kullanıcı deneyimini artırır.
* torch: Whisper’ın altında yatan derin öğrenme çerçevesi. GPU desteği için PyTorch’un CUDA özellikli sürümünü kurmanız önemlidir. Eğer GPU’nuz yoksa veya kullanmak istemiyorsanız, sadece pip install torch yeterli olacaktır (bu durumda CPU üzerinde çalışır ve daha yavaş olabilir). Yukarıdaki komut CUDA 11.8 içindir, kendi CUDA sürümünüze göre PyTorch’un resmi sitesinden (pytorch.org/get-started/locally/) doğru kurulum komutunu bulmalısınız.

Bölüm 3: Altyazı Oluşturma ve Videoya Ekleme Süreci

Şimdi, tüm bileşenler hazır olduğuna göre, videomuza otomatik altyazı ekleme sürecini adım adım uygulayalım. Bu süreç üç ana aşamadan oluşur: sesi videodan ayıklama, sesi metne dönüştürerek altyazı dosyası oluşturma ve altyazıyı videoya entegre etme.

3.1 Adım 1: Videodan Sesi Ayıklama

Whisper modeli doğrudan video dosyalarıyla çalışmak yerine ses dosyalarını (MP3, WAV vb.) tercih eder. Bu nedenle ilk adımımız, hedef videomuzdan ses parçasını ayıklamak olacaktır. Bu işlemi FFmpeg ile gerçekleştireceğiz.

import ffmpeg
import os

def extract_audio(video_path, audio_path):
    """
    Belirtilen video dosyasından sesi ayıklayarak MP3 formatında kaydeder.
    """
    if os.path.exists(audio_path):
        print(f"Ses dosyası zaten mevcut: {audio_path}")
        return

    print(f"Sesi ayıklanıyor: {video_path} -> {audio_path}")
    try:
        (
            ffmpeg
            .input(video_path)
            .output(audio_path, acodec='libmp3lame', ar='16000') # libmp3lame ile MP3 kodlama, 16kHz örnekleme hızı
            .run(overwrite_output=True, capture_stderr=True)
        )
        print(f"Ses başarıyla ayıklandı: {audio_path}")
    except ffmpeg.Error as e:
        print(f"Hata: Ses ayıklanamadı. STDERR: {e.stderr.decode()}")
        raise

Örnek kullanım:
video_input_path = "input_video.mp4"
audio_output_path = "extracted_audio.mp3"
extract_audio(video_input_path, audio_output_path)

Açıklamalar:
* ffmpeg.input(video_path): FFmpeg’e giriş videosunu belirtir.
* .output(audio_path, acodec='libmp3lame', ar='16000'): Çıkış dosyasını ve ses kodeğini (MP3 için libmp3lame), örnekleme hızını (Whisper için 16kHz önerilir) ayarlar.
* .run(overwrite_output=True, capture_stderr=True): FFmpeg komutunu çalıştırır. overwrite_output=True mevcut dosyayı üzerine yazar, capture_stderr=True hata mesajlarını yakalamak içindir.
* Hata yönetimi (try-except bloğu) ekleyerek FFmpeg komutunun başarısız olması durumunda kullanıcıya bilgi verilir.

3.2 Adım 2: OpenAI Whisper ile Altyazı (SRT) Oluşturma

Ses dosyası elimizde olduğuna göre, şimdi Whisper modelini kullanarak bu sesi metne dönüştürecek ve zaman damgalarıyla birlikte bir SRT (SubRip) formatında altyazı dosyası oluşturacağız.

import whisper
import os
import tqdm # İlerleme çubuğu için

def generate_subtitles(audio_path, srt_path, model_name="small", language="tr"):
    """
    Ses dosyasından altyazı (SRT) dosyası oluşturur.
    """
    if os.path.exists(srt_path):
        print(f"Altyazı dosyası zaten mevcut: {srt_path}")
        return

    print(f"Whisper modeli yükleniyor: {model_name}...")
    try:
        # GPU varsa 'cuda', yoksa 'cpu' kullanır
        device = "cuda" if whisper.torch.cuda.is_available() else "cpu"
        model = whisper.load_model(model_name, device=device)
        print(f"Model {device} üzerinde yüklendi.")
    except Exception as e:
        print(f"Hata: Whisper modeli yüklenemedi. {e}")
        print("GPU kullanırken sorun yaşıyorsanız, 'pip install torch --index-url https://download.pytorch.org/whl/cpu' ile sadece CPU sürümünü kurmayı deneyin.")
        raise

    print(f"Ses dönüştürülüyor: {audio_path} -> {srt_path}")
    try:
        # tqdm ile ilerleme çubuğu ekleyebiliriz (Whisper'ın kendi ilerleme çubuğu da var)
        # Whisper'ın transcribe metodunun bir progress callback'i yok, bu yüzden dışarıdan bir tqdm sarmalayıcı eklemek zor.
        # Ancak Whisper'ın kendi transkripsiyon süreci genellikle terminalde ilerleme gösterir.
        result = model.transcribe(audio_path, language=language, verbose=True) # verbose=True ile ilerleme gözlemlenebilir
        
        # SRT formatına dönüştürme
        with open(srt_path, "w", encoding="utf-8") as srt_file:
            for i, segment in enumerate(result["segments"]):
                start_time = format_timestamp(segment["start"])
                end_time = format_timestamp(segment["end"])
                text = segment["text"].strip()
                
                srt_file.write(f"{i + 1}\n")
                srt_file.write(f"{start_time} --> {end_time}\n")
                srt_file.write(f"{text}\n\n")
        
        print(f"Altyazı dosyası başarıyla oluşturuldu: {srt_path}")
    except Exception as e:
        print(f"Hata: Altyazı oluşturulamadı. {e}")
        raise

def format_timestamp(seconds):
    """Saniye cinsinden zamanı SRT formatına dönüştürür."""
    milliseconds = int((seconds - int(seconds)) * 1000)
    seconds = int(seconds)
    minutes, seconds = divmod(seconds, 60)
    hours, minutes = divmod(minutes, 60)
    return f"{hours:02}:{minutes:02}:{seconds:02},{milliseconds:03}"

Örnek kullanım:
audio_input_path = "extracted_audio.mp3"
srt_output_path = "subtitles.srt"
generate_subtitles(audio_input_path, srt_output_path, model_name="medium", language="tr")

Açıklamalar:
* whisper.load_model(model_name, device=device): Belirtilen Whisper modelini yükler. model_name olarak tiny, base, small, medium, large gibi seçenekler mevcuttur. medium veya large modelleri genellikle daha iyi doğruluk sunar ancak daha fazla işlem gücü (tercihen GPU) ve zaman gerektirir. device parametresi ile modelin CPU veya GPU’da çalışacağını belirtebiliriz.
* model.transcribe(audio_path, language=language, verbose=True): Ses dosyasını transkribe eder. language parametresi, konuşmanın dilini belirtir (örneğin, “tr” Türkçe için). verbose=True konsolda ilerleme durumunu gösterir.
* result["segments"]: Transkripsiyon sonucunda elde edilen her bir konuşma parçasını ve zaman damgalarını içeren bir listedir.
* format_timestamp fonksiyonu, Whisper’dan gelen saniye cinsinden zamanı SRT formatının gerektirdiği HH:MM:SS,ms formatına dönüştürür.
* SRT dosyası, her bir altyazı segmenti için sırasıyla bir numara, zaman aralığı ve metin içeren basit bir metin dosyasıdır.

3.3 Adım 3: Altyazıyı Videoya Entegre Etme (Hardcode)

Altyazı dosyamız (SRT) hazır olduğuna göre, son adım olarak bu altyazıları orijinal videomuza kalıcı olarak “yakacağız” (hardcode edeceğiz). Bu, altyazıların videonun bir parçası haline gelmesini ve herhangi bir oynatıcıda veya platformda otomatik olarak görünmesini sağlar. Bu işlemi yine FFmpeg ile yapacağız.

import ffmpeg
import os

def burn_subtitles_to_video(video_path, srt_path, output_video_path, font_size=24, font_color="white", font_name="Arial", outline_color="black"):
    """
    Altyazı dosyasını videoya kalıcı olarak yakar (hardcode).
    """
    if os.path.exists(output_video_path):
        print(f"Çıkış video dosyası zaten mevcut: {output_video_path}")
        return

    print(f"Altyazılar videoya yakılıyor: {video_path} + {srt_path} -> {output_video_path}")
    try:
        # FFmpeg'in subtitles filtresi ile altyazıları videoya yakma
        # font_name, font_size, PrimaryColour, OutlineColour, Alignment gibi birçok stil ayarı yapılabilir.
        # PrimaryColour ve OutlineColour AARRGGBB formatındadır (Alpha, Red, Green, Blue).
        # &H00FFFFFF = Beyaz (tam opak)
        # &H00000000 = Siyah (tam opak)
        
        style_string = (
            f"Fontname={font_name},"
            f"FontSize={font_size},"
            f"PrimaryColour=&H00{font_color.upper()}," # Örn: &H00FFFFFF (Beyaz)
            f"OutlineColour=&H00{outline_color.upper()}," # Örn: &H00000000 (Siyah)
            "BorderStyle=1," # 1: Outline+Shadow, 3: Opaque Box
            "Outline=1,"     # Outline kalınlığı
            "Shadow=0,"      # Gölge kalınlığı
            "Alignment=2,"   # 2: Orta Alt
            "MarginV=20"     # Dikey marj (alt kenardan uzaklık)
        )

        (
            ffmpeg
            .input(video_path)
            .output(
                output_video_path,
                vf=f"subtitles='{srt_path.replace(':', '\\:')}':force_style='{style_string}'",
                acodec='copy', # Ses akışını yeniden kodlamadan kopyala
                vcodec='libx264' # Video kodeğini belirle, h264 için libx264
            )
            .run(overwrite_output=True, capture_stderr=True)
        )
        print(f"Altyazılı video başarıyla oluşturuldu: {output_video_path}")
    except ffmpeg.Error as e:
        print(f"Hata: Altyazılar videoya yakılamadı. STDERR: {e.stderr.decode()}")
        raise

Örnek kullanım:
video_input_path = "input_video.mp4"
srt_input_path = "subtitles.srt"
output_video_path = "output_video_with_subtitles.mp4"
burn_subtitles_to_video(video_input_path, srt_input_path, output_video_path, font_size=28, font_color="FFFF00", outline_color="000000") # Sarı metin, siyah çerçeve

Açıklamalar:
* ffmpeg.input(video_path): Giriş videosunu belirtir.
* .output(output_video_path, vf=..., acodec='copy', vcodec='libx264'): Çıkış videosunu ve video filtresini (vf), ses ve video kodeklerini ayarlar.
* vf=f"subtitles='{srt_path}':force_style='{style_string}'": Bu kısım en önemli noktadır. subtitles filtresi, belirtilen SRT dosyasını videoya uygular.
* srt_path.replace(':', '\\:'): Windows sistemlerinde dosya yolu içinde C:\ gibi bir ifade varsa, FFmpeg’in bunu yanlış yorumlamaması için : karakterinin kaçırılması gerekebilir.
* force_style='...': Altyazının stilini özelleştirmek için kullanılır. Burada yazı tipi, boyutu, rengi, dış çizgi rengi, hizalama gibi birçok parametre ayarlanabilir.
* Fontname: Yazı tipi (örneğin, “Arial”, “Verdana”).
* FontSize: Yazı boyutu.
* PrimaryColour: Metin rengi (RGB veya AARRGGBB hex kodu, &H00RRGGBB formatında).
* OutlineColour: Dış çizgi rengi.
* BorderStyle: 1 (Dış çizgi + Gölge) veya 3 (Opak Kutu).
* Outline: Dış çizgi kalınlığı.
* Shadow: Gölge kalınlığı.
* Alignment: Metnin videodaki konumu (1-9 arası, 2 genellikle orta alt).
* MarginV: Dikey marj (altyazının alt kenardan ne kadar yukarıda olacağı).
* acodec='copy': Ses akışını yeniden kodlamadan kopyalar, bu da işlem süresini kısaltır ve kalite kaybını önler.
* vcodec='libx264': Video akışını H.264 formatında kodlar. Bu, çoğu platformda uyumlu ve iyi sıkıştırma sağlayan popüler bir kodektir.

Bölüm 4: Tüm Süreci Birleştiren Python Betiği ve Gelişmiş Konular

Şimdiye kadar öğrendiğimiz tüm adımları tek bir Python betiğinde birleştirelim ve kullanıcı dostu bir araç oluşturalım. Ayrıca, performans, doğruluk ve hata yönetimi gibi gelişmiş konulara da değinelim.

4.1 Ana Betik (main.py)

import os
import argparse
from datetime import datetime
import ffmpeg
import whisper

Daha önceki fonksiyonları buraya kopyalayabilir veya ayrı bir utils.py dosyasında tutabilirsiniz.
Basitlik için burada tekrar tanımlanmıştır.

def extract_audio(video_path, audio_path):
    if os.path.exists(audio_path):
        print(f"Ses dosyası zaten mevcut: {audio_path}")
        return True

    print(f"Sesi ayıklanıyor: {video_path} -> {audio_path}")
    try:
        (
            ffmpeg
            .input(video_path)
            .output(audio_path, acodec='libmp3lame', ar='16000')
            .run(overwrite_output=True, capture_stderr=True)
        )
        print(f"Ses başarıyla ayıklandı: {audio_path}")
        return True
    except ffmpeg.Error as e:
        print(f"Hata: Ses ayıklanamadı. STDERR: {e.stderr.decode()}")
        return False

def format_timestamp(seconds):
    milliseconds = int((seconds - int(seconds)) * 1000)
    seconds = int(seconds)
    minutes, seconds = divmod(seconds, 60)
    hours, minutes = divmod(minutes, 60)
    return f"{hours:02}:{minutes:02}:{seconds:02},{milliseconds:03}"

def generate_subtitles(audio_path, srt_path, model_name="small", language="tr"):
    if os.path.exists(srt_path):
        print(f"Altyazı dosyası zaten mevcut: {srt_path}")
        return True

    print(f"Whisper modeli yükleniyor: {model_name}...")
    try:
        device = "cuda" if whisper.torch.cuda.is_available() else "cpu"
        model = whisper.load_model(model_name, device=device)
        print(f"Model {device} üzerinde yüklendi.")
    except Exception as e:
        print(f"Hata: Whisper modeli yüklenemedi. {e}")
        print("GPU kullanırken sorun yaşıyorsanız, 'pip install torch --index-url https://download.pytorch.org/whl/cpu' ile sadece CPU sürümünü kurmayı deneyin.")
        return False

    print(f"Ses dönüştürülüyor: {audio_path} -> {srt_path}")
    try:
        result = model.transcribe(audio_path, language=language, verbose=True)
        
        with open(srt_path, "w", encoding="utf-8") as srt_file:
            for i, segment in enumerate(result["segments"]):
                start_time = format_timestamp(segment["start"])
                end_time = format_timestamp(segment["end"])
                text = segment["text"].strip()
                
                srt_file.write(f"{i + 1}\n")
                srt_file.write(f"{start_time} --> {end_time}\n")
                srt_file.write(f"{text}\n\n")
        
        print(f"Altyazı dosyası başarıyla oluşturuldu: {srt_path}")
        return True
    except Exception as e:
        print(f"Hata: Altyazı oluşturulamadı. {e}")
        return False

def burn_subtitles_to_video(video_path, srt_path, output_video_path, font_size=24, font_color="FFFFFF", font_name="Arial", outline_color="000000"):
    if os.path.exists(output_video_path):
        print(f"Çıkış video dosyası zaten mevcut: {output_video_path}")
        return True

    print(f"Altyazılar videoya yakılıyor: {video_path} + {srt_path} -> {output_video_path}")
    try:
        style_string = (
            f"Fontname={font_name},"
            f"FontSize={font_size},"
            f"PrimaryColour=&H00{font_color},"
            f"OutlineColour=&H00{outline_color},"
            "BorderStyle=1,"
            "Outline=1,"
            "Shadow=0,"
            "Alignment=2,"
            "MarginV=20"
        )

        (
            ffmpeg
            .input(video_path)
            .output(
                output_video_path,
                vf=f"subtitles='{srt_path.replace(':', '\\:')}':force_style='{style_string}'",
                acodec='copy',
                vcodec='libx264'
            )
            .run(overwrite_output=True, capture_stderr=True)
        )
        print(f"Altyazılı video başarıyla oluşturuldu: {output_video_path}")
        return True
    except ffmpeg.Error as e:
        print(f"Hata: Altyazılar videoya yakılamadı. STDERR: {e.stderr.decode()}")
        return False

def main():
    parser = argparse.ArgumentParser(description="Python, OpenAI Whisper ve FFmpeg kullanarak videolara otomatik altyazı ekler.")
    parser.add_argument("video_file", type=str, help="İşlenecek video dosyasının yolu.")
    parser.add_argument("--model", type=str, default="small", choices=["tiny", "base", "small", "medium", "large", "large-v2"],
                        help="Kullanılacak Whisper modeli (tiny, base, small, medium, large).")
    parser.add_argument("--lang", type=str, default="tr", help="Konuşmanın dili (örn: en, tr, de).")
    parser.add_argument("--font_size", type=int, default=24, help="Altyazı yazı boyutu.")
    parser.add_argument("--font_color", type=str, default="FFFFFF", help="Altyazı yazı rengi (hex kodu, örn: FFFFFF beyaz için).")
    parser.add_argument("--font_name", type=str, default="Arial", help="Altyazı yazı tipi.")
    parser.add_argument("--outline_color", type=str, default="000000", help="Altyazı dış çizgi rengi (hex kodu, örn: 000000 siyah için).")
    parser.add_argument("--output_suffix", type=str, default="_subtitled", help="Çıkış video dosyasına eklenecek sonek.")

    args = parser.parse_args()

    video_input_path = args.video_file
    
    if not os.path.exists(video_input_path):
        print(f"Hata: Video dosyası bulunamadı: {video_input_path}")
        return

    base_name = os.path.splitext(os.path.basename(video_input_path))[0]
    output_dir = "output_files"
    os.makedirs(output_dir, exist_ok=True)

    audio_output_path = os.path.join(output_dir, f"{base_name}.mp3")
    srt_output_path = os.path.join(output_dir, f"{base_name}.srt")
    output_video_path = os.path.join(output_dir, f"{base_name}{args.output_suffix}.mp4")

    start_time = datetime.now()
    print(f"İşlem başladı: {start_time}")

    # 1. Sesi Ayıkla
    if not extract_audio(video_input_path, audio_output_path):
        return

    # 2. Altyazı Oluştur
    if not generate_subtitles(audio_output_path, srt_output_path, args.model, args.lang):
        return

    # 3. Altyazıyı Videoya Yak
    if not burn_subtitles_to_video(video_input_path, srt_output_path, output_video_path, 
                                   args.font_size, args.font_color, args.font_name, args.outline_color):
        return
    
    end_time = datetime.now()
    print(f"İşlem tamamlandı: {end_time}")
    print(f"Toplam süre: {end_time - start_time}")
    print(f"Final video: {output_video_path}")

if __name__ == "__main__":
    main()

4.2 Betiği Çalıştırma

Yukarıdaki kodu main.py adıyla kaydedin. Ardından, sanal ortamınız etkinleştirilmişken komut istemcinizden çalıştırabilirsiniz:

python main.py input_video.mp4 --model medium --lang tr --font_size 28 --font_color FFFF00 --outline_color 000000

* input_video.mp4: İşlemek istediğiniz video dosyasının yolu.
* --model medium: medium boyutlu Whisper modelini kullanır. Daha hızlı ancak daha az doğru sonuçlar için small veya base kullanabilirsiniz. En iyi doğruluk için large veya large-v2 kullanın (GPU gerektirir).
* --lang tr: Konuşma dilini Türkçe olarak ayarlar.
* --font_size 28: Altyazı font boyutunu 28 yapar.
* --font_color FFFF00: Altyazı metin rengini sarı yapar.
* --outline_color 000000: Altyazı dış çizgi rengini siyah yapar.

4.3 Gelişmiş Konular ve En İyi Uygulamalar

4.3.1 Performans ve GPU Kullanımı

* Whisper Modeli Seçimi: tiny ve base modeller CPU üzerinde nispeten hızlı çalışırken, small, medium ve large modelleri GPU (özellikle NVIDIA CUDA) kullanıldığında çok daha hızlıdır. Eğer bir NVIDIA GPU’nuz varsa, PyTorch’u CUDA desteğiyle kurduğunuzdan emin olun (Bölüm 2.4’teki talimatlara bakın).
* Bellek Kullanımı: large model, özellikle uzun videolar için önemli miktarda VRAM (GPU belleği) veya RAM gerektirebilir. Bellek sınırlamaları yaşıyorsanız daha küçük bir model kullanmayı düşünebilirsiniz.
* Paralelleştirme: Birden fazla videoyu işlerken, her video için ayrı bir işlem veya iş parçacığı (thread) kullanarak işlemi paralelleştirebilir ve toplam süreyi kısaltabilirsiniz. Python’ın concurrent.futures modülü bu konuda yardımcı olabilir.

4.3.2 Doğruluk ve Dil Seçimi

* Ses Kalitesi: Whisper’ın doğruluğu, giriş sesinin kalitesiyle doğrudan orantılıdır. Arka plan gürültüsü, yankı veya düşük kayıt kalitesi transkripsiyon doğruluğunu olumsuz etkiler.
* Konuşma Hızı ve Netliği: Konuşmacının net ve makul bir hızda konuşması, daha doğru sonuçlar alınmasına yardımcı olur.
* Dil Belirtme: --lang parametresiyle doğru dili belirtmek, Whisper’ın o dile odaklanmasını sağlayarak doğruluğu artırır. Whisper otomatik dil tespiti yapabilse de, manuel belirtme genellikle daha güvenilirdir.
* Model Boyutu: Daha büyük modeller (örneğin, large veya large-v2) genellikle daha yüksek doğruluk sunar ancak daha yavaş çalışır ve daha fazla kaynak gerektirir.

4.3.3 Hata Yönetimi ve Sağlamlık

* Dosya Kontrolleri: Betik, giriş video dosyasının varlığını kontrol etmeli ve ara çıktı dosyalarının (ses, SRT) zaten mevcut olup olmadığını sorgulayarak gereksiz işlemleri atlamalıdır.
* Try-Except Blokları: FFmpeg komutları veya Whisper modeli yükleme/çalıştırma sırasında oluşabilecek hataları yakalamak için try-except blokları kullanmak, betiğin çökmesini engeller ve kullanıcıya anlamlı hata mesajları sunar.
* Geçici Dosyalar: Ayıklanan ses dosyaları veya oluşturulan SRT dosyaları gibi geçici dosyaların işleme sonunda silinmesi (veya belirli bir klasörde tutulması), disk alanının düzenli kalmasına yardımcı olur. Benim betiğim output_files klasöründe tutmayı tercih ediyor.

4.3.4 Altyazı Stili ve Konumlandırma

* FFmpeg subtitles Filtresi: FFmpeg’in subtitles filtresi, altyazıların görünümü üzerinde oldukça detaylı kontrol sağlar. force_style parametresiyle Fontname, FontSize, PrimaryColour, OutlineColour, Alignment, MarginV gibi birçok ayarı yapabilirsiniz.
* Renk Kodları: Renkler genellikle AARRGGBB (Alpha, Red, Green, Blue) formatında hex kodları olarak belirtilir. Python betiğimizde font_color="FFFFFF" gibi sadece RGB kısmını alıp &H00 ön ekini ekleyerek tam opak (Alpha=00) renkler oluşturuyoruz.
* Hizalama: Alignment parametresi, altyazının ekrandaki konumunu belirler. 2 (orta alt), 1 (sol alt), 3 (sağ alt) gibi değerler alabilir.

4.3.5 Batch İşleme

Birden fazla video dosyasını işlemek için ana betiği bir döngü içine alabilirsiniz. Belirli bir klasördeki tüm .mp4 dosyalarını bulup her biri için bu süreci tekrarlayan bir yapı kurmak oldukça kolaydır.

# main.py dosyasında main() fonksiyonunun içinde veya ayrı bir fonksiyonda
video_files_to_process = ["video1.mp4", "video2.mp4", "folder/video3.mp4"]
for video_file in video_files_to_process:
# Mevcut argümanları kullanarak her bir video için main() içindeki adımları tekrarla
# Veya main() fonksiyonunu bu döngüye uygun hale getirerek çağırın
process_single_video(video_file, args.model, args.lang, ...)

Sonuç

Bu kapsamlı teknik makalede, Python, OpenAI Whisper ve FFmpeg’in güçlü kombinasyonunu kullanarak videolara otomatik altyazı oluşturma ve ekleme sürecini adım adım inceledik. Videodan ses ayıklamadan, Whisper ile konuşmayı metne dönüştürmeye ve FFmpeg ile altyazıları videoya kalıcı olarak yakmaya kadar her aşamayı detaylandırdık.

Bu yöntem, içerik üreticileri, eğitimciler ve geliştiriciler için manuel altyazı oluşturma yükünü önemli ölçüde azaltarak zaman ve maliyet tasarrufu sağlar. Ayrıca, oluşturulan altyazılar sayesinde videolarınızın erişilebilirliğini artırabilir, daha geniş bir kitleye ulaşabilir ve arama motorlarındaki görünürlüğünü iyileştirebilirsiniz.

Unutulmamalıdır ki, yapay zeka tabanlı sistemler mükemmel değildir. Ses kalitesi, aksanlar veya karmaşık terminoloji gibi faktörler transkripsiyon doğruluğunu etkileyebilir. Bu nedenle, kritik uygulamalar için otomatik oluşturulan altyazıların manuel olarak gözden geçirilmesi ve düzenlenmesi her zaman iyi bir uygulama olacaktır.

Bu rehber, kendi otomatik altyazı oluşturma sisteminizi kurmanız için sağlam bir temel sunmaktadır. Bu temeli kullanarak kendi ihtiyaçlarınıza göre daha da geliştirebilir, farklı altyazı stilleri deneyebilir, birden fazla dil desteği ekleyebilir veya bir web arayüzü ile entegre edebilirsiniz. Teknolojinin bu heyecan verici birleşimini keşfetmeye devam edin ve video içeriğinizin potansiyelini tam olarak ortaya çıkarın!