सबटाइटल समय जुड़ा हुआ टेक्स्ट हैं। अरबी सबटाइटल पाइपलाइन का ज़्यादातर काम वही समय हासिल करना है। कुछ speech-to-text API उन्हें शब्द टाइमस्टैम्प या तैयार SRT फ़ाइल के रूप में दे देते हैं। दूसरे, जिनमें BroadNet Inference भी है, सिर्फ़ ट्रांसक्रिप्ट टेक्स्ट लौटाते हैं। यह पोस्ट बताती है कि SRT फ़ाइल को क्या चाहिए, कौन-से प्रोवाइडर टाइमस्टैम्प दस्तावेज़ित करते हैं, और सिर्फ़-टेक्स्ट API से इस्तेमाल लायक अरबी सबटाइटल कैसे बनाएँ, सीमाओं को साफ़-साफ़ बताते हुए।
BroadRouter, BroadNet की अपनी साइट है। अगर आपको frame-सटीक टाइमिंग चाहिए, तो नीचे का ईमानदार जवाब शब्द टाइमस्टैम्प वाला प्रोवाइडर है, BroadNet नहीं।
SRT फ़ाइल को क्या चाहिए?
SRT (SubRip) फ़ाइल सादा टेक्स्ट है। हर कैप्शन के चार हिस्से होते हैं: एक नंबर, एक समय वाली लाइन, टेक्स्ट की एक या दो लाइनें, और एक खाली लाइन।
1
00:00:00,000 --> 00:00:02,800
مرحباً بكم في الحلقة الأولى
2
00:00:03,600 --> 00:00:07,600
اليوم نتحدث عن تحويل الكلام إلى نص وكيف
نصنع ملف ترجمة مصاحبة
Library of Congress का फ़ॉर्मैट विवरण समय का फ़ॉर्मैट घंटे:मिनट:सेकंड,मिलीसेकंड बताता है और तीर को दो हाइफ़न और एक दायाँ कोण कोष्ठक। यह यह भी कहता है कि SRT “not well standardized” (अनुवाद: ठीक से मानकीकृत नहीं) है और SRT फ़ाइलें “do not have a character encoding standard” (अनुवाद: का कोई character encoding मानक नहीं है)। अरबी के लिए UTF-8 लिखें और अपने लक्षित प्लेयर में टेस्ट करें। WebVTT, इसका वेब उत्तराधिकारी, मिलीसेकंड से पहले कॉमा की जगह फ़ुल स्टॉप इस्तेमाल करता है।
तो सख़्त ज़रूरत हर कैप्शन के लिए शुरुआती और आख़िरी समय है। सिर्फ़ टेक्स्ट काफ़ी नहीं।
अरबी सबटाइटल की लाइन कितनी लंबी होनी चाहिए?
अनुमान लगाने के बजाय कोई प्रकाशित स्टाइल गाइड इस्तेमाल करें। Netflix की Arabic Timed Text Style Guide (change log की तारीख़ 2025-12-19) यह तय करती है:
| नियम | Netflix का मान |
|---|---|
| प्रति लाइन कैरेक्टर | 42 |
| प्रति कैप्शन लाइनें | अधिकतम दो |
| पढ़ने की गति, वयस्क कार्यक्रम | प्रति सेकंड 20 कैरेक्टर तक |
| पढ़ने की गति, बच्चों के कार्यक्रम | प्रति सेकंड 17 कैरेक्टर तक |
| लाइन तोड़ना | क्रिया को उसके कर्ता से, पूर्वसर्ग को उसकी संज्ञा से, या संख्या को गिनी जाने वाली चीज़ से अलग न करें |
Netflix की सामान्य ज़रूरतें प्रति कैप्शन न्यूनतम सेकंड का पाँच-छठा हिस्सा और अधिकतम 7 सेकंड जोड़ती हैं। अरबी गाइड अनुवादित सबटाइटल में मानक आधुनिक अरबी भी माँगती है। यह अनुवाद का नियम है; बोली वाली बातचीत का ट्रांसक्रिप्ट बोली में ही रहता है।
ये आँकड़े कोड बन जाते हैं: 42 कैरेक्टर पर लाइन तोड़ें, प्रति कैप्शन दो लाइनें, प्रति सेकंड 20 कैरेक्टर से ऊपर चेतावनी दें, और कोई कैप्शन 7 सेकंड से ज़्यादा न रोकें।
कौन-से speech-to-text API टाइमस्टैम्प या SRT दस्तावेज़ित करते हैं?
हमने 15 नवंबर 2026 को हर प्रोवाइडर के मौजूदा डॉक्स पढ़े। यह सूची बताती है कि वे क्या दस्तावेज़ित करते हैं, यह नहीं कि टाइमिंग कितनी सटीक है।
| प्रोवाइडर | डॉक्स क्या देते हैं | अरबी |
|---|---|---|
| OpenAI | response_format srt, vtt या verbose_json, और timestamp_granularities[] word या segment, सिर्फ़ whisper-1 पर। gpt-4o-transcribe और gpt-4o-mini-transcribe सिर्फ़ json लौटाते हैं |
जाँचा नहीं गया। OpenAI का deprecations पेज whisper-1, gpt-4o-transcribe, gpt-4o-mini-transcribe और gpt-4o-transcribe-diarize को deprecated बताता है, सभी 26 फ़रवरी 2027 को बंद होंगे, और इनकी जगह gpt-transcribe या gpt-live-transcribe की सलाह देता है |
| AssemblyAI | GET /v2/transcript/{transcript_id}/srt या /vtt, chars_per_caption के साथ |
Universal-2 पर अरबी सूचीबद्ध, उसके 10 से 25% WER वाले वर्ग में |
| Speechmatics | transcript endpoint पर format=srt; max_line_length और max_lines के साथ srt_overrides; शब्द आइटम में start_time और end_time |
अरबी, और एक ar_en अरबी-अंग्रेज़ी पैक |
| Deepgram | शब्द और utterance टाइमस्टैम्प; SRT और WebVTT लिखने वाली आधिकारिक Python और JavaScript कैप्शन लाइब्रेरी | Nova-3 पर अरबी और क्षेत्रीय कोड |
| ElevenLabs | timestamps_granularity word या character; हर शब्द का start और end सेकंड में |
अरबी सूचीबद्ध, उसके 10 से 20% WER वाले वर्ग में |
| BroadNet Inference | सिर्फ़ {"text": ...} |
अरबी के लिए विशेष मॉडल और 14 भाषाओं वाला मॉडल |
अगर आप मॉडल ख़ुद चला सकते हैं, तो whisper.cpp के साथ बना FFmpeg का whisper filter सीधे srt लिख सकता है और छोटी लाइनों के लिए उसमें max_len विकल्प है।
अरबी सटीकता और कीमत की पहली तुलना के लिए अरबी speech-to-text API ख़रीदार गाइड और speech-to-text कीमतों की तुलना देखें। उस फ़ैसले में टाइमस्टैम्प एक पंक्ति है, अकेली नहीं।
सिर्फ़-टेक्स्ट API से सबटाइटल कैसे बनाएँ?
आप ऑडियो जहाँ काटते हैं, वहीं से अपने टाइमस्टैम्प बनाते हैं। चरण:
- ठहराव ढूँढें। FFmpeg का
silencedetectजहाँ भी स्तर किसी सीमा से नीचे न्यूनतम समय तक रहता है, वहाँsilence_startऔरsilence_endसेकंड में लॉग करता है। - ठहरावों को बोली के हिस्सों में बदलें। दो ख़ामोशियों के बीच का सब कुछ एक हिस्सा है। हिस्सों को लगभग 12 सेकंड पर सीमित करें, ताकि कभी न रुकने वाला वक्ता भी छोटे कैप्शन दे।
- हर हिस्सा ट्रांसक्राइब करें। उसे 16 kHz mono WAV में काटें और
language=arके साथ भेजें। - कैप्शन का समय तय करें। हिस्से की शुरुआत और अंत आपके आधार समय हैं। अगर उसके टेक्स्ट को कई लाइनें चाहिए, तो हिस्से का समय उनकी लंबाई के अनुपात में बाँटें।
- SRT लिखें और लाइन की लंबाई, पढ़ने की गति और अवधि को स्टाइल नियमों से जाँचें।
यह वही बँटवारा है जो लंबी ऑडियो फ़ाइलें ट्रांसक्राइब करने में है, बस लक्ष्य अलग है। वहाँ chunks लगभग 10 मिनट के होते हैं और आपको सिर्फ़ जुड़े हुए टेक्स्ट की परवाह होती है। यहाँ chunks कुछ सेकंड के होते हैं, क्योंकि हर एक कैप्शन का समय बनता है। अगर आप हाथ से काटना पसंद करते हैं, तो ऑडियो स्प्लिटर टूल FFmpeg कमांड बनाता है।
Python में पाइपलाइन
यह स्क्रिप्ट OpenAI Python SDK और FFmpeg इस्तेमाल करती है। हमने इसे 15 नवंबर 2026 को एक लोकल mock सर्वर पर चलाया, जो BroadNet के दस्तावेज़ित endpoint ({"text": ...}) की तरह जवाब देता है, और टोन व ख़ाली जगहों वाली एक बनाई गई टेस्ट फ़ाइल के साथ। ऊपर वाला SRT इसी का आउटपुट है। कोई BroadNet key इस्तेमाल नहीं हुई, इसलिए अरबी टेक्स्ट mock से आया, मॉडल से नहीं।
import os, re, subprocess, sys
from openai import OpenAI
FFMPEG = os.environ.get("FFMPEG", "ffmpeg")
client = OpenAI(base_url=os.environ.get("BASE_URL", "https://inference.broadnet.ai/v1"),
api_key=os.environ["BROADNET_API_KEY"])
MODEL = "broadnet/cohere-transcribe-arabic"
MAX_CHARS, MAX_LINES, MAX_CUE, MAX_CPS = 42, 2, 7.0, 20 # Netflix Arabic / general guide values
def find_speech(path, noise="-35dB", min_silence=0.4, max_span=12.0):
"""Return [(start, end)] seconds of speech between silences, each at most max_span long."""
log = subprocess.run([FFMPEG, "-hide_banner", "-nostats", "-i", path,
"-af", f"silencedetect=n={noise}:d={min_silence}", "-f", "null", "-"],
capture_output=True, text=True).stderr
h, m, s = re.search(r"Duration: (\d+):(\d+):([\d.]+)", log).groups()
total = int(h) * 3600 + int(m) * 60 + float(s)
starts = [float(x) for x in re.findall(r"silence_start: (-?[\d.]+)", log)]
ends = [float(x) for x in re.findall(r"silence_end: ([\d.]+)", log)]
spans, t = [], 0.0
for i, s0 in enumerate(starts):
if s0 - t > 0.2:
spans.append((t, s0))
t = ends[i] if i < len(ends) else total
if total - t > 0.2:
spans.append((t, total))
out = []
for a, b in spans: # no pause found: cut at a fixed length
while b - a > max_span:
out.append((a, a + max_span)); a += max_span
out.append((a, b))
return out
def transcribe_span(path, a, b, name):
subprocess.run([FFMPEG, "-hide_banner", "-loglevel", "error", "-y", "-ss", f"{a:.3f}",
"-to", f"{b:.3f}", "-i", path, "-ar", "16000", "-ac", "1", name], check=True)
with open(name, "rb") as f:
return client.audio.transcriptions.create(model=MODEL, file=f, language="ar").text.strip()
def to_cues(text, a, b):
"""Wrap text into lines of <= MAX_CHARS, give each line a share of the span's time
in proportion to its length, then pack lines into cues of <= MAX_LINES and <= MAX_CUE s."""
lines, cur = [], ""
for w in text.split():
if cur and len(cur) + 1 + len(w) > MAX_CHARS:
lines.append(cur); cur = w
else:
cur = f"{cur} {w}".strip()
if cur:
lines.append(cur)
chars = sum(len(l) for l in lines) or 1
cues, t = [], a
for line in lines:
d = (b - a) * len(line) / chars
last = cues[-1] if cues else None
if last and len(last[2]) < MAX_LINES and t + d - last[0] <= MAX_CUE:
last[1] = t + d; last[2].append(line)
else:
cues.append([t, t + d, [line]])
t += d
for c in cues: # a long pause inside a span: don't hold text on screen
c[1] = min(c[1], c[0] + MAX_CUE)
return cues
def ts(x):
ms = round(x * 1000)
return f"{ms // 3600000:02}:{ms // 60000 % 60:02}:{ms // 1000 % 60:02},{ms % 1000:03}"
def make_srt(path, out="out.srt"):
cues = []
for i, (a, b) in enumerate(find_speech(path)):
text = transcribe_span(path, a, b, f"chunk-{i:04}.wav")
if text:
cues += to_cues(text, a, b)
with open(out, "w", encoding="utf-8") as f:
for n, (a, b, g) in enumerate(cues, 1):
cps = len(" ".join(g)) / (b - a)
if b - a > MAX_CUE or cps > MAX_CPS:
print(f"check cue {n}: {b - a:.1f} s, {cps:.0f} chars/s", file=sys.stderr)
f.write(f"{n}\n{ts(a)} --> {ts(b)}\n" + "\n".join(g) + "\n\n")
return len(cues)
if __name__ == "__main__":
print(make_srt(sys.argv[1], sys.argv[2] if len(sys.argv) > 2 else "out.srt"), "cues written")
BROADNET_API_KEY सेट करके चलाएँ: python make_srt.py episode.wav episode.srt। टेस्ट फ़ाइल पर ठहराव की पहचान ने 0 से 2.8 s, 3.6 से 7.6 s, 8.8 से 28.8 s (12 s पर काटा गया क्योंकि उसमें कोई ठहराव नहीं था) और 29.4 से 30.9 s के हिस्से पाए, जो फ़ाइल बनाने के तरीक़े से मेल खाते थे। आउटपुट Python srt पैकेज से साफ़ पार्स हुआ और FFmpeg से WebVTT में बदल गया।
दो मान अपने ऑडियो के अनुसार ट्यून करें। noise वह स्तर है जिसे ख़ामोशी माना जाता है: साफ़ बोली के लिए -30 से -40 dB आज़माएँ और शोर वाले कमरों के लिए ऊँचा। min_silence यह है कि ख़ाली जगह कितनी देर की होनी चाहिए: 0.3 से 0.5 सेकंड हर साँस पर काटे बिना वाक्यों के बीच के ठहराव पकड़ता है।
chunk-स्तर की टाइमिंग कितनी सटीक है?
यह तरीक़ा क्या कर सकता है और क्या नहीं, इस बारे में साफ़ रहें।
- हिस्सों के किनारे सबसे अच्छा भाग हैं। असली ठहराव पर पड़ने वाली कैप्शन की शुरुआत और अंत उतनी ही सटीक हैं जितनी ख़ामोशी की पहचान। हमारी सिंथेटिक टेस्ट फ़ाइल पर ये बिल्कुल मेल खाए; साँसों और कमरे के शोर वाली असली रिकॉर्डिंग ज़्यादा उलझी होती हैं।
- हिस्से के अंदर के समय अनुमान हैं। जब किसी हिस्से में दो या तीन कैप्शन होते हैं, तो स्क्रिप्ट उसका समय कैरेक्टर की गिनती से बाँटती है। वक्ता एक समान गति से नहीं बोलते, इसलिए अंदर की सीमाएँ एक सेकंड या ज़्यादा खिसक सकती हैं।
- तय कट शब्दों को काट सकते हैं। जब कोई हिस्सा बिना ठहराव के 12 सेकंड की सीमा पार करता है, तो कट जहाँ पड़े, वहीं पड़ता है। कट पर पड़ा शब्द खो सकता है या बिगड़ सकता है। पहले
noiseबढ़ाएँ याmin_silenceघटाएँ, ताकि कम हिस्सों को तय कट चाहिए। - छोटे chunks मॉडल को कम कॉन्टेक्स्ट देते हैं। 3 सेकंड की क्लिप में हर शब्द के आसपास 10 मिनट की फ़ाइल से कम शब्द होते हैं। हमने नहीं मापा कि इससे अरबी सटीकता कितनी बदलती है; इसे अपने ऑडियो पर WER से टेस्ट करें।
- स्पीकर लेबल नहीं। BroadNet कोई diarization नहीं लौटाता, इसलिए कैप्शन यह नहीं बताते कि कौन बोल रहा है।
- संगीत और शोर। बैकग्राउंड संगीत ठहराव पूरी तरह छिपा सकता है। तब ज़्यादातर हिस्से तय कट होते हैं, और टाइमिंग बिगड़ती है।
लेक्चर, पॉडकास्ट, वेबिनार और ट्रेनिंग वीडियो के लिए बोली से एक सेकंड के भीतर के कैप्शन आम तौर पर पढ़ने लायक होते हैं। ड्रामा, म्यूज़िक वीडियो या lip-sync वाली किसी भी चीज़ के लिए शब्द टाइमस्टैम्प वाला प्रोवाइडर इस्तेमाल करें, या किसी सबटाइटलर से फ़ाइल ठीक करवाएँ।
लागत क्या है, और यह कितना तेज़ है?
कीमत ऑडियो की लंबाई के हिसाब से है। BroadNet Transcribe Arabic पर एक घंटे की अरबी की लागत $0.25 है, चाहे आप उसे एक फ़ाइल में भेजें या पाँच-पाँच सेकंड की 720 फ़ाइलों में। BroadNet का कीमत पेज प्रति ऑडियो मिनट कीमत बताता है और प्रति फ़ाइल कोई न्यूनतम नहीं; पुष्टि के लिए पहले एपिसोड के बाद usage पेज देखें।
स्पीड अनुरोधों की संख्या के हिसाब से है। उपयोग के अनुसार भुगतान वाली key प्रति मिनट 30 अनुरोध और 4 in flight देती है। 5 सेकंड के हिस्सों में बँटी एक घंटे की बोली लगभग 720 अनुरोध है, जिसमें कम से कम 720 ÷ 30 मिनट लगते हैं। लंबे हिस्सों का मतलब कम अनुरोध। अगर 429 आए, तो एरर और retry गाइड के अनुसार रुकें, और प्रकाशित सीमाओं से बचने के लिए एक job को कई keys में न फैलाएँ।
BroadNet Inference कहाँ फ़िट होता है
BroadNet Transcribe Arabic सबटाइटल job के टेक्स्ट वाले हिस्से के लिए ठीक है: $0.0042 प्रति मिनट पर अरबी बोली से अरबी टेक्स्ट, और अनुरोध के बाद ऑडियो और ट्रांसक्रिप्ट नहीं रखे जाते। $5 का शुरुआती क्रेडिट ट्रांसक्रिप्शन को कवर करता है, इसलिए टॉप-अप से पहले आप असली एपिसोड पर पाइपलाइन टेस्ट कर सकते हैं। यह टाइमस्टैम्प, segments, स्पीकर लेबल या SRT नहीं लौटाता। अगर आपके सबटाइटल को शब्द-स्तर की टाइमिंग चाहिए, तो उसे दस्तावेज़ित करने वाला प्रोवाइडर इस्तेमाल करें, या forced-alignment टूल से BroadNet के टेक्स्ट को ऑडियो से मिलाएँ। अनुरोध का ढाँचा और सीमाएँ BroadNet API रेफ़रंस में हैं, और सेटअप अरबी speech-to-text गाइड में।
