0.5 ? T.accent : T.line, border: `2px solid ${T.line}`, boxSizing: "border-box" }}>
0.5 ? T.bg : T.text }} />
;
};
// шапка шага: номер, название и точки хода «шаг n из total»
export const StepHead: React.FC<{ n: number; total?: number; title?: string; o: number }> = ({ n, total = 4, title, o }) => {
const T = useTheme();
return (
{n}
{title ?
{title}
: null}
{Array.from({ length: total }, (_, k) => k + 1).map((i) =>
)}
);
};
```
```tsx
// Три раскладки кадра, субтитры, сцена со свечением. Под ролик не меняется: всё, что зависит от ролика, лежит в scenes.tsx.
import React from "react";
import { AbsoluteFill, Easing, OffthreadVideo, interpolate, staticFile, useCurrentFrame } from "remotion";
import { D, PALETTES, SANS, Sub, Theme, ThemeProvider, clamp, useTheme } from "./kit";
import { BOX, MODE, PALETTE, SCENES, SPEAKER } from "./scenes";
export const REEL_FRAMES = D.frames;
export const sceneAt = (f: number) => { let k = 0; for (let i = 0; i < SCENES.length; i++) if (f >= SCENES[i].from) k = i; return k; };
// сцена 1080×1000 со свечением; пятно переезжает к новой сцене за 18 кадров
const Stage: React.FC = () => {
const f = useCurrentFrame();
const T = useTheme();
const k = sceneAt(f), S = SCENES[k], P = SCENES[Math.max(0, k - 1)];
const p = interpolate(f, [S.from, S.from + 18], [0, 1], { ...clamp, easing: Easing.inOut(Easing.cubic) });
const gx = P.gx + (S.gx - P.gx) * p, gy = P.gy + (S.gy - P.gy) * p;
return (
);
};
const Staged: React.FC<{ theme: Theme; x: number; y: number; scale: number }> = ({ theme, x, y, scale }) => (
);
// человек: кадр 1080×1920 (base.mp4 1152×2048 показывается в размер), y0 – с какой высоты кадра показывать, scale – увеличение от верха
const Speaker: React.FC<{ top: number; height: number; y0: number; fade?: string; scale?: number }> = ({ top, height, y0, fade, scale = 1 }) => (
);
// Субтитры: фраза целиком или ничего (hide); плашка только поверх видео и в цвет карточки палитры
const Subs: React.FC<{ list: Sub[]; y: number; size: number; plate?: Theme; color: string }> = ({ list, y, size, plate, color }) => {
const f = useCurrentFrame();
const s = list.find((x) => f >= x.from && f < x.to);
if (!s || s.hide) return null;
return (
);
};
const STARS = Array.from({ length: 90 }, (_, i) => { const r = (n: number) => { const v = Math.sin(i * 127.1 + n * 311.7) * 43758.5453; return v - Math.floor(v); }; return { x: r(1) * 1080, y: r(2) * 1920, s: 2 + r(3) * 4, o: 0.25 + r(4) * 0.6, ph: r(5) * 6 }; });
const Stars: React.FC = () => {
const f = useCurrentFrame();
return <>{STARS.map((s, i) =>
)};
};
// карточка под подбородком: сцена вписывается в неё по рамке содержимого BOX, внутренних рамок нет (flat)
const CARD = { left: 190, top: 1050, w: 700, h: 420 };
const OverCard: React.FC<{ theme: Theme }> = ({ theme }) => {
const f = useCurrentFrame();
const S = SCENES[sceneAt(f)];
const [x0, y0, x1, y1] = BOX[S.name];
const sc = Math.min((CARD.w - 56) / (x1 - x0), (CARD.h - 48) / (y1 - y0), 0.86);
return (
);
};
const SPLIT = 770, SPLIT_SC = 0.72;
export const Reel: React.FC = () => {
const f = useCurrentFrame();
const T = PALETTES[PALETTE];
const mode = MODE[SCENES[sceneAt(f)].name];
return (
{mode === "split" ? (
<>
) : mode === "full" ? (
<>
) : (
<>
)}
);
};
```
```tsx
// Сцены ЭТОГО ролика. Пишется заново под каждый текст. Номера слов – из `python3 tools/gen_data.py --list`.
// Ниже рабочий образец на пять сцен: замени номера слов, тексты и предметы под свою речь.
import React from "react";
import { useCurrentFrame } from "remotion";
import { Badge, Balloon, Bubble, Check, Cross, Cursor, Doc, Dots, Folder, Lines, Monitor, Person, Pill, SANS, StepHead, WinBar, Wavy, at, cardStyle, clickAt, en, pop, rise, springAt, tileStyle, up, usePath, usePop, useTheme, useTyped, useWords } from "./kit";
export const PALETTE = "graphite"; // раздел 8: ключ палитры
export const SPEAKER = { splitY0: 390, overShift: 115, overScale: 1.06 }; // раздел 7: подогнать под кадр
// 1. Хук: первая фраза печатается тремя строками, под ней две плитки «✓ / ✕» (раскладка over)
const Hook: React.FC = () => {
const T = useTheme();
const t = useWords(0, 8, [4, 6]); // слова 0–8, перенос после 4-го и 6-го
const left = usePop(at(3)), ok = usePop(at(3) + 8), right = usePop(at(7)), no = usePop(at(7) + 6);
return (
<>
);
};
// 2. Цифра: крупное число на своём слове, подпись и ряд плиток (раскладка over)
const BigNumber: React.FC = () => {
const T = useTheme();
const f = useCurrentFrame();
const big = usePop(at(18) - 2), word = up(f, at(19), 7);
return (
<>
4
настройки
{[Doc, Folder, Bubble, Monitor].map((Ic, i) => (
))}
);
};
// 3. Окно программы и курсор: нажатие на слове действия, затем появляется поле (раскладка split)
const AppWindow: React.FC = () => {
const T = useTheme();
const f = useCurrentFrame();
const a = up(f, at(27), 8), page = up(f, at(38) + 4, 7);
const c = usePath([[at(30) - 8, 760, 700], [at(33), 150, 790], [at(37), 150, 790], [at(38), 600, 560]]);
const click = Math.max(clickAt(f, at(33)), clickAt(f, at(38)));
return (
<>
{[0, 1, 2, 3].map((i) =>
)}
);
};
// 4. Цитата в облачке: три точки, пока цитата не началась, потом она печатается (раскладка full)
const Quote: React.FC = () => {
const T = useTheme();
const f = useCurrentFrame();
const a = up(f, at(45), 8);
const q = useWords(47, 55, [50]);
return (
<>
{f < at(47) ?
: null}
);
};
// 5. Финал: мораль печатается, главное акцентом, волнистая черта (раскладка over)
const Final: React.FC = () => {
const T = useTheme();
const f = useCurrentFrame();
const last = 60; // номер последнего слова морали
const t = useTyped([[56, "Главная"], [57, " мысль"], [58, "\nролика"], [59, " вот"], [last, " такая"]]);
return (
);
};
export type Mode = "over" | "split" | "full";
// расписание: сцена начинается с кадра from; gx, gy – где свечение (проценты сцены)
export const SCENES: { from: number; name: string; C: React.FC; gx: number; gy: number }[] = [
{ from: 0, name: "hook", C: Hook, gx: 50, gy: 34 },
{ from: at(17), name: "number", C: BigNumber, gx: 30, gy: 30 },
{ from: at(27), name: "app", C: AppWindow, gx: 40, gy: 60 },
{ from: at(45), name: "quote", C: Quote, gx: 50, gy: 50 },
{ from: at(56), name: "final", C: Final, gx: 44, gy: 40 },
];
export const MODE: Record
= { hook: "over", number: "over", app: "split", quote: "full", final: "over" };
// рамка содержимого каждой сцены [x0, y0, x1, y1] на сцене 1080×1000 – по ней сцена вписывается в карточку раскладки over
export const BOX: Record = {
hook: [72, 190, 1008, 690], number: [72, 170, 1008, 640], app: [72, 140, 1008, 880], quote: [72, 150, 1008, 820], final: [72, 250, 1008, 470],
};
```
```python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Данные ролика: основа видео, голос, кадры слов, фразы, субтитры. Настройки в work/edit.json (раздел 6 скилла).
python3 tools/gen_data.py --list печать слов с номерами и кадрами и фраз
python3 tools/gen_data.py --base пересобрать основу видео и голос принудительно"""
import json, math, os, re, subprocess, sys
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
FF = os.environ.get("FFMPEG", "ffmpeg"); FP = os.environ.get("FFPROBE", "ffprobe"); FPS = 30
CFG = json.load(open(os.path.join(ROOT, "work", "edit.json"), encoding="utf-8"))
SRC = CFG["source"]
BASE = os.path.join(ROOT, "public", "base.mp4"); VOICE = os.path.join(ROOT, "work", "voice.wav")
SEGF = os.path.join(ROOT, "work", "segments.json")
GRADE = "curves=all='0/0 0.25/0.245 0.55/0.60 0.83/0.90 1/1',eq=saturation=1.04,vignette=angle=PI/7"
os.makedirs(os.path.join(ROOT, "public"), exist_ok=True)
def run(a): subprocess.run([FF, "-nostdin", "-y", "-v", "error"] + a, check=True)
def probe(args, path): return subprocess.run([FP, "-v", "error"] + args + ["-of", "default=nw=1:nk=1", path], stdout=subprocess.PIPE, text=True).stdout.strip()
# 1. тишина в исходнике (по ней поправляется начало слов после пауз)
out = subprocess.run([FF, "-nostdin", "-hide_banner", "-i", SRC, "-vn", "-af", "silencedetect=noise=-40dB:d=0.2", "-f", "null", "-"], stderr=subprocess.PIPE).stderr.decode(errors="ignore")
sil, cs = [], None
for m in re.finditer(r"silence_(start|end): ([\d.]+)", out):
if m.group(1) == "start": cs = float(m.group(2))
elif cs is not None: sil.append((cs, float(m.group(2)))); cs = None
# 2. слова: правки fix / merge / drop (номера по СЫРОЙ расшифровке)
d = json.load(open(os.path.join(ROOT, CFG["transcript"]), encoding="utf-8"))
raw = [w for s in d["segments"] for w in s.get("words", [])]
fix = {int(k): v for k, v in CFG.get("fix", {}).items()}; merge = set(CFG.get("merge", [])); drop = set(CFG.get("drop", []))
ws = []
for i, w in enumerate(raw):
t = fix.get(i, w["word"].strip()); a, b = float(w["start"]), float(w["end"])
if i in drop: continue
if i in merge and ws: ws[-1]["end"] = b; continue
for s_, e in sil: # Whisper растягивает слово на паузу перед ним: начало = конец тишины
if s_ <= a + 0.06 and a < e < b: a = max(a, e - 0.03)
ws.append({"t": t, "start": a, "end": b, "raw": i})
# предупреждения о зацикливании расшифровки
for i in range(len(raw) - 3):
if len({round(float(raw[k]["start"]), 2) for k in range(i, i + 4)}) == 1:
print(f"⚠️ слова {i}–{i + 3} сырой расшифровки начинаются в одно время ({raw[i]['start']}): похоже на зацикливание Whisper"); break
for i, w in enumerate(raw):
if re.search(r"(?i)субтитр|продолжение следует|подписывайтесь|redactor|dimatorzok", w["word"]): print(f"⚠️ слово {i} «{w['word'].strip()}» похоже на выдумку Whisper: проверь и убери через drop")
# 3. шкала времени: куски исходника, которые остаются (в кадрах)
dur = float(probe(["-show_entries", "format=duration"], SRC))
t0, t1 = max(0.0, ws[0]["start"] - 0.09), min(dur - 0.02, ws[-1]["end"] + 0.2)
thr = float(CFG.get("cut_pauses_over", 0) or 0)
cuts = [[t0, None]]
if thr > 0:
for p, n in zip(ws, ws[1:]):
if n["start"] - p["end"] > thr: cuts[-1][1] = p["end"] + 0.12; cuts.append([n["start"] - 0.12, None])
cuts[-1][1] = t1
segs = [(int(math.floor(a * FPS)), int(math.ceil(b * FPS))) for a, b in cuts]
offs, acc = [], 0
for a, b in segs: offs.append(acc); acc += b - a
FRAMES = acc
def fr(t):
x = t * FPS
for (a, b), o in zip(segs, offs):
if x < a: return o # попало в вырезанную паузу: к началу следующего куска
if x < b: return int(round(o + x - a))
return FRAMES - 1
# 4. основа видео и голос одним проходом, по одним и тем же кадрам
need = "--base" in sys.argv or not os.path.exists(BASE) or not os.path.exists(VOICE) or not os.path.exists(SEGF) or json.load(open(SEGF)) != {"src": SRC, "segs": segs, "grade": CFG.get("grade", True)}
if need:
n = len(segs); g = ("," + GRADE) if CFG.get("grade", True) else ""
fc = [f"[0:v]fps={FPS},split={n}" + "".join(f"[v{i}]" for i in range(n)), "[0:a]aresample=48000,asplit=" + str(n) + "".join(f"[a{i}]" for i in range(n))]
for i, (a, b) in enumerate(segs):
fc.append(f"[v{i}]trim=start_frame={a}:end_frame={b},setpts=PTS-STARTPTS[w{i}]")
fc.append(f"[a{i}]atrim=start={a / FPS:.6f}:end={b / FPS:.6f},asetpts=PTS-STARTPTS[x{i}]")
fc.append("".join(f"[w{i}][x{i}]" for i in range(n)) + f"concat=n={n}:v=1:a=1[cv][ca]")
fc.append(f"[cv]scale=1152:2048:force_original_aspect_ratio=increase:flags=lanczos,crop=1152:2048{g},format=yuv420p[vo]")
print(f"собираю основу: {n} кус., {FRAMES} кадров = {FRAMES / FPS:.2f} с …")
run(["-i", SRC, "-filter_complex", ";".join(fc),
"-map", "[vo]", "-an", "-c:v", "libx264", "-preset", "fast", "-crf", "13", "-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709", "-color_range", "tv", BASE,
"-map", "[ca]", "-vn", "-ac", "1", "-c:a", "pcm_s16le", VOICE])
nf = int(probe(["-count_frames", "-select_streams", "v:0", "-show_entries", "stream=nb_read_frames"], BASE))
vd = float(probe(["-show_entries", "format=duration"], VOICE))
assert nf == FRAMES, f"в основе {nf} кадров, а должно быть {FRAMES}"
assert abs(vd - FRAMES / FPS) < 0.05, f"голос {vd:.3f} с, видео {FRAMES / FPS:.3f} с: рассинхрон"
json.dump({"src": SRC, "segs": segs, "grade": CFG.get("grade", True)}, open(SEGF, "w"))
# 5. фразы: номер последнего слова каждой (ends); если не заданы – черновик по знакам препинания
def clean(t): return t.strip(".,!?«»:;…\"")
ends = CFG.get("ends") or []
if not ends:
st = 0
for i, w in enumerate(ws):
if (re.search(r"[.!?…:;,»]$", w["t"]) and i - st >= 1) or i - st >= 7: ends.append(i); st = i + 1
if not ends or ends[-1] != len(ws) - 1: ends.append(len(ws) - 1)
print("⚠️ ends не заданы: фразы разбиты черновиком по знакам препинания, поправь в edit.json")
assert ends == sorted(ends) and ends[-1] == len(ws) - 1, f"ends: последнее слово должно быть {len(ws) - 1}"
# 6. субтитры: фраза делится на куски по 2–5 слов, не длиннее ~24 знаков, кусок не кончается предлогом
GLUE = {"в", "на", "к", "с", "и", "а", "но", "что", "как", "не", "из", "от", "у", "за", "их", "его", "бы", "чем", "же", "до", "он", "я", "им", "было", "для", "ещё", "вы", "под", "перед", "со", "по", "при", "над", "о", "об", "про", "без", "через"}
def split_cue(cue):
n = len(cue); best = {0: (0, [])}
for i in range(1, n + 1):
cand = None
for k in (1, 2, 3, 4, 5):
if i - k < 0: continue
part = cue[i - k:i]; chars = len(" ".join(clean(w["t"]) for w in part)); pen = best[i - k][0]
if chars > 24: pen += 20
if k == 5: pen += 6
if k == 1 and n > 1: pen += 100
if i < n and clean(part[-1]["t"]).lower() in GLUE: pen += 10
pen += abs(k - min(3, n)) * 0.5 + 0.03 * abs(chars - 14)
if cand is None or pen < cand[0]: cand = (pen, best[i - k][1] + [k])
best[i] = cand
out, pos = [], 0
for k in best[n][1]: out.append(cue[pos:pos + k]); pos += k
return out
SHOW, WHOLE = set(CFG.get("show", [])), set(CFG.get("whole", []))
subs, phrases, a = [], [], 0
for ci, e in enumerate(ends):
cue = ws[a:e + 1]; a = e + 1; phrases.append(" ".join(clean(w["t"]) for w in cue))
for part in ([cue] if ci in WHOLE else split_cue(cue)):
subs.append({"from": fr(part[0]["start"]), "to": fr(part[-1]["end"]), "text": " ".join(clean(w["t"]) for w in part), "hide": ci not in SHOW})
for i in range(len(subs) - 1): subs[i]["to"] = min(subs[i]["to"] + 3, subs[i + 1]["from"])
shown = [s["text"] for s in subs if not s["hide"]]
for t in shown:
if len(t.split()) < 2: print(f"⚠️ субтитр из одного слова: «{t}» – добавь фразу в whole или пересобери фразы")
json.dump({"frames": FRAMES, "ws": [fr(w["start"]) for w in ws], "we": [fr(w["end"]) for w in ws], "wt": [w["t"] for w in ws], "subs": subs},
open(os.path.join(ROOT, "src", "reel", "data.json"), "w", encoding="utf-8"), ensure_ascii=False)
print(f"кадров {FRAMES} = {FRAMES / FPS:.2f} с | слов {len(ws)} | фраз {len(ends)} | субтитров показано {len(shown)}")
if "--list" in sys.argv:
print(" ".join(f"{i}:{w['t']}@{fr(w['start'])}" for i, w in enumerate(ws)))
for i, p in enumerate(phrases): print(("👁 " if i in SHOW else " ") + f"{i} {p}")
```
```python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Расшифровка по словам через faster-whisper (Windows, Linux, Intel Mac). Выход в формате mlx-whisper.
python3 tools/transcribe.py work/a16.wav work/run1/a16.json large-v3 "подсказка: начало сценария, имена, термины" """
import json, os, sys
from faster_whisper import WhisperModel
src, dst = sys.argv[1], sys.argv[2]
model = sys.argv[3] if len(sys.argv) > 3 else "large-v3"
prompt = sys.argv[4] if len(sys.argv) > 4 else None
m = WhisperModel(model, device="auto", compute_type="int8")
segs, _ = m.transcribe(src, language="ru", word_timestamps=True, initial_prompt=prompt, condition_on_previous_text=False, vad_filter=False)
out = {"segments": [{"text": s.text, "words": [{"word": w.word, "start": w.start, "end": w.end} for w in (s.words or [])]} for s in segs]}
os.makedirs(os.path.dirname(dst) or ".", exist_ok=True)
json.dump(out, open(dst, "w", encoding="utf-8"), ensure_ascii=False)
print("слов:", sum(len(s["words"]) for s in out["segments"]))
```
```python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Три коротких удара для акцентов (синтез, без чужих сэмплов): tools/hits/hit_a.wav, hit_b.wav, hit_c.wav. Пик −1 dBFS."""
import math, os, random, struct, wave
SR = 48000; OUT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "hits"); os.makedirs(OUT, exist_ok=True)
random.seed(7)
def env(t, T, att, dec): return min(1.0, t / att) * math.exp(-t * dec) * min(1.0, (T - t) / 0.02)
def write(name, xs):
pk = max(abs(x) for x in xs) or 1.0; g = 10 ** (-1 / 20) / pk
with wave.open(os.path.join(OUT, name), "wb") as w:
w.setnchannels(1); w.setsampwidth(2); w.setframerate(SR)
w.writeframes(b"".join(struct.pack("
```python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Звук: голос work/voice.wav → обработка → −17 LUFS моно (= −14 в стерео) → удары из work/sfx.json → work/audio_final.wav."""
import glob, json, os, re, subprocess
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))); W = os.path.join(ROOT, "work")
FF = os.environ.get("FFMPEG", "ffmpeg"); FPS = 30
def run(a): return subprocess.run([FF, "-nostdin", "-hide_banner", "-y"] + a, stderr=subprocess.PIPE).stderr.decode(errors="ignore")
chain = ",".join([
"highpass=f=80", "afftdn=nr=6:nf=-55",
"equalizer=f=300:t=q:w=1:g=-2.5", "equalizer=f=3500:t=q:w=0.9:g=3", "treble=g=3:f=8000",
"deesser=i=0.35",
"acompressor=threshold=-24dB:ratio=3:attack=10:release=120",
"alimiter=limit=-1.5dB:level=disabled",
])
run(["-i", os.path.join(W, "voice.wav"), "-af", chain, "-ar", "48000", os.path.join(W, "_fx.wav")])
def lufs(p):
m = run(["-i", p, "-af", "ebur128", "-f", "null", "-"])
return float(re.search(r"Integrated loudness:.*?I:\s+(-?[\d.]+) LUFS", m, re.S).group(1))
src = os.path.join(W, "_fx.wav")
for step in range(3):
cur = lufs(src); g = -17.0 - cur
print(f"проход {step}: {cur:.1f} LUFS (моно), усиление {g:+.1f} дБ")
if abs(g) < 0.15: break
dst = os.path.join(W, f"_n{step}.wav")
run(["-i", src, "-af", f"volume={g:.2f}dB,alimiter=limit=-1.5dB:attack=5:release=60:level=disabled", "-ar", "48000", dst]); src = dst
data = json.load(open(os.path.join(ROOT, "src", "reel", "data.json"), encoding="utf-8"))
sfx = json.load(open(os.path.join(W, "sfx.json"), encoding="utf-8")) if os.path.exists(os.path.join(W, "sfx.json")) else []
ins, fc, labs = ["-i", src], [], ["[0]"]
for i, s in enumerate(sfx):
t = (data["ws"][s["word"]] + s.get("shift", 0)) / FPS
ins += ["-i", os.path.join(ROOT, "tools", "hits", f"hit_{s['hit']}.wav")]
fc.append(f"[{i + 1}]volume=-7dB,adelay={int(round(t * 1000))}:all=1[s{i}]"); labs.append(f"[s{i}]")
print(f"удар {s['hit']} на слове {s['word']} «{data['wt'][s['word']]}», {t:.2f} с")
fc.append(f"{''.join(labs)}amix=inputs={len(labs)}:normalize=0:duration=first,alimiter=limit=-1.2dB:level=disabled,pan=stereo|c0=c0|c1=c0[out]")
run(ins + ["-filter_complex", ";".join(fc), "-map", "[out]", "-ar", "48000", "-c:a", "pcm_s16le", os.path.join(W, "audio_final.wav")])
m = run(["-i", os.path.join(W, "audio_final.wav"), "-af", "ebur128=peak=true", "-f", "null", "-"])
st = [float(b) for a, b in re.findall(r"t:\s*([\d.]+)\s+TARGET.*?S:\s*(-?[\d.]+)", m) if float(a) > 3 and float(b) > -60]
print("итог:", re.search(r"Integrated loudness:.*?I:\s+(-?[\d.]+ LUFS)", m, re.S).group(1), "| истинный пик:", re.findall(r"Peak:\s+(-?[\d.]+) dBFS", m)[-1], "dBFS",
"| разброс кратковременной громкости: %.1f LU (норма до 5)" % (max(st) - min(st)))
for f in glob.glob(os.path.join(W, "_*.wav")): os.remove(f)
```
```python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Рендер без звука → сведение с work/audio_final.wav → проверка → листы кадров всего ролика в out/check/.
python3 tools/render.py весь ролик
python3 tools/render.py 0-299 только кадры 0–299 (быстрая проба)"""
import glob, json, os, re, shutil, subprocess, sys, tempfile
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
FF = os.environ.get("FFMPEG", "ffmpeg"); FP = os.environ.get("FFPROBE", "ffprobe")
CFG = json.load(open(os.path.join(ROOT, "work", "edit.json"), encoding="utf-8"))
os.makedirs(os.path.join(ROOT, "out", "check"), exist_ok=True)
def clean_tmp(): # каждый рендер оставляет временную сборку на сотни МБ
for d in glob.glob(os.path.join(tempfile.gettempdir(), "remotion-webpack-bundle-*")): shutil.rmtree(d, ignore_errors=True)
clean_tmp()
raw = os.path.join(ROOT, "out", "raw.mp4")
cmd = [shutil.which("npx") or "npx", "remotion", "render", "src/index.ts", "Reel", raw, "--muted", "--color-space", "bt709",
"--jpeg-quality", "92", "--crf", "12", "--concurrency", os.environ.get("CONCURRENCY", "4")]
if len(sys.argv) > 1: cmd += ["--frames", sys.argv[1]]
subprocess.run(cmd, cwd=ROOT, check=True, shell=(os.name == "nt"))
clean_tmp()
final = os.path.join(ROOT, "out", CFG.get("out_name", "reel.mp4"))
subprocess.run([FF, "-nostdin", "-y", "-v", "error", "-i", raw, "-i", os.path.join(ROOT, "work", "audio_final.wav"), "-map", "0:v", "-map", "1:a",
"-vf", "setparams=range=tv:color_primaries=bt709:color_trc=bt709:colorspace=bt709,format=yuv420p",
"-c:v", "libx264", "-preset", "slow", "-crf", "17", "-maxrate", "12M", "-bufsize", "24M", "-g", "30", "-profile:v", "high", "-level", "4.2",
"-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709", "-color_range", "tv",
"-c:a", "aac", "-b:a", "192k", "-ar", "48000", "-shortest", "-movflags", "+faststart", final], check=True)
os.remove(raw)
# проверка: полное декодирование, кадры, громкость
err = subprocess.run([FF, "-nostdin", "-v", "error", "-i", final, "-f", "null", "-"], stderr=subprocess.PIPE, text=True).stderr.strip()
nf = subprocess.run([FP, "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=nb_frames", "-of", "default=nw=1:nk=1", final], stdout=subprocess.PIPE, text=True).stdout.strip()
m = subprocess.run([FF, "-nostdin", "-hide_banner", "-i", final, "-af", "ebur128=peak=true", "-f", "null", "-"], stderr=subprocess.PIPE, text=True).stderr
print("файл:", final, "| %.1f МБ" % (os.path.getsize(final) / 1e6), "| кадров:", nf, "| ошибки декодирования:", err or "нет")
print("громкость:", re.search(r"Integrated loudness:.*?I:\s+(-?[\d.]+ LUFS)", m, re.S).group(1), "| истинный пик:", re.findall(r"Peak:\s+(-?[\d.]+) dBFS", m)[-1], "dBFS")
# листы кадров всего ролика: кадр каждые 1,5 с, по 20 на лист
for f in glob.glob(os.path.join(ROOT, "out", "check", "list_*.jpg")): os.remove(f)
subprocess.run([FF, "-nostdin", "-y", "-v", "error", "-i", final, "-vf", "fps=2/3,scale=324:576,tile=10x2", "-q:v", "3", os.path.join(ROOT, "out", "check", "list_%d.jpg")], check=True)
print("листы:", ", ".join(sorted(os.path.basename(p) for p in glob.glob(os.path.join(ROOT, "out", "check", "list_*.jpg")))))
```
```js
// Кадры-проверки: один раз собирает проект и снимает перечисленные кадры. node tools/stills.mjs Reel out/st 0,60,150
import { bundle } from "@remotion/bundler";
import { renderStill, selectComposition } from "@remotion/renderer";
import fs from "fs";
import os from "os";
import path from "path";
const [comp, out, list] = process.argv.slice(2);
fs.mkdirSync(out, { recursive: true });
for (const f of fs.readdirSync(out)) if (/^f\d+\.jpg$/.test(f)) fs.rmSync(path.join(out, f));
const serveUrl = await bundle({ entryPoint: path.resolve("src/index.ts") });
const composition = await selectComposition({ serveUrl, id: comp });
for (const f of list.split(",").map(Number)) {
await renderStill({ composition, serveUrl, frame: f, output: path.join(out, `f${String(f).padStart(4, "0")}.jpg`), imageFormat: "jpeg", jpegQuality: 90 });
console.log("кадр", f);
}
fs.rmSync(serveUrl, { recursive: true, force: true });
for (const d of fs.readdirSync(os.tmpdir())) if (d.startsWith("remotion-webpack-bundle-")) fs.rmSync(path.join(os.tmpdir(), d), { recursive: true, force: true });
```
```python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Лист кадров-проверок с линиями безопасной зоны Instagram (y 250, y 1470, x 950). python3 tools/sheet.py out/st out/st/sheet 6"""
import glob, os, sys
from PIL import Image, ImageDraw
d, out = sys.argv[1], sys.argv[2]; per = int(sys.argv[3]) if len(sys.argv) > 3 else 6
fs = sorted(glob.glob(os.path.join(d, "f*.jpg"))); W, H = 405, 720
for n in range(0, len(fs), per):
row = fs[n:n + per]; sh = Image.new("RGB", ((W + 6) * len(row), H + 22), (30, 30, 30))
for i, p in enumerate(row):
im = Image.open(p).convert("RGB").resize((W, H)); dr = ImageDraw.Draw(im)
for y, c in ((250, (0, 255, 255)), (1470, (255, 255, 0))): dr.line((0, y * H / 1920, W, y * H / 1920), fill=c, width=1)
dr.line((950 * W / 1080, 0, 950 * W / 1080, H), fill=(255, 255, 0), width=1)
sh.paste(im, (i * (W + 6), 22)); ImageDraw.Draw(sh).text((i * (W + 6) + 4, 5), os.path.basename(p)[1:5], fill=(255, 255, 255))
sh.save(f"{out}_{n // per}.jpg", quality=85)
print("листов:", (len(fs) + per - 1) // per)
```
```json
{
"source": "ПУТЬ/К/ВИДЕО.mov",
"transcript": "work/run1/a16.json",
"fix": {},
"merge": [],
"drop": [],
"ends": [],
"show": [],
"whole": [],
"cut_pauses_over": 0,
"grade": true,
"out_name": "reel.mp4"
}
```
```json
[]
```
---
## 15. Чек-лист перед сдачей
- [ ] Расшифровка сверена двумя прогонами, выдуманных слов нет, имена и бренды написаны правильно.
- [ ] Первый кадр: человек на весь экран, карточка уже не пустая или пустеет не дольше 3 кадров.
- [ ] Каждый блок раскладки не короче 3,5 с.
- [ ] Субтитры только целыми фразами, не дублируют графику, не короче двух слов.
- [ ] Все слова на экране сказаны человеком; цифры и пропорции только названные им.
- [ ] Ни одна надпись не вылезает за карточку или край экрана; главное в безопасной зоне.
- [ ] Видео в раскладке `over` доходит до низа экрана.
- [ ] Палитра выбрана по теме и не совпадает с прошлым роликом; плашка субтитров в цвет карточки.
- [ ] Три удара на смысловых словах, других звуков нет.
- [ ] Громкость −14 LUFS (±0,5), пик не выше −1 dBFS, разброс до 5 LU.
- [ ] Ролик просмотрен целиком по листам кадров после рендера.
- [ ] Файл отправлен пользователю; в отчёте палитра, сцены, удары и таблица «в тексте / сказано».