def check_file(file_path: str, chat_id: int, item_id: int, app) -> dict:
"""
- Se originale <= limite: original_ok.
- Altrimenti:
Tentativo 1: calcolo plan con limite "fudgiato" (solo qui).
Se OK (<= limite reale): replace e encoded_ok.
Se overshoot e RETRY_ON_OVERSHOOT=True: Tentativo 2.
- Mantiene audio e vf_height del 1°
- Ricalcola SOLO v_kbps 'spalmando' l'eccesso + safety.
Se 2° OK: replace e encoded_ok.
Altrimenti: too_big (lo split lo farà chi chiama).
"""
try:
src = Path(file_path)
if not src.exists():
msg = "❌ File non trovato"
try: send_telegram_message(chat_id, msg)
except Exception: pass
return {"status": "error", "msg": msg, "path": None}
orig_size = src.stat().st_size
if orig_size <= safe_limit_bytes:
# logger.info("[check] Originale sotto soglia: %s <= %s", orig_size, safe_limit_bytes)
logger.info(
"[check] originale <= limite: size=%s (%d B) <= limit=%s (%d B) — skip encode.",
_fmt_bytes(orig_size), orig_size, _fmt_bytes(safe_limit_bytes), safe_limit_bytes
)
return {"status": "original_ok", "path": str(src), "size": orig_size}
if app == "sonarr":
api_key = sonarr_api
host = sonarr_host
port = sonarr_port
elif app == "radarr":
api_key = radarr_api
host = radarr_host
port = radarr_port
else:
raise ValueError("app must be 'radarr' or 'sonarr'")
profile_language = get_profile_language_iso639_2(app, api_key, host, port, item_id)
langs = _analyze_audio_languages_with_docker(src)
filter_enabled, keep_relidx, notify_msg, summary_str = _decide_audio_selection(profile_language, langs)
# Log elenco tracce rilevate
logger.info("[audio] Tracce: %s", summary_str)
# Notifiche all'owner, se richieste dalla logica
if notify_msg:
try:
send_telegram_message(owner_chatid, f"ℹ️ {src.name}: {notify_msg}")
except Exception:
pass
ctx = extract_encode_context(str(src))
# Report keep/remove
if filter_enabled:
keep_1based = [i+1 for i in sorted(keep_relidx)]
all_1based = [int(t.get("track")) for t in langs]
remove_1based = [t for t in all_1based if t not in keep_1based]
# logger.info("[audio] Keep: %s | Remove: %s",
# ", ".join(f"#{i}" for i in keep_1based) if keep_1based else "(none)",
# ", ".join(f"#{i}" for i in remove_1based) if remove_1based else "(none)")
logger.info(
"[audio] selection: keep=%s (%d/%d), remove=%s",
", ".join(f"#{i}" for i in keep_1based) if keep_1based else "(none)",
len(keep_1based), len(langs),
", ".join(f"#{i}" for i in remove_1based) if remove_1based else "(none)"
)
else:
logger.info("[audio] selection: keep=all (%d/%d), remove=(none)", ctx.n_audio, ctx.n_audio)
# Context e output temporaneo
# ctx = extract_encode_context(str(src))
out_tmp = str(src.with_name(f"{src.stem}.encode{REENCODE_OUTPUT_EXT}"))
try:
if os.path.exists(out_tmp):
os.remove(out_tmp)
except Exception:
pass
dur_txt = _fmt_hms(ctx.duration_s)
try:
send_telegram_message(
chat_id,
"🗜️ Provo compressione GPU (HEVC NVENC, multipass)…"
)
logger.info(
"[check] source: name=%s, dur=%s (%.0fs), size=%s (%d B), limit=%s (%d B), app=%s, profile_lang=%s",
src.name, _fmt_hms(ctx.duration_s), ctx.duration_s,
_fmt_bytes(orig_size), orig_size,
_fmt_bytes(safe_limit_bytes), safe_limit_bytes,
app, profile_language or "n/a"
)
a_src_est = max(0, ctx.source_total_kbps_est - ctx.source_video_kbps_est)
logger.info(
"[src] video: %dx%d, %s-bit, v_src≈%d kb/s",
ctx.width, ctx.height, ("10" if ctx.is_10bit else "8"), ctx.source_video_kbps_est
)
logger.info(
"[src] audio: tracks=%d, a_src_est≈%d kb/s",
ctx.n_audio, a_src_est
)
logger.info(
"[src] container: total_src≈%d kb/s, dur=%s (%.0fs), size=%s (%d B), ext=%s",
ctx.source_total_kbps_est, dur_txt, ctx.duration_s,
_fmt_bytes(orig_size), orig_size, ctx.ext_low
)
except Exception:
pass
# ---- Tentativo 1 (fudge -1% sul limite totale) ----
limit_try1 = int(safe_limit_bytes * (1.0 - FUDGE_VBR_FIRST_TRY))
n_audio_eff = len(keep_relidx) if filter_enabled else ctx.n_audio
plan1 = compute_target_for_size(ctx, limit_try1, n_audio_override=n_audio_eff)
# logger.info("[check] Tentativo 1 → target_kbps_tot=%s, audio=%s, video=%s, vf_h=%s",
# plan1.safe_total_kbps, plan1.target_audio_kbps_total, plan1.v_kbps, plan1.vf_height)
logger.info(
"[plan] try#1: total=%s kb/s (v=%s, a=%s), vf_h=%s, limit_fudged=%s (%d B, fudge=%.2f%%), dur=%s (%.0fs)",
plan1.safe_total_kbps, plan1.v_kbps, plan1.target_audio_kbps_total, plan1.vf_height,
_fmt_bytes(limit_try1), limit_try1, (FUDGE_VBR_FIRST_TRY * 100.0),
_fmt_hms(ctx.duration_s), ctx.duration_s
)
# Se filtriamo, passiamo la mappa esplicita; altrimenti None per comportamento corrente
audio_map = keep_relidx if filter_enabled else None
rc1, el1, out1 = run_encode_once(out_tmp, ctx, plan1, audio_map_relidx=audio_map)
logger.info("[encode] v_kbps=%s, vf_h=%s, audio_kbps_total=%s, safe_total_kbps=%s, src_v_kbps=%s",
plan1.v_kbps, plan1.vf_height, plan1.target_audio_kbps_total,
plan1.safe_total_kbps, getattr(plan1, "source_video_kbps_est", "n/a"))
if rc1 != 0 or out1 <= 0 or not os.path.exists(out_tmp):
try: send_telegram_message(chat_id, "❌ Compress. fallita (1° tentativo).")
except Exception: pass
try:
if os.path.exists(out_tmp):
os.remove(out_tmp)
except Exception:
pass
return {"status": "error", "path": str(src), "msg": "encode1_failed"}
logger.info("[encode] OK rc=%s, size=%s bytes", rc1, out1)
if out1 <= safe_limit_bytes:
# SUCCESSO → sostituisco l'originale
try:
dest_path = src.with_suffix(REENCODE_OUTPUT_EXT)
os.replace(out_tmp, dest_path)
if dest_path != src:
try:
os.remove(src)
except Exception:
pass
try:
eff_n_audio = (len(audio_map) if audio_map is not None else ctx.n_audio)
update_mkv_metadata_final(dest_path, src, eff_n_audio)
logger.info("[final] mkvpropedit: track statistics tags rigenerati + segment title/default audio impostati.")
except Exception:
pass
final_size = os.path.getsize(dest_path)
try:
eff_total_kbps_1 = int((final_size * 8) / max(1.0, ctx.duration_s) / 1000)
margin_pct_1 = (1.0 - (final_size / safe_limit_bytes)) * 100.0
logger.info(
"[final] try#1 OK: size=%s (%d B) ≤ limit=%s (%d B), margin=%.2f%%, "
"eff_total=%d kb/s vs plan_total=%s, v=%s, vf_h=%s, audio_streams=%d, dest=%s",
_fmt_bytes(final_size), final_size,
_fmt_bytes(safe_limit_bytes), safe_limit_bytes, margin_pct_1,
eff_total_kbps_1, plan1.safe_total_kbps, plan1.v_kbps, plan1.vf_height,
(len(audio_map) if filter_enabled else ctx.n_audio),
str(dest_path)
)
size_factor = (orig_size / final_size) if final_size > 0 else 0.0
size_redux_pct = 100.0 * (1.0 - (final_size / orig_size))
tot_redux_pct = 100.0 * (1.0 - (eff_total_kbps_1 / max(1, ctx.source_total_kbps_est)))
v_redux_pct = 100.0 * (1.0 - (plan1.v_kbps / max(1, ctx.source_video_kbps_est)))
logger.info(
"[final] delta#1: total≈%d→%d kb/s (Δ=%.2f%%), v≈%d→%d kb/s (plan, Δ=%.2f%%), "
"size %s→%s (x%.2f, Δ=%.2f%%), vf_h=%s, a_streams=%d",
ctx.source_total_kbps_est, eff_total_kbps_1, tot_redux_pct,
ctx.source_video_kbps_est, plan1.v_kbps, v_redux_pct,
_fmt_bytes(orig_size), _fmt_bytes(final_size), size_factor, size_redux_pct,
plan1.vf_height, (len(audio_map) if filter_enabled else ctx.n_audio)
)
except Exception:
pass
except Exception:
try: os.remove(out_tmp)
except Exception: pass
final_size = out1 # best effort
try:
send_telegram_message(chat_id, f"✅ Compressione ok: {_fmt_bytes(final_size)} (limite {_fmt_bytes(safe_limit_bytes)})")
except Exception:
pass
# return {"status": "encoded_ok", "path": file_path, "size": final_size,
return {"status": "encoded_ok", "path": dest_path, "size": final_size,
"plan": {"vf_height": plan1.vf_height, "v_kbps": plan1.v_kbps,
"audio_kbps": plan1.target_audio_kbps_total,
"safe_total_kbps": plan1.safe_total_kbps,
"src_video_kbps_est": getattr(plan1, "source_video_kbps_est", None)}}
# ---- Overshoot → valutazione retry ----
if not RETRY_ON_OVERSHOOT:
try:
send_telegram_message(chat_id, f"ℹ️ Output {_fmt_bytes(out1)} > limite ({_fmt_bytes(safe_limit_bytes)}). Retry disattivato.")
logger.info(
"[overshoot] try#1: size=%s (%d B) > limit=%s (%d B) by %.2f%% — retry disattivato.",
_fmt_bytes(out1), out1, _fmt_bytes(safe_limit_bytes), safe_limit_bytes,
((out1 - safe_limit_bytes) / safe_limit_bytes) * 100.0
)
except Exception:
pass
try:
if os.path.exists(out_tmp):
os.remove(out_tmp)
except Exception:
pass
return {"status": "too_big", "path": str(src), "size": out1, "msg": "overshoot_no_retry"}
overs_bytes = out1 - safe_limit_bytes
pct = (overs_bytes / safe_limit_bytes) * 100.0
min_floor = _floor_value_min(H265_FLOOR_KBPS)
v2 = _compute_retry_v_kbps(
ctx.duration_s, out1, safe_limit_bytes, plan1.v_kbps, RETRY_SAFETY_PCT,
floor_kbps=min_floor
)
try:
plan2 = adjust_plan_after_retry(ctx, plan1, v2) # usa H265_FLOOR_KBPS e MAX_TARGET_HEIGHT interni/globali
except EncodeNotFeasible as e:
# Retry non fattibile (v2 < floor minore, o nessun bucket compatibile) → chiedi split
try:
send_telegram_message(chat_id,
f"❌ Retry impossibile: {e}. Suggerito split.")
except Exception:
pass
try:
if os.path.exists(out_tmp):
os.remove(out_tmp)
except Exception:
pass
return {"status": "too_big", "path": str(src), "size": out1, "msg": "overshoot_retry_unfeasible"}
try:
send_telegram_message(
chat_id,
"ℹ️ Overshoot: {} > limite ({}) di {:.2f}%.\n"
"Retry: video {} → {} kb/s; risoluzione {} → {}."
.format(_fmt_bytes(out1), _fmt_bytes(safe_limit_bytes), pct,
plan1.v_kbps, plan2.v_kbps, plan1.vf_height, plan2.vf_height)
)
logger.info(
"[overshoot] try#1: size=%s (%d B) > limit=%s (%d B) by %.2f%% — "
"retry plan: v=%s→%s kb/s, vf_h=%s→%s",
_fmt_bytes(out1), out1, _fmt_bytes(safe_limit_bytes), safe_limit_bytes, pct,
plan1.v_kbps, plan2.v_kbps, plan1.vf_height, plan2.vf_height
)
except Exception:
pass
logger.info(
"[plan] try#2: total=%s kb/s (v=%s, a=%s), vf_h=%s",
plan2.safe_total_kbps, plan2.v_kbps, plan2.target_audio_kbps_total, plan2.vf_height
)
rc2, el2, out2 = run_encode_once(out_tmp, ctx, plan2, audio_map_relidx=audio_map)
logger.info("[encode] v_kbps=%s, vf_h=%s, audio_kbps_total=%s, safe_total_kbps=%s, src_v_kbps=%s",
plan2.v_kbps, plan2.vf_height, plan2.target_audio_kbps_total,
plan2.safe_total_kbps, getattr(plan2, "source_video_kbps_est", "n/a"))
if rc2 != 0 or out2 <= 0 or not os.path.exists(out_tmp):
try: send_telegram_message(chat_id, "❌ Compress. fallita (2° tentativo).")
except Exception: pass
try:
if os.path.exists(out_tmp):
os.remove(out_tmp)
except Exception:
pass
return {"status": "error", "path": str(src), "msg": "encode2_failed"}
logger.info("[encode] OK rc=%s, size=%s bytes", rc2, out2)
if out2 <= safe_limit_bytes:
try:
dest_path = src.with_suffix(REENCODE_OUTPUT_EXT)
os.replace(out_tmp, dest_path)
if dest_path != src:
try:
os.remove(src)
except Exception:
pass
try:
eff_n_audio = (len(audio_map) if audio_map is not None else ctx.n_audio)
update_mkv_metadata_final(dest_path, src, eff_n_audio)
logger.info("[final] mkvpropedit: track statistics tags rigenerati + segment title/default audio impostati.")
except Exception:
pass
final_size = os.path.getsize(dest_path)
try:
eff_total_kbps_2 = int((final_size * 8) / max(1.0, ctx.duration_s) / 1000)
margin_pct_2 = (1.0 - (final_size / safe_limit_bytes)) * 100.0
logger.info(
"[final] try#2 OK: size=%s (%d B) ≤ limit=%s (%d B), margin=%.2f%%, "
"eff_total=%d kb/s vs plan_total=%s, v=%s, vf_h=%s, audio_streams=%d, dest=%s",
_fmt_bytes(final_size), final_size,
_fmt_bytes(safe_limit_bytes), safe_limit_bytes, margin_pct_2,
eff_total_kbps_2, plan2.safe_total_kbps, plan2.v_kbps, plan2.vf_height,
(len(audio_map) if filter_enabled else ctx.n_audio),
str(dest_path)
)
size_factor = (orig_size / final_size) if final_size > 0 else 0.0
size_redux_pct = 100.0 * (1.0 - (final_size / orig_size))
tot_redux_pct = 100.0 * (1.0 - (eff_total_kbps_2 / max(1, ctx.source_total_kbps_est)))
v_redux_pct = 100.0 * (1.0 - (plan2.v_kbps / max(1, ctx.source_video_kbps_est)))
logger.info(
"[final] delta#2: total≈%d→%d kb/s (Δ=%.2f%%), v≈%d→%d kb/s (plan, Δ=%.2f%%), "
"size %s→%s (x%.2f, Δ=%.2f%%), vf_h=%s, a_streams=%d",
ctx.source_total_kbps_est, eff_total_kbps_2, tot_redux_pct,
ctx.source_video_kbps_est, plan2.v_kbps, v_redux_pct,
_fmt_bytes(orig_size), _fmt_bytes(final_size), size_factor, size_redux_pct,
plan2.vf_height, (len(audio_map) if filter_enabled else ctx.n_audio)
)
except Exception:
pass
except Exception:
try: os.remove(out_tmp)
except Exception: pass
final_size = out2
try:
send_telegram_message(chat_id, f"✅ Compressione ok al 2° tentativo: {_fmt_bytes(final_size)} (limite {_fmt_bytes(safe_limit_bytes)})")
except Exception:
pass
# return {"status": "encoded_ok", "path": file_path, "size": final_size,
return {"status": "encoded_ok", "path": dest_path, "size": final_size,
"plan": {"vf_height": plan2.vf_height, "v_kbps": plan2.v_kbps,
"audio_kbps": plan2.target_audio_kbps_total,
"safe_total_kbps": plan2.safe_total_kbps,
"src_video_kbps_est": getattr(plan2, "source_video_kbps_est", None)}}
# Ancora troppo grande → lasciare la decisione di split al chiamante
try:
if os.path.exists(out_tmp):
os.remove(out_tmp)
except Exception:
pass
try:
send_telegram_message(chat_id, f"ℹ️ Output ancora > limite ({_fmt_bytes(safe_limit_bytes)}).")
except Exception:
pass
logger.info(
"[final] try#2 still too big: size=%s (%d B) > limit=%s (%d B) by %.2f%% — split demandato al chiamante.",
_fmt_bytes(out2), out2, _fmt_bytes(safe_limit_bytes), safe_limit_bytes,
((out2 - safe_limit_bytes) / safe_limit_bytes) * 100.0
)
return {"status": "too_big", "path": str(src), "size": out2, "msg": "overshoot_after_retry"}
except Exception as e:
logger.exception("[check_file] eccezione: %s", e)
try: send_telegram_message(chat_id, f"❌ Errore check_file: {e}")
except Exception: pass
return {"status": "error", "path": None, "msg": str(e)}
