ابزار نویسی و توسعه ترجمه خودکار

عکس شماره <1>

مقدمه

حتماً پیش اومده بخوای یه ویدیوی آموزشی یا انگیسی رو ببینی ولی زیرنویس نداشته باشه.

اینجا جاییه که هوش مصنوعی وارد میشه

این ابزار میتونه صدای ویدیوهای انگلیسی رو به متن تبدیل کنه و بهصورت زیرنویس روی همون ویدیو قرار بده.

نکته جالبش اینه که فقط بار اول نیاز به اینترنت داره تا پکیجهای موردنیاز دانلود بشن؛ بعد از اون همهچیز آفلاین روی سیستم خودت انجام میشه.

در صورت تمایل هم میتونی زیرنویس فارسی رو در کنار انگلیسی داشته باشی.

خروجی صدا فقط انگلیسی به متن

#!/usr/bin/env python3

# -*- coding: utf-8 -*-
"""
auto_sub_en_dir.py final vidoe to en
------------------
Batch-generate English subtitles (.en.srt) for all video/audio files in a directory.

Pipeline:
1) Extract audio with ffmpeg -> 16kHz mono WAV
2) Transcribe with faster-whisper (task="transcribe", language="en")
3) Save subtitles in clean SRT format

Requirements:
    pip install faster-whisper ffmpeg-python tqdm

Usage:
    python auto_sub_en_dir.py /path/to/videos --outdir subs --device cpu --compute-type int8
"""

import argparse
import os
import sys
import subprocess
import shutil
import tempfile
from datetime import timedelta
from typing import List, Tuple
from tqdm import tqdm   # progress bar

# ---------- Utilities ----------
def hhmmss_msec(seconds: float) -> str:
    """Convert seconds to SRT timestamp (HH:MM:SS,mmm)."""
    t = timedelta(seconds=max(0.0, float(seconds)))
    total = int(t.total_seconds())
    h = total // 3600
    m = (total % 3600) // 60
    s = total % 60
    ms = int(round((t.total_seconds() - total) * 1000))
    return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"

def wrap_text(text: str, max_line_chars: int = 42, max_lines: int = 2) -> str:
    """Word-wrap subtitle lines for better readability."""
    words = text.strip().split()
    if not words:
        return ""
    lines, curr = [], []
    for w in words:
        if len(" ".join(curr + [w])) <= max_line_chars:
            curr.append(w)
        else:
            lines.append(" ".join(curr))
            curr = [w]
            if len(lines) >= max_lines - 1:
                rest = " ".join([*curr] + words[words.index(w)+1:])
                lines.append(rest)
                return "\n".join(lines[:max_lines])
    if curr:
        lines.append(" ".join(curr))
    return "\n".join(lines[:max_lines])

def write_srt(segments: List[Tuple[int, float, float, str]], out_path: str,
              max_line_chars: int = 42, max_lines: int = 2) -> None:
    """Write subtitle segments to an SRT file."""
    with open(out_path, "w", encoding="utf-8") as f:
        for idx, start, end, text in segments:
            pretty = wrap_text(text, max_line_chars, max_lines) if text else ""
            f.write(f"{idx}\n{hhmmss_msec(start)} --> {hhmmss_msec(end)}\n{pretty}\n\n")

def ensure_ffmpeg() -> str:
    """Ensure ffmpeg is installed and available in PATH."""
    exe = shutil.which("ffmpeg")
    if exe is None:
        raise RuntimeError("ffmpeg not found. Install from https://ffmpeg.org/ and add to PATH.")
    return exe

# ---------- Whisper Transcription ----------
def _import_whisper():
    try:
        from faster_whisper import WhisperModel
        return WhisperModel
    except Exception:
        print("ERROR: faster-whisper is not installed. Run: pip install faster-whisper", file=sys.stderr)
        raise

def extract_audio(input_media: str, out_wav: str, ffmpeg_path: str) -> None:
    """Extract mono 16kHz WAV audio from video."""
    cmd = [
        ffmpeg_path, "-y", "-i", input_media,
        "-vn", "-acodec", "pcm_s16le", "-ac", "1", "-ar", "16000", out_wav
    ]
    proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    if proc.returncode != 0:
        raise RuntimeError(f"ffmpeg failed to extract audio:\n{proc.stderr.decode(errors='ignore')}")

def transcribe_to_english(input_path: str,
                          model,
                          ffmpeg_path: str,
                          beam_size: int = 1) -> List[Tuple[int, float, float, str]]:
    """Transcribe audio to English text with Whisper (model already loaded)."""
    with tempfile.TemporaryDirectory() as td:
        wav = os.path.join(td, "audio.wav")
        extract_audio(input_path, wav, ffmpeg_path)

        segments, _ = model.transcribe(
            wav,
            task="transcribe",
            language="en",
            vad_filter=True,
            vad_parameters=dict(min_silence_duration_ms=250),
            beam_size=beam_size,
        )
        return [(i, seg.start, seg.end, seg.text.strip()) for i, seg in enumerate(segments, start=1)]

# ---------- Main ----------
def main():
    parser = argparse.ArgumentParser(description="Batch-generate English subtitles from all media files in a directory.")
    parser.add_argument("input_dir", help="Input directory containing video/audio files")
    parser.add_argument("--model-size", default="small", help="Whisper model size (tiny, base, small, medium, large-v3)")
    parser.add_argument("--device", default="cpu", help="Device: cpu or cuda")
    parser.add_argument("--compute-type", default="int8", help="Compute type for Whisper (e.g., int8, int8_float16, float16, auto)")
    parser.add_argument("--beam-size", type=int, default=1, help="Beam size (1 = fastest, >1 = better quality)")
    parser.add_argument("--outdir", default=None, help="Directory to save subtitles (default: alongside video files)")
    parser.add_argument("--max-line-chars", type=int, default=42, help="Max characters per subtitle line")
    parser.add_argument("--max-lines", type=int, default=2, help="Max lines per subtitle")
    args = parser.parse_args()

    if not os.path.isdir(args.input_dir):
        print(f"ERROR: input directory not found: {args.input_dir}", file=sys.stderr)
        sys.exit(1)

    # collect video/audio files
    exts = {".mp4", ".mkv", ".avi", ".mov", ".mp3", ".wav", ".flac"}
    files = [os.path.join(args.input_dir, f) for f in os.listdir(args.input_dir)
             if os.path.splitext(f)[1].lower() in exts]

    if not files:
        print(f"No supported media files found in {args.input_dir}", file=sys.stderr)
        sys.exit(1)

    ffmpeg_path = ensure_ffmpeg()

    # load model once
    WhisperModel = _import_whisper()
    print(f"[+] Loading Whisper model ({args.model_size}) on {args.device}...")
    model = WhisperModel(args.model_size, device=args.device, compute_type=args.compute_type)

    # process files with progress bar
    for inp in tqdm(files, desc="Processing files", unit="file"):
        try:
            eng_segs = transcribe_to_english(inp, model, ffmpeg_path, beam_size=args.beam_size)
        except Exception as e:
            print(f"[!] Failed to transcribe {inp}: {e}", file=sys.stderr)
            continue

        base, _ = os.path.splitext(inp)
        if args.outdir:
            os.makedirs(args.outdir, exist_ok=True)
            base = os.path.join(args.outdir, os.path.basename(base))
        en_out = f"{base}.en.srt"

        write_srt(eng_segs, en_out, args.max_line_chars, args.max_lines)
        tqdm.write(f"[✓] Wrote: {en_out}")

if __name__ == "__main__":
    sys.exit(main())

این ابزار با کمک هوش مصنوعی لوکال صدای ویدیوهای انگلیسی را به زیرنویس انگلیسی (.en.srt) تبدیل میکند.
فقط بارِ اول به اینترنت نیاز دارد تا مدلها و پکیجها دانلود شوند؛ بعد از آن کل فرآیند کاملاً آفلاین روی سیستم خودت انجام میشود.

امکانات

• پردازش گروهی همهٔ فایلهای صوتی/ویدیویی داخل یک پوشه

• استخراج صدا با ffmpeg به WAV تککاناله 16kHz

• تبدیل گفتار انگلیسی به متن با faster-whisper

• ذخیره خروجی در SRT تمیز با شکستِ خطوط خوانا (قابل تنظیم)

• نوار پیشرفت (tqdm) + لاگ خطا برای هر فایل

راهنمای ساده برای کاربران ویندوز (بدون نیاز به دانش برنامهنویسی )

نکته: اگه دانش برنامه نویسی داری این بخش رد کن!

این بخش برای کساییه که هیچ تجربهای در برنامهنویسی ندارن و فقط میخوان اسکریپت راحت اجرا بشه.

۱. نصب Python

1. وارد سایت رسمی پایتون :

2. نسخهٔ Python 3.11 رو دانلود کن (نسخه 64bit).

3. نصب رو اجرا کن → حتماً تیک "Add Python to PATH" رو بزن.

2.دانلود ffmpeg

1. نسخهٔ ویندوز (ffmpeg-release-essentials) رو دانلود کن.

2. فایل Zip رو Extract کن (مثلاً توی C:\ffmpeg).

3. مسیر C:\ffmpeg\bin رو به PATH ویندوز اضافه کن:

   1. Start Menu → سرچ کن "Environment Variables" → Edit System Variables → Path → New → آدرس C:\ffmpeg\bin رو وارد کن → OK.

۳. دانلود کد آماده

1. فایل اسکریپت auto_sub_en_dir.py رو ذخیره کن (همین کدی که گذاشتیم).

2. پیشنهاد: بریز داخل یه پوشه به اسم مثلاً subtitle_tool.

3. همهٔ ویدیوها یا فایلهای صوتیات رو هم بریز داخل یه پوشهٔ جدا.

۴. نصب پکیجها (فقط بار اول)

• منوی Start → سرچ کن cmd و بازش کن.

• دستور زیر رو بزن:

pip install faster-whisper ffmpeg-python tqdm

۵. اجرای برنامه

فرض کنیم ویدیوها داخل پوشه E:\Videos هستن. دستور زیر رو بزن:

python auto_sub_en_dir.py "E:\Videos" --outdir مسیر خروجی(subs)  --device cpu --compute-type int8

• اگر درست باشه، شروع میکنه به پردازش و کنار هر ویدیو یک فایل زیرنویس .en.srt میسازه (در پوشه subs).

• بار اول کمی طول میکشه چون مدل دانلود میشه. دفعات بعدی خیلی سریعتر و حتی بدون اینترنت کار میکنه.

پیشنیازها (Programming & Tools)

pip install faster-whisper ffmpeg-python tqdm

• نصب ffmpeg و در دسترسبودن در PATH:

  • ویندوز: دانلود باینری از سایت ffmpeg و افزودن مسیر bin به PATH

  • لینوکس/مک: از package manager نصب کن (مثلاً sudo apt install ffmpeg یا brew install ffmpeg)

• (اختیاری، برای GPU):

  • NVIDIA CUDA سازگار + درایور بهروز

  • نصب پکیجهای PyTorch/CUDA موردنیاز سیستم (اگر قصد استفاده از --device cuda را داری)

نکته: بار اول که اسکریپت اجرا میشود، مدل انتخابیِ Whisper (مثلاً small) دانلود و در کش ذخیره میشود. دفعات بعدی آفلاین اجرا میشود.

نصب سریع (Windows)

python -m venv .venv
.venv\Scripts\activate
pip install --upgrade pip
pip install faster-whisper ffmpeg-python tqdm
# ffmpeg را نصب و PATH را تنظیم کن

طریقه استفاده

ساخت زیرنویس انگلیسی برای همهٔ ویدیو/صوتهای یک پوشه(سیستم خودم این روش رفتم):

python auto_sub_en_dir.py "/path/to/videos" --outdir subs --device cpu --compute-type int8

نمونههای دیگر:

GPU (در صورت نصب CUDA):

python auto_sub_en_dir.py "E:\Videos" --device cuda --compute-type float16 --model-size small

کیفیت بالاتر (کندتر):

python auto_sub_en_dir.py "/path/to/videos" --beam-size 5 --model-size medium

کنترل خوانایی سطرها:

python auto_sub_en_dir.py "/path/to/videos" --max-line-chars 38 --max-lines 2

فرمتهای پشتیبانیشده

mp4, mkv, avi, mov, mp3, wav, flac (میتوانی بهراحتی پسوندهای دیگر را به مجموعهٔ exts در کد اضافه کنی.)

انتخاب مدل و منابع سیستم

برای کارایی بهتر دستور راهنما هم درون کد وجود دارد.بطور کلی من به موارد زیر اشاره میکنم :

نوع model-size:

--model-size
base, small, medium, large-v3

tiny/base

سریع و سبک (برای سیستمهای ضعیف)

small

تعادل سرعت/دقت (پیشنهادی)

medium/large-v3

دقت بالاتر، مصرف RAM/VRAM بیشتر

نوع device:

--device
cuda و cpu

cpu

سازگار با همه

cuda

سریعتر با GPU

نوع compute-type

--compute-type
CPU ->
int8 
int8_float16
GPU ->
float16 
auto

خروجی

برای هر فایل ورودی، یک فایل زیرنویس <name>.en.srt ساخته میشود (در --outdir اگر تنظیم شده باشد؛ در غیر این صورت کنار فایل اصلی).

فقط بار اول آنلاین؛ بعد آفلاین

• بار اول: دانلود مدل Whisper انتخابی + کششدن.

• دفعات بعد: اگر اینترنت قطع باشد هم اسکریپت از مدل کششده استفاده میکند و آفلاین اجرا میشود.

نکات و رفع اشکال

ffmpeg not found خطای

ffmpeg نصب نیست یا PATH تنظیم نشده. پس از نصب، ترمینال را ببند و دوباره باز کن.

کندی زیاد روی CPU (تا حدودی طبیعی هست سیستم قوی میخواد ولی)

از --model-size small/base و --compute-type int8 استفاده کن.

GPU در دسترس نیست (cuda error)

مطمئن شو درایور NVIDIA و Runtime CUDA سازگار نصب است؛ موقتاً با --device cpu تست بزن.

خطای حافظه/VRAM ناکافی

مدل کوچکتر انتخاب کن

کاراکترچینی SRT

با --max-line-chars و --max-lines بازی کن تا خطوط خواناتر شوند.

حریم خصوصی

کل پردازش (پس از بار اول) روی سیستم خودت انجام میشود و فایلها جایی آپلود نمیشوند.

جمع بندی

با این اسکریپت میتونی خیلی راحت ویدیوها و فایلهای صوتی انگلیسی رو به زیرنویس انگلیسی تبدیل کنی.
مزیتش اینه که فقط یک بار اینترنت نیاز داری برای دانلود مدلها؛ بعد از اون همهچیز به صورت آفلاین و امن روی سیستم خودت انجام میشه.

در پست بعدی، توضیح میدم چطور میتونیم همین زیرنویسهای انگلیسی رو به زیرنویس فارسی هم تبدیل کنیم تا ویدیوها کاملتر و قابلفهمتر بشن.