467 lines
22 KiB
Python
467 lines
22 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""
|
|
Best3 저수준 도구함 (TTS · 비전 · ffmpeg · BGM · 폰트)
|
|
======================================================
|
|
|
|
one_short / render 가 공통으로 쓰는 유틸 모음. 단독 실행용 아님.
|
|
· 비전: analyze_photos(사진/클립프레임 라벨·점수), extract_frame
|
|
· 음성: gen_tts(Gemini TTS), pcm_to_wav, wav_seconds, process_audio(무음제거·속도)
|
|
· ffmpeg: _ffmpeg, _run, pick_encoder(QSV/libx264), _AUDIO_ARGS
|
|
· 자막: _wrap_lines(픽셀폭 줄바꿈)
|
|
· BGM: resolve_bgm(폴더 랜덤 1곡), mix_bgm
|
|
|
|
설치: pip install google-genai pillow imageio-ffmpeg
|
|
"""
|
|
|
|
import json
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
import time
|
|
import wave
|
|
from pathlib import Path
|
|
|
|
from google.genai import types
|
|
|
|
HERE = Path(__file__).parent
|
|
W, H = 1080, 1920 # 세로 쇼츠
|
|
FPS = 30
|
|
|
|
VISION_MODEL = "gemini-2.5-flash" # 사진/클립 비전 분석용
|
|
TTS_MODEL = "gemini-2.5-flash-preview-tts"
|
|
TTS_VOICE = "Aoede" # 산뜻하고 가벼운 보이스. 대안: Charon(차분) / Sulafat(따뜻) / Laomedeia(경쾌)
|
|
TTS_STYLE = ("다음 문장을 밝고 경쾌하게, 적당히 빠른 속도로 활기차고 신나는 톤으로 읽어줘. "
|
|
"지루하지 않게 텐션을 올리되, 과한 병맛·오버는 아니고 세련되게:")
|
|
LINK_CTA = "소개한 곳 링크는 고정댓글에서 확인하세요" # info 카드 링크 안내
|
|
|
|
# 한글 자막용 폰트 — 주아체(fonts/ 동봉), 없으면 맑은고딕 볼드. 제목/정보용은 송명체.
|
|
FONT = str(HERE / "fonts" / "Jua-Regular.ttf")
|
|
FONT_FALLBACK = r"C:\Windows\Fonts\malgunbd.ttf"
|
|
TITLE_FONT = str(HERE / "fonts" / "SongMyung-Regular.ttf")
|
|
|
|
_AUDIO_ARGS = ["-c:a", "aac", "-b:a", "160k", "-ar", "44100", "-ac", "2"]
|
|
|
|
# 수동 입력(링크 없이 직접 업로드)용 — 로컬 폴더의 이미지/영상 파일 목록
|
|
_LOCAL_IMG_EXTS = (".jpg", ".jpeg", ".png", ".webp", ".bmp")
|
|
_LOCAL_VID_EXTS = (".mp4", ".mov", ".webm", ".m4v")
|
|
|
|
|
|
def list_media(folder, kind="image"):
|
|
"""로컬 폴더의 이미지(kind='image') 또는 영상(kind='video') 파일을 정렬해 [Path...] 반환.
|
|
링크 없이 직접 사진/클립을 올릴 때 사용. 폴더가 없으면 빈 리스트."""
|
|
exts = _LOCAL_VID_EXTS if kind == "video" else _LOCAL_IMG_EXTS
|
|
d = Path(folder) if folder else None
|
|
if not d or not d.is_dir():
|
|
return []
|
|
return sorted(p for p in d.iterdir() if p.suffix.lower() in exts)
|
|
|
|
|
|
# ---------------------------------------------------------------- ffmpeg
|
|
def _ffmpeg() -> str:
|
|
import imageio_ffmpeg
|
|
return imageio_ffmpeg.get_ffmpeg_exe()
|
|
|
|
|
|
def _run(cmd):
|
|
r = subprocess.run(cmd, capture_output=True, text=True, encoding="utf-8", errors="replace")
|
|
if r.returncode != 0:
|
|
raise RuntimeError("ffmpeg 실패:\n" + (r.stderr or "")[-1500:])
|
|
return r
|
|
|
|
|
|
def pick_encoder(exe) -> list:
|
|
"""Intel QSV 하드웨어 인코딩이 실제로 동작하면 그걸, 아니면 libx264 ultrafast."""
|
|
test = subprocess.run(
|
|
[exe, "-hide_banner", "-f", "lavfi", "-i", "color=c=black:s=128x128:d=1",
|
|
"-c:v", "h264_qsv", "-f", "null", "-"],
|
|
capture_output=True, text=True, errors="replace")
|
|
if test.returncode == 0:
|
|
print(" 인코더: h264_qsv (Intel 하드웨어)")
|
|
return ["-c:v", "h264_qsv", "-global_quality", "24", "-preset", "fast"]
|
|
print(" 인코더: libx264 (superfast)")
|
|
return ["-c:v", "libx264", "-preset", "superfast", "-crf", "26"]
|
|
|
|
|
|
# ---------------------------------------------------------------- 비전
|
|
def analyze_photos(client, photo_paths, model=None):
|
|
"""사진/클립프레임을 비전으로 한 번에 분석.
|
|
반환 rows: 입력 순서대로 [{label, char_fit, has_text}].
|
|
label = 보이는 핵심 한국어 한 줄(나레이션 매칭용)
|
|
char_fit = 컷이 매력적인 정도 1~10(클립·사진 순위용)
|
|
has_text = 글자/자막/캡션이 박혀 보이면 True
|
|
실패 시 빈 라벨/0/False."""
|
|
n = len(photo_paths)
|
|
parts = [types.Part.from_text(text=(
|
|
"여러 이미지(가게 사진 또는 영상 캡처)다. 각 이미지를 분석해라.\n"
|
|
"- label: 보이는 핵심을 짧은 한국어 한 줄로(예: '대게 한 상', '바다 노을 뷰', '야외 수영장', "
|
|
"'아늑한 객실', '외관/간판'). 메뉴판이면 '메뉴판'.\n"
|
|
"- char_fit: 광고 컷으로 매력적인 정도 1~10 "
|
|
"(음식·음료·수영장·아늑한 실내=높게 / 메뉴판·로고·밋밋한 외관·사람 위주=낮게).\n"
|
|
"- has_text: 이미지에 '글자/자막/캡션/큰 로고 텍스트'가 박혀 보이면 true, 깨끗하면 false.\n"
|
|
"각 이미지 앞 [이미지 N] 의 N 을 index 로 써라."))]
|
|
for i, p in enumerate(photo_paths):
|
|
parts.append(types.Part.from_text(text=f"[이미지 {i}]"))
|
|
parts.append(types.Part.from_bytes(data=Path(p).read_bytes(), mime_type="image/jpeg"))
|
|
schema = {"type": "object", "properties": {"photos": {"type": "array", "items": {
|
|
"type": "object", "properties": {
|
|
"index": {"type": "integer"}, "label": {"type": "string"},
|
|
"char_fit": {"type": "integer"}, "has_text": {"type": "boolean"}},
|
|
"required": ["index", "label", "char_fit", "has_text"]}}}, "required": ["photos"]}
|
|
resp = client.models.generate_content(
|
|
model=model or VISION_MODEL, contents=parts,
|
|
config=types.GenerateContentConfig(
|
|
temperature=0.2, response_mime_type="application/json", response_schema=schema))
|
|
by = {r["index"]: r for r in json.loads(resp.text).get("photos", [])
|
|
if 0 <= r.get("index", -1) < n}
|
|
return [{"label": (by.get(i, {}).get("label") or "").strip(),
|
|
"char_fit": by.get(i, {}).get("char_fit", 0),
|
|
"has_text": bool(by.get(i, {}).get("has_text", False))} for i in range(n)]
|
|
|
|
|
|
def extract_frame(video_path, out_jpg, at=1.0):
|
|
"""영상에서 프레임 1장 추출(비전 분석/썸네일용)."""
|
|
_run([_ffmpeg(), "-y", "-ss", str(at), "-i", str(video_path),
|
|
"-frames:v", "1", str(out_jpg)])
|
|
return out_jpg
|
|
|
|
|
|
# ---------------------------------------------------------------- 음성
|
|
def _extract_audio(resp):
|
|
"""TTS 응답에서 (pcm, rate) 추출. 비었으면 None 반환(재시도 신호)."""
|
|
cands = getattr(resp, "candidates", None) or []
|
|
for c in cands:
|
|
content = getattr(c, "content", None)
|
|
parts = getattr(content, "parts", None) or [] if content else []
|
|
for p in parts:
|
|
inline = getattr(p, "inline_data", None)
|
|
if inline and inline.data:
|
|
m = re.search(r"rate=(\d+)", inline.mime_type or "")
|
|
return inline.data, (int(m.group(1)) if m else 24000)
|
|
return None
|
|
|
|
|
|
def gen_tts(client, text, voice, retries=4) -> bytes:
|
|
"""Gemini TTS. 프리뷰 모델이 가끔 빈 응답(content=None)을 주므로 재시도한다."""
|
|
last = ""
|
|
for attempt in range(1, retries + 1):
|
|
try:
|
|
resp = client.models.generate_content(
|
|
model=TTS_MODEL,
|
|
contents=f"{TTS_STYLE}\n\n{text}",
|
|
config=types.GenerateContentConfig(
|
|
response_modalities=["AUDIO"],
|
|
speech_config=types.SpeechConfig(
|
|
voice_config=types.VoiceConfig(
|
|
prebuilt_voice_config=types.PrebuiltVoiceConfig(voice_name=voice)
|
|
)
|
|
),
|
|
),
|
|
)
|
|
got = _extract_audio(resp)
|
|
if got:
|
|
return got
|
|
# 비었으면 왜 비었는지(finish_reason 등) 기록하고 재시도
|
|
fr = ""
|
|
try:
|
|
fr = str(getattr(resp.candidates[0], "finish_reason", "") or "")
|
|
except Exception:
|
|
fr = "no-candidates"
|
|
last = f"빈 응답(finish_reason={fr or '?'})"
|
|
except Exception as e:
|
|
last = f"{type(e).__name__}: {e}"
|
|
if attempt < retries:
|
|
wait = 2 * attempt # 2s, 4s, 6s … 점증 백오프
|
|
print(f"\n ↻ TTS 재시도 {attempt}/{retries-1} ({last}) — {wait}s 후",
|
|
end="", flush=True)
|
|
time.sleep(wait)
|
|
raise RuntimeError(f"TTS 실패(재시도 {retries}회): {last}\n 문장: {text[:40]}…")
|
|
|
|
|
|
def pcm_to_wav(pcm, path, rate):
|
|
with wave.open(str(path), "wb") as w:
|
|
w.setnchannels(1); w.setsampwidth(2); w.setframerate(rate)
|
|
w.writeframes(pcm)
|
|
|
|
|
|
def wav_seconds(path: Path) -> float:
|
|
with wave.open(str(path), "rb") as w:
|
|
return w.getnframes() / w.getframerate()
|
|
|
|
|
|
def _atempo_chain(speed: float) -> list:
|
|
"""atempo 는 0.5~2.0 범위만 받으므로 큰 배율은 곱으로 쪼개 체이닝."""
|
|
chain, s = [], speed
|
|
while s > 2.0:
|
|
chain.append("atempo=2.0"); s /= 2.0
|
|
while s < 0.5:
|
|
chain.append("atempo=0.5"); s *= 2.0
|
|
chain.append(f"atempo={s:.4f}")
|
|
return chain
|
|
|
|
|
|
def process_audio(exe, src_wav, dst_wav, speed=1.0, trim_silence=True,
|
|
threshold="-38dB", keep=0.06):
|
|
"""컷편집용 음성 가공: 앞뒤 침묵 제거 + 말 속도 올리기.
|
|
|
|
- trim_silence: 앞/뒤 침묵을 잘라 컷이 탁탁 넘어가게(가운데 호흡은 유지).
|
|
silenceremove 로 앞을 자르고, areverse 로 뒤집어 다시 앞(=원래 뒤)을 자른 뒤 복원.
|
|
keep: 잘라낸 끝에 남길 여유(초). 작을수록 마디가 바짝 붙는다.
|
|
- speed: 1.0=원본, 1.3 이면 30% 빠르게(음정 유지). 길이도 그만큼 줄어든다.
|
|
가공 결과가 비거나 실패하면 원본을 그대로 복사해 안전하게 폴백.
|
|
"""
|
|
af = []
|
|
if trim_silence:
|
|
one = (f"silenceremove=start_periods=1:start_silence={keep}:"
|
|
f"start_threshold={threshold}:detection=peak")
|
|
af += [one, "areverse", one, "areverse"]
|
|
if speed and abs(speed - 1.0) > 1e-3:
|
|
af += _atempo_chain(speed)
|
|
if not af:
|
|
shutil.copyfile(src_wav, dst_wav); return
|
|
try:
|
|
_run([exe, "-y", "-i", str(src_wav), "-af", ",".join(af),
|
|
"-ar", "24000", "-ac", "1", str(dst_wav)])
|
|
if wav_seconds(dst_wav) < 0.15: # 과하게 잘렸으면 폴백
|
|
raise RuntimeError("가공 후 음성이 너무 짧음")
|
|
except (RuntimeError, OSError):
|
|
shutil.copyfile(src_wav, dst_wav)
|
|
|
|
|
|
# ---------------------------------------------------------------- 자막 유틸
|
|
def _wrap_lines(draw, text, font, max_w):
|
|
"""글자 단위로 픽셀 폭(max_w)에 맞춰 줄바꿈."""
|
|
lines, cur = [], ""
|
|
for ch in text:
|
|
if ch == "\n":
|
|
lines.append(cur); cur = ""; continue
|
|
if draw.textlength(cur + ch, font=font) <= max_w:
|
|
cur += ch
|
|
else:
|
|
lines.append(cur); cur = ch
|
|
if cur:
|
|
lines.append(cur)
|
|
return lines or [""]
|
|
|
|
|
|
# ---------------------------------------------------------------- 카메라 모션
|
|
#
|
|
# 엔진 4종(animation / samgukji / greekroman / odyssey)이 각자 복사본을 갖고 있던
|
|
# `_scene_motion` 을 여기로 올렸다. 완전히 같은 코드였고(md5 일치), 효과를 늘릴 때마다
|
|
# 4곳을 손으로 맞춰야 해 어긋나기 쉬웠다.
|
|
#
|
|
# 표현식은 ffmpeg `zoompan` 의 z/x/y 만 반환한다 — d/s/fps 는 호출부가 붙인다.
|
|
# 회전·틸트 필터는 쓰지 않는다: 렌더가 이미 떨림 방지로 3배 업스케일 중이라
|
|
# 필터를 더 얹으면 메모리와 시간이 그만큼 붙는다. zoompan 하나로 낼 수 있는
|
|
# 범위 안에서만 다양화했다.
|
|
|
|
#: 스토리보드가 고를 수 있는 카메라 종류. gen.py 의 SB_SCHEMA enum 과 같은 값이어야 한다.
|
|
CAMERA_KINDS = (
|
|
"reveal", # 살짝 당긴 상태에서 전체로 — 첫 컷(훅) 기본값
|
|
"punch_in", # 앞부분에서 확 들어가 고정 — 반전·폭로
|
|
"slow_in", # 완만한 줌인 — 몰입이 쌓이는 서술
|
|
"slow_out", # 완만한 줌아웃 — 상황이 드러나는 서술
|
|
"pan_left", # 우→좌
|
|
"pan_right", # 좌→우
|
|
"tilt_up", # 아래→위 — 올려다보는 느낌(권위·거대함)
|
|
"tilt_down", # 위→아래 — 내려다보는 느낌(추락·좌절)
|
|
"shake", # 미세 흔들림 — 충격·당황
|
|
"hold", # 완전 정지 — 정적인 대사, 앞뒤 대비용
|
|
)
|
|
|
|
# ── 움직임이 '계단처럼' 보이지 않게 하는 규칙 ────────────────────────────
|
|
#
|
|
# zoompan 은 크롭 사각형을 **입력 정수 픽셀**로 반올림한다. 3배 업스케일이면
|
|
# 출력 기준 약 0.33px 격자이고, 이 격자 오차(측정값 jerk 0.13~0.16px)는
|
|
# 무엇을 해도 거의 줄지 않는다. 실측(2026-08-10):
|
|
#
|
|
# 업스케일 3배 → 6배 → 8배 : jerk 0.127 → 0.094 → 0.085 (33% 개선)
|
|
# 그런데 렌더 시간은 : 5.6초 → 22.5초 → 29.3초 (5배)
|
|
#
|
|
# 즉 업스케일은 나쁜 거래다. 바닥이 고정이라면 **프레임당 이동량을 그 위로
|
|
# 올리는 것**이 답이다. 실제로 부드러웠던 팬은 1.06px/프레임이었고,
|
|
# 계단이 보이던 줌은 0.25~0.38px/프레임이었다.
|
|
#
|
|
# 컷 길이별 불균일도(= jerk / 프레임당 이동), 확대폭 10% 고정 시
|
|
# 2초 22% · 4초 34% · 6초 63% ← 컷이 길수록 급격히 나빠진다
|
|
# 확대폭을 35% 로 올리면 6초 컷도 16% 로 떨어진다.
|
|
#
|
|
# 원인은 **확대·이동 폭이 컷 길이와 무관하게 고정**이었다는 것이다. 컷이 길수록
|
|
# 같은 거리를 더 잘게 나눠 가므로 한 걸음이 격자 아래로 내려간다.
|
|
# → 아래 두 상수로 '한 걸음'을 목표치에 맞춰 폭을 역산한다.
|
|
#
|
|
# 가감속(smoothstep)은 넣지 않았다. 양 끝에서 속도가 0 이 되어 그 구간이
|
|
# 격자 아래로 떨어진다 — 실측에서 정지 프레임이 0개에서 7개로 늘었다.
|
|
# 등속이 이 격자 위에서는 가장 부드럽다.
|
|
|
|
#: 프레임당 목표 이동량(출력 px). 부드러웠던 팬의 실측치(1.06px)를 기준으로 잡았다.
|
|
TARGET_PX_PER_FRAME = 1.0
|
|
|
|
#: 확대폭 한계. 너무 크면 원본 화질이 드러나고 화면이 과하게 요동친다.
|
|
_ZOOM_MIN, _ZOOM_MAX = 0.08, 0.30
|
|
|
|
#: 팬·틸트 이동 거리(화면 대비 비율) 한계.
|
|
_PAN_MIN, _PAN_MAX = 0.06, 0.25
|
|
|
|
#: 출력 가로 폭. 이동량 계산의 기준이며 W 와 같다.
|
|
_OUT_W = 1080
|
|
|
|
#: 확대율 1% 당 화면에서 움직이는 픽셀 수(실측 회귀).
|
|
#: 확대폭 a, 프레임 f 일 때 프레임당 이동 = a * 450 / f 로 맞았다.
|
|
_ZOOM_PX_GAIN = 450.0
|
|
|
|
|
|
def _zoom_amount(frames: int) -> float:
|
|
"""컷 길이에 맞춘 확대폭. 한 걸음이 목표치(≈1px)가 되도록 역산한다."""
|
|
f = max(frames, 1)
|
|
want = f * TARGET_PX_PER_FRAME / _ZOOM_PX_GAIN
|
|
return max(_ZOOM_MIN, min(_ZOOM_MAX, want))
|
|
|
|
|
|
def _pan_zoom(frames: int) -> tuple:
|
|
"""팬·틸트용 (확대율, 이동비율). 확대율은 이동할 여백을 만들기 위한 것이다.
|
|
|
|
이동 거리 = 화면폭 * ratio 이므로, 프레임당 목표 이동에서 ratio 를 역산한다.
|
|
"""
|
|
f = max(frames, 1)
|
|
ratio = f * TARGET_PX_PER_FRAME / _OUT_W
|
|
ratio = max(_PAN_MIN, min(_PAN_MAX, ratio))
|
|
return 1.0 / (1.0 - ratio), ratio
|
|
|
|
#: 역할을 알 수 없는 컷에 순환시킬 기본 목록.
|
|
#: reveal/punch_in/shake 는 강한 효과라 여기서 뺐다 — 아무 데나 붙으면 산만해진다.
|
|
_NEUTRAL_KINDS = ("slow_in", "pan_right", "slow_out", "tilt_up", "pan_left", "tilt_down")
|
|
|
|
_CX = "iw/2-(iw/zoom/2)" # 가로 중앙 고정
|
|
_CY = "ih/2-(ih/zoom/2)" # 세로 중앙 고정
|
|
|
|
|
|
def motion_seed(text: str) -> int:
|
|
"""스토리보드 텍스트에서 카메라 순환 시작점을 뽑는다.
|
|
|
|
난수를 쓰지 않는 이유: 같은 콘텐츠를 다시 렌더하면 같은 영상이 나와야
|
|
비교·디버깅이 된다. 반면 콘텐츠가 다르면 시작점이 달라지므로
|
|
**영상마다 카메라 순서가 달라진다** — 결정론과 다양성을 함께 얻는다.
|
|
"""
|
|
import hashlib
|
|
|
|
digest = hashlib.md5((text or "").encode("utf-8", "ignore")).hexdigest()
|
|
return int(digest[:8], 16)
|
|
|
|
|
|
def _camera_expr(kind: str, frames: int) -> str:
|
|
"""카메라 종류 → zoompan 표현식.
|
|
|
|
확대·이동 폭은 상수가 아니라 **컷 길이에서 역산**한다(위 주석 참조).
|
|
긴 컷일수록 폭을 키워야 한 걸음이 양자화 격자 위에 남는다.
|
|
"""
|
|
f = max(frames, 1)
|
|
a = _zoom_amount(f) # 이 컷에 맞는 확대폭
|
|
pz, _ = _pan_zoom(f) # 팬·틸트용 확대율(여백 확보)
|
|
|
|
if kind == "reveal":
|
|
# 당긴 상태에서 전체로. 확대폭을 조금 더 크게 잡아 '드러나는' 느낌을 준다
|
|
ra = min(_ZOOM_MAX, a * 1.4)
|
|
return f"zoompan=z='max({1 + ra:.4f}-{ra:.4f}*on/{f},1.0)':x='{_CX}':y='{_CY}'"
|
|
if kind == "punch_in":
|
|
# 앞 35% 구간에서 들어가고 나머지는 정지. 정지 구간은 움직임이 아예 없어
|
|
# 격자 문제가 생기지 않고, 돌진 구간은 걸음이 크므로 부드럽다
|
|
rush = max(1, int(f * 0.35))
|
|
pa = min(_ZOOM_MAX, a * 1.4)
|
|
return f"zoompan=z='min(1.0+{pa:.4f}*on/{rush},{1 + pa:.4f})':x='{_CX}':y='{_CY}'"
|
|
if kind == "slow_in":
|
|
return f"zoompan=z='1.0+{a:.4f}*on/{f}':x='{_CX}':y='{_CY}'"
|
|
if kind == "slow_out":
|
|
return f"zoompan=z='{1 + a:.4f}-{a:.4f}*on/{f}':x='{_CX}':y='{_CY}'"
|
|
if kind == "pan_right":
|
|
return f"zoompan=z='{pz:.4f}':x='(iw-iw/zoom)*on/{f}':y='{_CY}'"
|
|
if kind == "pan_left":
|
|
# `(1-on/f)` 로 쓰면 1 에 가까운 값을 큰 수에 곱하게 되어 반올림이 어긋난다.
|
|
# 실측에서 pan_right 4.1% 대 pan_left 22.3% 로 방향만 다른데 5배 차이가 났다.
|
|
# 증가항을 그대로 두고 '빼는' 형태로 쓰면 두 방향의 격자 패턴이 같아진다.
|
|
return f"zoompan=z='{pz:.4f}':x='(iw-iw/zoom)-(iw-iw/zoom)*on/{f}':y='{_CY}'"
|
|
if kind == "tilt_down":
|
|
return f"zoompan=z='{pz:.4f}':x='{_CX}':y='(ih-ih/zoom)*on/{f}'"
|
|
if kind == "tilt_up":
|
|
return f"zoompan=z='{pz:.4f}':x='{_CX}':y='(ih-ih/zoom)-(ih-ih/zoom)*on/{f}'"
|
|
if kind == "shake":
|
|
# 흔들림은 의도된 진동이라 걸음이 크다(프레임당 수 px) — 격자 영향 없음
|
|
return ("zoompan=z='1.06':"
|
|
f"x='{_CX}+8*sin(on*1.6)':"
|
|
f"y='{_CY}+6*cos(on*2.2)'")
|
|
# hold — **완전 정지**. 예전에는 3px 사인 드리프트를 줬으나, 그 폭이 출력
|
|
# 기준 1px 라 격자에 걸려 프레임의 1/3 이 멈췄다 튀었다(실측 20/59).
|
|
# 미세하게 움직이느니 아예 안 움직이는 편이 훨씬 깔끔하다.
|
|
return f"zoompan=z='1.04':x='{_CX}':y='{_CY}'"
|
|
|
|
|
|
def scene_motion(scene, idx: int, n: int, frames: int, seed: int = 0) -> str:
|
|
"""장면 하나의 zoompan 표현식.
|
|
|
|
카메라를 정하는 순서는 셋이고, 앞에서 정해지면 뒤는 보지 않는다:
|
|
|
|
1. **스토리보드가 지정한 값** (`scene["camera"]`).
|
|
LLM 이 장면 내용을 알고 고른 것이라 가장 정확하다.
|
|
2. **위치 휴리스틱** — 첫 컷은 reveal, 마지막 컷은 시선을 모으는 slow_in.
|
|
스토리보드가 camera 를 안 줬을 때의 안전망이다.
|
|
3. **seed 순환** — 중립 효과를 `(idx + seed)` 로 돌린다. idx 가 1씩
|
|
늘어나므로 **인접 컷이 같은 효과가 되는 일이 없고**, seed 가 콘텐츠마다
|
|
달라 영상끼리도 순서가 겹치지 않는다.
|
|
|
|
`scene` 이 dict 가 아니거나 모르는 값이면 조용히 3단계로 떨어진다 —
|
|
카메라 때문에 렌더 전체가 실패하면 안 된다.
|
|
"""
|
|
if isinstance(scene, dict):
|
|
want = str(scene.get("camera") or "").strip().lower()
|
|
if want in CAMERA_KINDS:
|
|
return _camera_expr(want, frames)
|
|
|
|
if idx == 1:
|
|
return _camera_expr("reveal", frames)
|
|
if n >= 3 and idx == n:
|
|
return _camera_expr("slow_in", frames)
|
|
|
|
kind = _NEUTRAL_KINDS[(idx + seed) % len(_NEUTRAL_KINDS)]
|
|
return _camera_expr(kind, frames)
|
|
|
|
|
|
# ---------------------------------------------------------------- BGM
|
|
AUDIO_EXTS = (".mp3", ".wav", ".m4a", ".aac", ".ogg", ".flac", ".opus")
|
|
|
|
|
|
def resolve_bgm(bgm_arg):
|
|
"""--bgm 값 → 실제 음악 파일 경로(없으면 None).
|
|
|
|
해석 순서(분위기별로 bgm/ 폴더에 나눠 담는 걸 지원):
|
|
1) 파일이면 그대로
|
|
2) 폴더면 그 안 음악 중 무작위 1곡
|
|
3) 이름만 주면 HERE/<값> → HERE/bgm/<값> 순으로 파일/폴더 탐색
|
|
"""
|
|
if not bgm_arg or str(bgm_arg).strip().lower() in ("none", "off", "no"):
|
|
return None
|
|
import random
|
|
p = Path(bgm_arg)
|
|
cands = [p] if p.is_absolute() else [HERE / p, HERE / "bgm" / p]
|
|
for c in cands:
|
|
if c.is_file():
|
|
return c
|
|
if c.is_dir():
|
|
files = [f for f in sorted(c.iterdir()) if f.suffix.lower() in AUDIO_EXTS]
|
|
if files:
|
|
return random.choice(files)
|
|
return None
|
|
|
|
|
|
def mix_bgm(exe, video_path, bgm_path, out_path, volume=0.3, fade=1.0):
|
|
"""완성 영상(나레이션 음성 포함) 위에 BGM 한 트랙을 작은 볼륨으로 깔아 최종본 저장.
|
|
|
|
- BGM 이 영상보다 짧으면 무한 루프(-stream_loop -1), 길면 영상 길이에 맞춰 잘림.
|
|
- 나레이션[0:a] + BGM[1:a]*volume 를 amix(duration=first)로 섞어 영상 길이에 맞춘다.
|
|
- 영상은 재인코딩하지 않는다(-c:v copy) → 빠름. 시작에 짧은 페이드인.
|
|
"""
|
|
fc = (f"[1:a]volume={volume},afade=t=in:st=0:d={fade}[bg];"
|
|
f"[0:a][bg]amix=inputs=2:duration=first:dropout_transition=0[a]")
|
|
_run([exe, "-y", "-i", str(video_path), "-stream_loop", "-1", "-i", str(bgm_path),
|
|
"-filter_complex", fc, "-map", "0:v", "-map", "[a]",
|
|
"-c:v", "copy", *_AUDIO_ARGS, "-shortest", "-movflags", "+faststart",
|
|
str(out_path)])
|