DEV Community

Cover image for ffmpeg से सीन कट कैसे ढूँढें और वीडियो को ठीक उन्हीं कट पर कैसे split करें

ffmpeg से सीन कट कैसे ढूँढें और वीडियो को ठीक उन्हीं कट पर कैसे split करें

एडिट किए हुए वीडियो में कट ढूँढना ffmpeg एक ही filter से कर देता है, और ज़्यादातर गाइड यहीं रुक जाती हैं: select='gt(scene,0.4)',showinfo, timestamps पढ़ो, काम खत्म। लेकिन असली एडिट पर इसके बाद भी दो सवाल बचे रहते हैं। कौन-सा threshold कट को कैमरा शेक से अलग करता है, और उन timestamps को ऐसी फ़ाइलों में कैसे बदलें जो सच में कट से ही शुरू हों? osFoundry डेस्कटॉप ऐप का वीडियो एडिटर पहला हिस्सा Rust में करता है (canvas_operations.rs में canvas_scene_split) और दूसरे हिस्से से पूरी तरह बच निकलता है। नीचे दोनों हिस्सों को Python में दोबारा बनाया गया है और एक वीडियो पर मापा गया है, उन नंबरों के साथ जो हर फ़ैसला तय करते हैं।

टेस्ट फ़ाइल NASA की public-domain launch highlights है, Artemis II टेस्ट फ़्लाइट से: 92 सेकंड का H.264, 640×360, 30 fps, 2,760 फ़्रेम, 19 shots से कटा हुआ। सारी timings Apple M1 पर ffmpeg 7.1 और Python 3.9 के साथ ली गई हैं।

कट डिटेक्ट करना

कमांड वही है जो हर गाइड दिखाती है। जिस बात में लोगों की पूरी दोपहर चली जाती है, वह यह है कि output जाता कहाँ है: showinfo ffmpeg के log में लिखता है, और वह stderr है। stdout पढ़ेंगे तो ठीक चले हुए run से भी खाली list मिलेगी।

import re, subprocess

def detect(video, threshold):
    vf = f"select='gt(scene,{threshold})',showinfo"
    p = subprocess.run(["ffmpeg", "-hide_banner", "-i", video, "-an",
                        "-filter_complex", vf, "-f", "null", "-"],
                       capture_output=True, text=True)
    return [round(float(t) * 1000)
            for t in re.findall(r"pts_time:([0-9.]+)", p.stderr)]
Enter fullscreen mode Exit fullscreen mode

0.27 पर, जो ऐप का default है, यह milliseconds में 18 कट टाइम लौटाता है, 3,133 से 73,033 तक। यह pass 0.80 s में पूरा हुआ (5 runs का median), यानी डिटेक्शन इतना सस्ता है कि जब चाहें दूसरे threshold के साथ फिर से चला सकते हैं।

scene score असल में क्या मापता है

threshold चुनना आसान हो जाता है जब पता हो कि यह नंबर है क्या। libavfilter/f_select.c में get_scene_score इस फ़्रेम और पिछले फ़्रेम के बीच mean absolute difference (mafd) निकालता है, फिर उसमें से पिछले फ़्रेम का mafd घटाता है:

score = min(mafd, |mafd - prev_mafd|) / 100
Enter fullscreen mode Exit fullscreen mode

YUV input में सिर्फ़ luma plane की तुलना होती है। इसलिए Python की कुछ लाइनों में यह score दोबारा बनाया जा सकता है, और कोई अजीब value समझने का यही सबसे तेज़ तरीका है:

def luma(video, n):
    p = subprocess.run(["ffmpeg", "-v", "error", "-i", video,
                        "-vf", f"select='eq(n,{n})'", "-frames:v", "1",
                        "-f", "rawvideo", "-pix_fmt", "yuv420p", "-"],
                       capture_output=True)
    return p.stdout[:640 * 360]   # Y plane only

def mafd(a, b):
    return sum(abs(x - y) for x, y in zip(a, b)) / len(a)

f0, f1, f2 = (luma(VIDEO, k) for k in (n - 2, n - 1, n))
prev, cur = mafd(f0, f1), mafd(f1, f2)
score = min(cur, abs(cur - prev)) / 100
Enter fullscreen mode Exit fullscreen mode

Y plane को -pix_fmt gray माँगने के बजाय yuv420p से लेना ज़रूरी है: gray conversion value range को खींच देता है और दोबारा बनाए गए scores करीब 16 % ज़्यादा आए। raw Y plane के साथ इस वीडियो के चार फ़्रेम ffmpeg के अपने scores से मैच करते हैं:

फ़्रेम क्या होता है mafd पिछला mafd score
33.300 s भीड़ पर hard cut 57.12 1.31 0.558
33.333 s उस कट के ठीक बाद वाला फ़्रेम 13.75 57.12 0.138
58.567 s इंजन ignition पर कैमरा शेक 27.03 10.88 0.161
63.667 s पैड से चौड़े आसमान वाले shot पर कट 34.64 0.90 0.337

ऊपर: ignition पर लगातार दो फ़्रेम, score 0.161। नीचे: पैड से wide shot पर कट, score 0.337

यही घटाव चलते हुए shots को कट बनने से रोकता है। ignition वाला फ़्रेम अपने पिछले फ़्रेम से औसतन 27 brightness levels अलग है, जो भीड़ वाले कट के बाद के फ़्रेम से दोगुना है। लेकिन उससे पहले वाला फ़्रेम पहले ही 10.9 बदल चुका था, इसलिए सिर्फ़ बढ़त गिनी जाती है और score 0.16 आता है। पैड से आसमान वाला कट कई दूसरे कट से कम बदलाव करता है, लेकिन वह लगभग स्थिर फ़्रेम के बाद आता है, इसलिए उसका score 0.34 है। कट का मतलब बदलाव में अचानक उछाल है, सिर्फ़ ज़्यादा बदलाव नहीं।

डेटा से threshold चुनना

अंदाज़ा लगाने के बजाय एक बार हर फ़्रेम का score dump करें और देखें कि gap कहाँ है:

ffmpeg -i launch.mp4 -an -vf "select='gte(scene,0)',metadata=print:file=-" -f null - \
  | grep -o 'scene_score=[0-9.]*'
Enter fullscreen mode Exit fullscreen mode

इस वीडियो का median फ़्रेम 0.0015 score करता है। सत्रह फ़्रेम 0.5 से ऊपर हैं, एक 0.337 पर है, और उसके बाद सबसे ऊँचा ignition वाला फ़्रेम है, 0.161 पर। 0.162 और 0.337 के बीच कोई भी threshold वही 18 कट लौटाता है। sweep, कट के बीच 500 ms के minimum gap के साथ और बिना:

threshold उससे ऊपर फ़्रेम 500 ms gap के बाद कट
0.08 27 20
0.10 24 20
0.12 20 19
0.15 19 19
0.20 18 18
0.27 18 18
0.35 17 17
0.40 17 17
0.50 17 17

ffmpeg mailing list और कई tutorials जो 0.3–0.5 की range सुझाते हैं, उसका ज़्यादातर हिस्सा इस वीडियो के लिए बहुत ऊँचा है: 0.35 और उससे ऊपर पैड से आसमान वाला कट गायब हो जाता है। 0.15 और उससे नीचे ignition कट बनाने लगता है। तेज़ motion वाली footage पर safe band काफ़ी पतला हो सकता है, इसलिए किसी और के वीडियो से लिया नंबर मानने से पहले distribution पर एक नज़र डाल लेना ठीक रहता है।

minimum gap

0.08 से 0.12 वाली rows दिखाती हैं कि ऐप पिछले hit के बहुत जल्दी बाद आने वाले hits को क्यों छोड़ देता है (parse_scene_times, default 500 ms)। 0.12 पर 33.300 s वाला कट अगले फ़्रेम 33.333 s पर फिर से fire होता है, क्योंकि वह फ़्रेम अब भी अपने पड़ोसी से 13.75 अलग है, जबकि उससे पहले का उछाल बहुत बड़ा था। 0.08 पर ignition 57.7 s और 59.0 s के बीच आठ hits देता है। आधे सेकंड का gap हर burst को एक marker में समेट देता है:

def min_gap(hits, gap_ms=500):
    out = []
    for ms in hits:
        if not out or ms - out[-1] >= gap_ms:
            out.append(ms)
    return out
Enter fullscreen mode Exit fullscreen mode

यह कम threshold को ठीक नहीं करता, सिर्फ़ duplicates हटाता है। 0.08 पर gap के बाद भी ignition में दो गलत कट बचे रहते हैं।

-c copy से split करने पर फ़ाइलें कट पर नहीं बनतीं

अगला सीधा कदम है ffmpeg का segment muxer, stream copy के साथ:

ffmpeg -i launch.mp4 -c copy -f segment -segment_times 3.133,6.333,... \
  -reset_timestamps 1 scene%02d.mp4
Enter fullscreen mode Exit fullscreen mode

इसमें 0.05 s लगे और 18 फ़ाइलें बनीं, 19 नहीं, और सब 3.3 से 6.0 सेकंड लंबी थीं। जबकि असली सीन 1.5 से 19.0 सेकंड तक के हैं। stream copy किसी फ़ाइल को सिर्फ़ keyframe से शुरू कर सकता है, और इस encode में ऐसे 18 हैं, ज़्यादा से ज़्यादा 6 सेकंड के अंतर पर। ffprobe -skip_frame nokey उन्हें list करता है:

ffprobe -v error -select_streams v -skip_frame nokey \
  -show_entries frame=pts_time -of csv=p=0 launch.mp4
Enter fullscreen mode Exit fullscreen mode

18 में से सिर्फ़ 5 कट keyframe पर पड़ते हैं, वही जहाँ original encoder ने संयोग से एक keyframe रख दिया था। बाकी हर फ़ाइल boundary देर से आती है, सबसे खराब करीब 4 सेकंड देर से, और जहाँ दो कट का अगला keyframe एक ही है, वहाँ दोनों एक boundary में मिल जाते हैं।

re-encode, और आधे फ़्रेम का जाल

हर कट पर keyframe force करके re-encode करने से boundaries कहीं भी पड़ सकती हैं:

ffmpeg -i launch.mp4 -c:v libx264 -crf 18 -preset fast -c:a aac \
  -force_key_frames "$T" -f segment -segment_times "$T" \
  -reset_timestamps 1 scene%02d.mp4
Enter fullscreen mode Exit fullscreen mode

$T में milliseconds तक round किए गए डिटेक्टेड टाइम डालने पर 19 फ़ाइलें बनीं, फिर भी 18 में से 4 कट एक फ़्रेम देर से आए। एक कट पूरी तरह छूट गया, जिससे दो सीन मिलकर 12.3 सेकंड की एक फ़ाइल बन गए, और एक फ़ालतू फ़ाइल में सिर्फ़ एक फ़्रेम था। वजह rounding है। फ़्रेम 269 वाला कट 8.9666… s पर है, और "8.967" उसके ठीक बाद पड़ता है, इसलिए comparison अगला फ़्रेम चुन लेता है। देर से आए चारों कट ऐसे टाइम पर हैं जो दोहराते 6 पर खत्म होते हैं, और 44.067 s वाला फ़ालतू फ़्रेम भी।

हर टाइम को आधा फ़्रेम पहले खिसकाने से (30 fps पर 1/60 s) वह बिना किसी शक के कट फ़्रेम से पहले आ जाता है:

T = ",".join(f"{ms / 1000 - 0.5 / 30:.4f}" for ms in cuts)
Enter fullscreen mode Exit fullscreen mode

इस बदलाव के बाद सभी 18 boundaries कट फ़्रेम पर पड़ीं और 19 फ़ाइलों की लंबाई सीन की लंबाई से फ़्रेम तक मैच हुई। 92 सेकंड की क्लिप का re-encode 6.9 s में हुआ और 15.2 MB लिखे गए, जबकि CRF 18 पर source 18.2 MB का है।

या फ़ाइलें लिखें ही नहीं

ऐप तीसरा रास्ता लेता है। उसके Split at बटन canvas_layers.rs में canvas_split_clip को call करते हैं, जो चुनी हुई क्लिप को छोटा करता है और उसी asset पर बाद वाले in-point के साथ एक नई क्लिप जोड़ देता है। कुछ भी decode या write नहीं होता, इसलिए न keyframe की समस्या है और न generation loss, और encode सिर्फ़ एक बार होता है, जब पूरा एडिट export किया जाता है। अगर मकसद किसी को 19 फ़ाइलें देना नहीं बल्कि वीडियो को दोबारा काटना है, तो यही तरीका अपनाने लायक है: कट list को in/out points के रूप में रखें और frame-accurate काम final render पर छोड़ दें।

पूरी script, ऊपर के सारे measurements के साथ, ffmpeg और ffprobe के आसपास standard-library Python की करीब 120 लाइनें है। osFoundry डेस्कटॉप ऐप में यही डिटेक्शन वीडियो एडिटर का Find the cuts preset है, और यह आपकी अपनी मशीन पर चलता है, जैसा local-first पेज पर बताया गया है। ऐप osFoundry डाउनलोड पेज से मुफ़्त मिलता है।

Top comments (0)