iphone-stream / app.py
jumannendange's picture
Upload app.py
5823606 verified
Raw History Blame
42.8 kB
import os
# Zima SSR ya Gradio (Node proxy) ili routes zetu zifike moja kwa moja.
os.environ.setdefault("GRADIO_SSR_MODE", "False")
import hashlib
import json
import ipaddress
import re
import shutil
import socket
import subprocess
import tempfile
import threading
from concurrent.futures import ThreadPoolExecutor
import time
import logging
log = logging.getLogger("bridge")
from datetime import datetime, timedelta, timezone
from urllib.parse import urlparse
import gradio as gr
import requests
from fastapi import Request
from fastapi.responses import FileResponse, JSONResponse, Response
from starlette.concurrency import run_in_threadpool
# ZeroGPU inahitaji angalau function moja yenye @spaces.GPU wakati wa startup.
# Placeholder tu; haiitwi kamwe. (Kama Space iko kwenye CPU basic, haina madhara.)
try:
import spaces
@spaces.GPU
def _gpu_placeholder() -> str:
return "ok"
except ImportError:
pass
# ═══════════════════════════ v2 β€” "Live TV ya kweli" ═══════════════════════════
# Mabadiliko makuu dhidi ya toleo lililopita:
# 1. FORCE_REENCODE sasa ni default TRUE β€” GOP (keyframe) inapangwa daima
# kwa sekunde HLS_TIME, kuzuia 'kuganda-ganda' kwa vyanzo vyenye GOP
# fupi/isiyo sawa (km. Azam).
# 2. TARGET_HEIGHT=360 (default) inalazimishwa kwa "-vf scale" wakati wa
# re-encode β€” ubora UNAFANANA kote bila kujali chanzo ni 480p/720p/1080p,
# na CPU/bandwidth vinapungua sana (session nyingi 24/7 kwa uthabiti).
# 3. Channel za jaynestv (zote, "24/7") zinawashwa na kubaki hai kiotomatiki
# (warm_loop), zikigawanywa kati ya Space nyingi kwa SPACE_INDEX/
# SPACE_COUNT (hash ile ile na edge function ya Supabase "iphone-stream"),
# ili channel moja isianzishwe mara mbili kwenye Space mbili kwa pamoja.
# 4. Saa 6 usiku – saa 3 asubuhi EAT (HARDCODED, si env): warm inasimama β€”
# channel mpya hazianzishwi mapema; zile zinazotazamwa na watu halisi
# zinaendelea mpaka waondoke (IDLE_TIMEOUT ya kawaida).
# ════════════════════════════════════════════════════════════════════════════
SPACE_HOST = os.environ.get("SPACE_HOST", "")
SELF_URL = f"https://{SPACE_HOST}" if SPACE_HOST else os.environ.get("SELF_URL", "")
# ── Mipangilio (Space β†’ Settings β†’ Variables and secrets) ──
BRIDGE_TOKEN = os.environ.get("BRIDGE_TOKEN", "") # hiari: ulinzi wa /bridge/start
ID_SECRET = os.environ.get("ID_SECRET", "change-me")
MAX_SESSIONS = int(os.environ.get("MAX_SESSIONS", "3"))
IDLE_TIMEOUT = int(os.environ.get("IDLE_TIMEOUT", "600"))
READY_TIMEOUT = int(os.environ.get("READY_TIMEOUT", "60"))
PING_INTERVAL_SECONDS = 300
MAX_VARIANTS = int(os.environ.get("MAX_VARIANTS", "1")) # video za ubora tofauti (za juu zaidi)
MAX_AUDIO = int(os.environ.get("MAX_AUDIO", "2")) # sauti/lugha tofauti
# ── MPYA: udhibiti wa segment handling (ndiyo chanzo cha kuganda/stutter) ──
HLS_TIME = int(os.environ.get("HLS_TIME", "4")) # muda wa kila segment (sekunde)
HLS_LIST_SIZE = int(os.environ.get("HLS_LIST_SIZE", "8")) # segments ngapi kwenye playlist (dirisha) β€” 8Γ—4s=32s nyuma ya live, badala ya 20Γ—4s=80s
HLS_DELETE_THRESHOLD = int(os.environ.get("HLS_DELETE_THRESHOLD", "5")) # segments za ziada kabla ya kufutwa
STALL_TIMEOUT = int(os.environ.get("STALL_TIMEOUT", "20")) # sekunde bila segment mpya -> restart
# v2: default sasa ni TRUE β€” "professional, live kweli" inahitaji GOP
# iliyopangwa daima; copy haiaminiki kwa vyanzo vingi vya Afrika Mashariki
# (tulivyothibitisha na Azam One/Azam Sports). 360p inapunguza gharama ya
# CPU ya re-encode kiasi cha kutosha kubeba session nyingi 24/7.
FORCE_REENCODE = os.environ.get("FORCE_REENCODE", "true").lower() == "true"
REENCODE_FPS = int(os.environ.get("REENCODE_FPS", "30")) # FPS inayodhaniwa kwa kukokotoa GOP
TARGET_HEIGHT = int(os.environ.get("TARGET_HEIGHT", "360")) # v2: "360 quality kote" β€” kikomo cha juu kabisa, hata chanzo kikiwa 720p/1080p
VIDEO_BITRATE = os.environ.get("VIDEO_BITRATE", "800k").strip() # bitrate ya video wakati wa re-encode (inatosha kwa 360p)
# ── MPYA: channel 24/7 (jaynestv) zikigawanywa kati ya Space kadhaa ──
# Kila Space inayoshiriki (jumannendange-iphone-stream, ...1, jaynestv-
# iphone-stream) LAZIMA iwe na SPACE_INDEX tofauti (0,1,2) na SPACE_COUNT
# ile ile (3), ili hash hii ilingane na ile inayotumika kwenye edge
# function ya Supabase "iphone-stream" (pickIdx huko) β€” channel moja
# isianzishwe kwenye Space mbili kwa wakati mmoja.
SPACE_INDEX = int(os.environ.get("SPACE_INDEX", "0"))
SPACE_COUNT = int(os.environ.get("SPACE_COUNT", "3"))
def pick_index(name: str, n: int) -> int:
"""Hash ile ile inayotumika kwenye iphone-stream (Supabase, pickIdx)."""
h = 0
for ch in name:
h = (h * 31 + ord(ch)) & 0xFFFFFFFF
return h % n if n > 0 else 0
# ── MPYA: ratiba ya usiku β€” HARDCODED kwa ombi la mtumiaji (si env) ──
# Saa 6 usiku hadi saa 3 asubuhi, wakati wa Afrika Mashariki (EAT, UTC+3).
EAT = timezone(timedelta(hours=3))
NIGHT_START_HOUR_EAT = 0 # saa 6 usiku EAT = 00:00
NIGHT_END_HOUR_EAT = 9 # saa 3 asubuhi EAT = 09:00
def is_night_eat() -> bool:
return NIGHT_START_HOUR_EAT <= datetime.now(EAT).hour < NIGHT_END_HOUR_EAT
ROOT = os.path.join(tempfile.gettempdir(), "hls_bridge")
os.makedirs(ROOT, exist_ok=True)
# MPYA: onyo la mapema kama MAX_SESSIONS inazidi uwezo wa CPU ya Space hii.
# Re-encode ya 360p (TARGET_HEIGHT, veryfast+zerolatency) ni nyepesi zaidi
# kuliko 480p ya awali β€” takriban session 1.5-2 kwa kila CPU core kwa
# kawaida. Session nyingi mno kwenye CPU chache ndizo sababu ya kuchelewa
# kuanza (dakika kadhaa) na segments ndefu mno (>10s) ulizoziona awali.
_cpu = os.cpu_count() or 1
if FORCE_REENCODE and MAX_SESSIONS > max(1, _cpu * 2):
logging.getLogger("bridge").warning(
"MAX_SESSIONS=%s na FORCE_REENCODE=true kwenye CPU zenye cores %s pekee β€” "
"hata kwa 360p (nyepesi), hii huenda ikasababisha kuchelewa kuanza na "
"segments ndefu mno wakati session nyingi zinaendesha kwa wakati mmoja. "
"Punguza MAX_SESSIONS, au pandisha Space tier.",
MAX_SESSIONS, _cpu,
)
UA = "Mozilla/5.0 (Linux; Android 13) AppleWebKit/537.36 Chrome/124.0 Mobile Safari/537.36"
SESSIONS: dict = {}
LOCK = threading.Lock()
_key_opt = None
PLAN_CACHE: dict = {} # mpd|key -> (time, plan): ffprobe mara moja tu
DETAIL_CACHE: dict = {} # channel id -> (time, (mpd, key))
CACHE_TTL = int(os.environ.get("CACHE_TTL", "1800"))
class BridgeError(Exception):
def __init__(self, status: int, detail: str):
super().__init__(detail)
self.status, self.detail = status, detail
def cors(resp: Response) -> Response:
resp.headers["Access-Control-Allow-Origin"] = "*"
resp.headers["Access-Control-Expose-Headers"] = "*"
return resp
def err(status: int, detail: str) -> Response:
return cors(JSONResponse({"detail": detail}, status_code=status))
# ───────────────────────── ffmpeg ─────────────────────────
def key_option() -> str:
global _key_opt
if _key_opt:
return _key_opt
opt = "-decryption_key"
try:
out = subprocess.run(["ffmpeg", "-hide_banner", "-h", "demuxer=dash"],
capture_output=True, text=True, timeout=10).stdout
if "cenc_decryption_key" in out:
opt = "-cenc_decryption_key"
except Exception:
pass
_key_opt = opt
return opt
def check_public_url(url: str) -> None:
p = urlparse(url)
if p.scheme not in ("http", "https") or not p.hostname:
raise BridgeError(400, "MPD lazima iwe URL ya http/https")
try:
for info in socket.getaddrinfo(p.hostname, None):
ip = ipaddress.ip_address(info[4][0])
if ip.is_private or ip.is_loopback or ip.is_link_local or ip.is_reserved:
raise BridgeError(400, "Anwani hairuhusiwi")
except socket.gaierror:
raise BridgeError(400, "Host haipatikani")
def clean_hex(s) -> str:
return re.sub(r"[^0-9a-fA-F]", "", s or "").lower()
def tail(path: str, n: int = 6) -> str:
try:
with open(path, "r", errors="ignore") as f:
return " | ".join(f.read().strip().splitlines()[-n:])
except Exception:
return ""
def slugify(name: str) -> str:
return re.sub(r"[^a-z0-9]+", "-", (name or "").lower()).strip("-")[:40] or "stream"
def input_args(key: str) -> list:
a = ["-thread_queue_size", "4096", # v2: akiba kubwa zaidi ya packet queue β€”
# inazuia 'kuganda' fupi kila ffmpeg
# inapofungua segment mpya kutoka CDN
# (tulithibitisha hili kwa Azam One/Crown TV
# kwa kuangalia 'dup=' burst zinazoambatana
# na mistari ya '[dash] Opening ... for reading')
"-protocol_whitelist", "http,https,tcp,tls,crypto", "-user_agent", UA,
"-analyzeduration", "1500000", "-probesize", "1000000",
"-reconnect", "1", "-reconnect_streamed", "1", "-reconnect_at_eof", "1",
"-reconnect_on_network_error", "1", "-reconnect_on_http_error", "4xx,5xx",
"-reconnect_delay_max", "10", "-rw_timeout", "15000000",
"-multiple_requests", "1"] # tumia muunganisho ule ule (HTTP keep-alive) badala ya TCP/TLS handshake mpya kila segment mpya
if key:
a += [key_option(), key]
return a
def _br(st: dict) -> int:
try:
return int(st.get("bit_rate") or 0)
except (TypeError, ValueError):
return 0
def _double_rate(rate: str) -> str:
"""'800k' -> '1600k' (kwa -bufsize, inapaswa kuwa ~2x -maxrate)."""
m = re.match(r"(\d+)([kKmM]?)$", rate.strip())
if not m:
return rate
return f"{int(m.group(1)) * 2}{m.group(2)}"
def build_plan(mpd: str, key: str):
"""Chunguza MPD kwa ffprobe kisha chagua: video za H.264 za ubora tofauti
na sauti moja kwa kila lugha. Ikishindwa, rudisha None (track moja tu)."""
if not shutil.which("ffprobe"):
return None
ck = f"{mpd}|{key}"
hit = PLAN_CACHE.get(ck)
if hit and time.time() - hit[0] < CACHE_TTL:
return hit[1]
plan = _probe_plan(mpd, key)
if plan:
PLAN_CACHE[ck] = (time.time(), plan)
return plan
def _probe_plan(mpd: str, key: str):
cmd = ["ffprobe", "-v", "error", "-of", "json",
"-show_entries", "stream=index,codec_type,codec_name,width,height,bit_rate:stream_tags=language",
*input_args(key), mpd]
try:
out = subprocess.run(cmd, capture_output=True, text=True, timeout=20)
streams = json.loads(out.stdout or "{}").get("streams", [])
except Exception:
return None
vids = [x for x in streams if x.get("codec_type") == "video"]
h264 = [x for x in vids if x.get("codec_name") == "h264"] or vids[:1]
best = {}
for x in h264: # moja kwa kila height (yenye bitrate kubwa zaidi)
h = int(x.get("height") or 0)
if h not in best or _br(x) > _br(best[h]):
best[h] = x
def _rank(x):
h = int(x.get("height") or 0)
return (0 if h <= TARGET_HEIGHT else 1, abs(h - TARGET_HEIGHT), -_br(x))
pick = min(best.values(), key=_rank) if best else None
top = [pick] if pick else []
top.sort(key=lambda x: (int(x.get("height") or 0), _br(x))) # kuanzia ubora wa chini
videos, used = [], set()
for i, x in enumerate(top):
h = int(x.get("height") or 0)
name = f"{h}p" if h else f"v{i}"
while name in used:
name += "b"
used.add(name)
videos.append((x["index"], name))
if not videos:
return None
audios, seen = [], {}
bestl = {}
for i, x in enumerate([x for x in streams if x.get("codec_type") == "audio"]):
lang = ((x.get("tags") or {}).get("language") or "und").lower()[:8]
lang = re.sub(r"[^a-z0-9-]", "", lang) or "und"
k = lang if lang != "und" else f"und{i}"
if k not in bestl or _br(x) > _br(bestl[k][1]):
bestl[k] = (lang, x)
AUDIO_LANGS = [l.strip() for l in os.environ.get("AUDIO_LANGS", "sw,swh,swa").split(",") if l.strip()]
pref = [v for v in bestl.values() if v[0] in AUDIO_LANGS]
chosen = pref[:1] if pref else list(bestl.values())[:1]
for lang, x in chosen:
base = lang if lang != "und" else f"aud{len(audios)}"
name, n = base, 1
while name in used:
n += 1
name = f"{base}{n}"
used.add(name)
audios.append((x["index"], name, lang))
return {"videos": videos, "audios": audios}
# ── MPYA: msaidizi wa segment handling ──
def parse_extinf_durations(playlist_path: str) -> list:
"""Soma #EXTINF kwenye playlist ili kupima kama segments zina urefu
sawa (GOP alignment nzuri) au zinatofautiana sana (dalili ya tatizo la
keyframe wakati wa -c:v copy β€” hii ndiyo sababu kuu ya kuganda)."""
out = []
try:
with open(playlist_path, "r", errors="ignore") as f:
for line in f:
if line.startswith("#EXTINF:"):
try:
out.append(float(line[8:].split(",")[0]))
except ValueError:
pass
except FileNotFoundError:
pass
return out
def newest_segment_mtime(d: str, variants: list) -> float | None:
"""Wakati (mtime) wa segment ya mwisho kutengenezwa, ikitafuta kwenye
saraka za variants ZOTE (video na audio) β€” hutumika na watchdog
kugundua ffmpeg iliyoganda (stall) hata kama variant moja tu ndiyo
imesimama kutengeneza segments."""
newest = None
for v in variants:
vdir = os.path.join(d, v)
try:
for name in os.listdir(vdir):
if name.startswith("seg_") and name.endswith(".ts"):
mt = os.path.getmtime(os.path.join(vdir, name))
if newest is None or mt > newest:
newest = mt
except FileNotFoundError:
pass
return newest
def spawn_ffmpeg(sid: str, mpd: str, key: str, plan, slug: str, reencode: bool = False) -> dict:
d = os.path.join(ROOT, sid)
shutil.rmtree(d, ignore_errors=True)
os.makedirs(d, exist_ok=True)
logp = os.path.join(d, "ffmpeg.log")
master = f"{slug}.m3u8"
cmd = ["ffmpeg", "-hide_banner", "-loglevel", os.environ.get("FFMPEG_LOGLEVEL", "info").strip(),
"-nostdin", "-fflags", "+genpts+discardcorrupt", *input_args(key), "-i", mpd]
seg = lambda v: os.path.join(d, v, "seg_%05d.ts")
if plan:
vs, au = plan["videos"], plan["audios"]
for idx, _ in vs:
cmd += ["-map", f"0:{idx}"]
for idx, _, _ in au:
cmd += ["-map", f"0:{idx}"]
vmap = []
for i, (_, name) in enumerate(vs):
vmap.append(f"v:{i}" + (",agroup:aud" if au else "") + f",name:{name}")
for j, (_, name, lang) in enumerate(au):
e = f"a:{j},agroup:aud,name:{name}"
if lang != "und":
e += f",language:{lang}"
if j == 0:
e += ",default:yes"
vmap.append(e)
variants = [n for _, n in vs] + [n for _, n, _ in au]
tail_args = ["-master_pl_name", master, "-var_stream_map", " ".join(vmap),
"-hls_segment_filename", seg("%v"), os.path.join(d, "%v", "index.m3u8")]
else: # ffprobe imeshindwa: track moja ya video na moja ya sauti
variants = ["main"]
cmd += ["-map", "0:v:0", "-map", "0:a:0?"]
tail_args = ["-hls_segment_filename", seg("main"), os.path.join(d, "main", "index.m3u8")]
with open(os.path.join(d, master), "w") as f:
f.write("#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=2500000\nmain/index.m3u8\n")
for v in variants:
os.makedirs(os.path.join(d, v), exist_ok=True)
# ── MPYA: GOP alignment ──
# -c:v copy ni haraka na haitumii CPU, lakini segment za HLS zinaweza
# kukatwa tu penye keyframe ya chanzo. Kama chanzo halina keyframe kila
# HLS_TIME sekunde, segments zitakuwa na urefu tofauti-tofauti na
# wachezaji (hasa AVPlayer ya iPhone) wataganda/kuruka. Ukiwasha
# FORCE_REENCODE=true (au tuma "reencode": true kwenye /bridge/start),
# video inabadilishwa kupitia libx264 ikiwa na -g/-keyint_min/
# -sc_threshold 0 + -force_key_frames ili kila segment ianze na
# keyframe kamili β€” hii ndiyo dawa ya uhakika ya "freezing", kwa gharama
# ya CPU zaidi.
if reencode:
gop = max(HLS_TIME * REENCODE_FPS, REENCODE_FPS)
# v2: "-vf scale" inalazimisha 360p (TARGET_HEIGHT) HATA kama chanzo
# ni 480p/720p/1080p β€” hii ndiyo "360 quality kote" + inapunguza CPU
# na bandwidth, ikiruhusu session nyingi 24/7 kwa uthabiti. "-2"
# inahakikisha upana unabaki namba sawa (divisible na 2, muhimu kwa
# x264). "-b:v"/"-maxrate"/"-bufsize" zinaweka bitrate inayolingana
# na 360p badala ya kurithi bitrate kubwa ya chanzo bila sababu.
vcodec_args = [
"-vf", f"scale=-2:{TARGET_HEIGHT}:flags=fast_bilinear",
# v2.1: VFR badala ya CFR ya default β€” Azam/Crown TV (na huenda
# vyanzo vingine) vinatuma frame kwa kasi ya chini ya ile
# 'inayodhaniwa', hivyo CFR ililazimisha ffmpeg kuRudia (dup=)
# karibu 50-70% ya frame kila mara ili 'kujaza pengo' β€” hilo
# ndilo lililoonekana kama 'kuganda'. VFR inatuma frame kama
# zinavyofika kweli; segment bado zinakatwa sahihi kila
# HLS_TIME (force_key_frames inategemea muda wa saa, si idadi
# ya frame), hivyo GOP alignment haiathiriki.
"-fps_mode", "vfr",
"-c:v", "libx264", "-preset", "veryfast", "-tune", "zerolatency",
"-profile:v", "main", "-pix_fmt", "yuv420p",
"-b:v", VIDEO_BITRATE, "-maxrate", VIDEO_BITRATE, "-bufsize", _double_rate(VIDEO_BITRATE),
"-g", str(gop), "-keyint_min", str(gop), "-sc_threshold", "0",
"-force_key_frames", f"expr:gte(t,n_forced*{HLS_TIME})",
]
else:
vcodec_args = ["-c:v", "copy"]
cmd += [*vcodec_args,
"-c:a", "aac", "-b:a", "128k", "-ac", "2", # sauti -> AAC kwa iPhone
# aresample inazuia audio/video kutengana (drift) hasa video
# ikiwa copy na audio ikiwa imebadilishwa (re-encoded).
"-af", "aresample=async=1:min_hard_comp=0.100:first_pts=0",
"-max_muxing_queue_size", "1024",
"-f", "hls", "-hls_time", str(HLS_TIME),
"-hls_list_size", str(HLS_LIST_SIZE),
"-hls_delete_threshold", str(HLS_DELETE_THRESHOLD),
# append_list: playlist haiandikwi upya kabisa kila segment (I/O
# kidogo). temp_file: kila segment na playlist zinaandikwa
# kwenye .tmp kisha kubadilishwa jina (atomic rename) β€” hakuna
# mteja atakayesoma faili nusu-andikwa.
"-hls_flags", "delete_segments+append_list+independent_segments+program_date_time+temp_file",
"-hls_segment_type", "mpegts", *tail_args]
proc = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=open(logp, "w"))
return {"proc": proc, "dir": d, "log": logp, "last": time.time(), "started": time.time(),
"mpd": mpd, "key": key, "plan": plan, "slug": slug, "reencode": reencode,
"master": master, "variants": variants, "ready": False}
def stop_session(sid: str) -> None:
with LOCK:
s = SESSIONS.pop(sid, None)
if not s:
return
try:
s["proc"].terminate()
s["proc"].wait(timeout=5)
except Exception:
try:
s["proc"].kill()
except Exception:
pass
shutil.rmtree(s["dir"], ignore_errors=True)
def restart_session(sid: str) -> None:
"""MPYA: anzisha upya ffmpeg ya session iliyoganda (stall), ukitumia
mpd/key/plan/slug/reencode zilizohifadhiwa tayari (hakuna ffprobe
tena β€” haraka). Saraka mpya inaanza upya kabisa (segment 0), hivyo
kuna rebuffer fupi kwa mtazamaji, lakini stream inaendelea badala ya
kubaki imeganda milele."""
with LOCK:
s = SESSIONS.get(sid)
if not s:
return
mpd, key, plan, slug, reencode = s["mpd"], s["key"], s["plan"], s["slug"], s["reencode"]
stop_session(sid)
try:
with LOCK:
SESSIONS[sid] = spawn_ffmpeg(sid, mpd, key, plan, slug, reencode)
wait_ready(sid)
log.info("Session %s: imeanzishwa upya kikamilifu baada ya stall", sid)
except BridgeError:
log.exception("Session %s: imeshindwa kuanzisha upya baada ya stall", sid)
def wait_ready(sid: str) -> None:
s = SESSIONS.get(sid)
if not s:
raise BridgeError(500, "Session imeondolewa wakati wa kuanza")
def ready() -> bool:
if not os.path.exists(os.path.join(s["dir"], s["master"])):
return False
# Tayari mara segment ya kwanza ya video ipo (sio kusubiri kila track)
try:
with open(os.path.join(s["dir"], s["variants"][0], "index.m3u8")) as f:
return f.read().count(".ts") >= 1
except FileNotFoundError:
return False
t0 = time.time()
while time.time() - t0 < READY_TIMEOUT:
rc = s["proc"].poll()
if rc is not None:
msg = tail(s["log"]) or "hakuna maelezo"
stop_session(sid)
raise BridgeError(502, f"ffmpeg ilizimika (code {rc}): " + msg)
if SESSIONS.get(sid) is not s:
raise BridgeError(500, "Session iliondolewa wakati wa kuanza. Jaribu tena.")
if ready():
s["ready"] = True
s["last"] = time.time()
# MPYA: angalia kama segments zina urefu sawa. Kama zinatofautiana
# sana na -c:v copy ndiyo inatumika, andika onyo wazi ili
# mwendeshaji ajue kuwasha FORCE_REENCODE=true.
if not s["reencode"]:
durs = parse_extinf_durations(os.path.join(s["dir"], s["variants"][0], "index.m3u8"))
if len(durs) >= 2:
lo, hi = min(durs), max(durs)
if hi > HLS_TIME * 2.5 or (hi - lo) > HLS_TIME * 1.5:
log.warning(
"Session %s: urefu wa segments hautofautiani sawasawa "
"(min=%.1fs max=%.1fs, lengo=%ss) β€” chanzo hakina keyframe "
"ya kutosha kwa -c:v copy, hii ndiyo sababu ya kuganda/"
"kuruka-ruka. Washa FORCE_REENCODE=true au tuma "
"'reencode': true kwenye /bridge/start.",
sid, lo, hi, HLS_TIME,
)
return
time.sleep(0.2)
msg = tail(s["log"], 8) or "ffmpeg haikutoa log yoyote (huenda inasubiri jibu la seva ya chanzo)"
stop_session(sid)
raise BridgeError(504, "Muda umeisha kusubiri stream. " + msg)
def start_session(mpd: str, key: str, name: str = "", reencode: bool | None = None) -> str:
mpd = (mpd or "").strip()
check_public_url(mpd)
k = clean_hex(key)
if key and not re.fullmatch(r"[0-9a-f]{32}", k):
raise BridgeError(400, "Key lazima iwe hex ya herufi 32")
want_reencode = FORCE_REENCODE if reencode is None else bool(reencode)
sid = hashlib.sha256(f"{ID_SECRET}|{mpd}|{k}|{want_reencode}".encode()).hexdigest()[:24]
with LOCK:
s = SESSIONS.get(sid)
if s and s["proc"].poll() is None:
s["last"] = time.time()
return sid
plan = build_plan(mpd, k) # ffprobe nje ya LOCK (inaweza kuchukua sekunde kadhaa)
with LOCK:
s = SESSIONS.get(sid)
if s and s["proc"].poll() is None:
s["last"] = time.time()
return sid
SESSIONS.pop(sid, None)
live = sum(1 for x in SESSIONS.values() if x["proc"].poll() is None)
if live >= MAX_SESSIONS:
raise BridgeError(503, "Server ina shughuli nyingi, jaribu tena baadaye")
SESSIONS[sid] = spawn_ffmpeg(sid, mpd, k, plan, slugify(name), want_reencode)
wait_ready(sid)
return sid
def public_url(sid: str) -> str:
s = SESSIONS.get(sid)
master = s["master"] if s else "stream.m3u8"
return f"{SELF_URL or 'http://localhost:7860'}/hls/{sid}/{master}"
def housekeeping_loop():
last_ping = time.time()
while True:
time.sleep(10)
now = time.time()
for sid, s in list(SESSIONS.items()):
idle = now - s["last"] > IDLE_TIMEOUT
starting_too_long = (not s.get("ready")) and now - s["last"] > READY_TIMEOUT + 30
if (s.get("ready") and idle) or starting_too_long or s["proc"].poll() is not None:
stop_session(sid)
if SELF_URL and now - last_ping > PING_INTERVAL_SECONDS:
last_ping = now
try:
requests.get(SELF_URL, timeout=15)
except Exception:
pass
def watchdog_loop():
"""MPYA: fuatilia kila session iliyo 'ready'; ikiwa hakuna segment mpya
(kwenye variant yoyote) kwa zaidi ya STALL_TIMEOUT sekunde ingawa
mchakato bado unaendesha (yaani imeganda, si imekufa), anzisha upya
kiotomatiki kupitia restart_session(). Hii ndiyo inayozuia stream
'kufungia' na kubaki hivyo milele hadi mtu aingilie kati."""
while True:
time.sleep(5)
now = time.time()
with LOCK:
items = list(SESSIONS.items())
for sid, s in items:
if not s.get("ready") or s["proc"].poll() is not None:
continue
newest = newest_segment_mtime(s["dir"], s["variants"]) or s.get("started", s["last"])
stalled_for = now - newest
if stalled_for > STALL_TIMEOUT:
log.warning(
"Session %s: hakuna segment mpya kwa %.0fs (kikomo=%ss) β€” "
"ffmpeg imeganda, kuanzisha upya", sid, stalled_for, STALL_TIMEOUT,
)
restart_session(sid)
threading.Thread(target=housekeeping_loop, daemon=True).start()
threading.Thread(target=watchdog_loop, daemon=True).start()
def warm_loop():
"""v2: inawasha channel ZOTE za jaynestv (kiotomatiki kutoka Supabase β€”
"16 ziwe 24/7") ili zibaki 'hai' kama TV halisi, mtazamaji akibonyeza
video inaanza papo hapo badala ya kusubiri ffmpeg ianze.
Mgawanyo kati ya Space nyingi: kila channel inapewa Space KWA HASH YA
JINA LAKE (pick_index, ile ile inayotumika kwenye edge function ya
Supabase "iphone-stream") β€” Space hii inawarm TU channel zinazoiangukia
yenyewe (SPACE_INDEX/SPACE_COUNT), si zote, ili channel moja isianzishwe
mara mbili kwenye Space mbili tofauti wakati huo huo.
Usiku (saa 6 usiku – saa 3 asubuhi EAT, HARDCODED): warm inasimama β€”
hakuna channel mpya inayoanzishwa mapema. Channel zinazotazamwa na watu
halisi wakati huo HAZIKATWI papo hapo; zinaendelea mpaka mtazamaji
aondoke, kisha housekeeping_loop ya kawaida (IDLE_TIMEOUT) ndiyo
inayozisimamisha β€” si warm_loop hii.
WARM_CHANNELS (hiari): ukiiweka, inachuja orodha kuwa majina hayo tu
badala ya channel zote 16 (kwa mfano ukitaka Sports pekee ziwe 24/7).
"""
time.sleep(5)
manual = [x.strip() for x in os.environ.get("WARM_CHANNELS", "").split(",") if x.strip()]
workers = int(os.environ.get("WARM_WORKERS", "2"))
was_night = None
def _warm_one(n):
try:
url, msg = ui_start_channel(n)
if not url:
log.warning("WARM FAIL %s: %s", n, str(msg)[:300])
except Exception:
log.exception("warm %s", n)
while True:
night = is_night_eat()
if night != was_night:
log.info(
"warm_loop[space %s/%s]: %s (saa %02d:00 EAT)",
SPACE_INDEX, SPACE_COUNT,
"inalala (00:00–09:00 EAT) β€” channel mpya hazitaanzishwa mapema" if night
else "imeamka β€” inaanza kuwasha channel za 24/7",
datetime.now(EAT).hour,
)
was_night = night
try:
if not night:
if not CHANNELS:
CHANNELS.update(fetch_channels())
all_names = manual or list(CHANNELS)
mine = [n for n in all_names if pick_index(n, SPACE_COUNT) == SPACE_INDEX]
if mine:
with ThreadPoolExecutor(max_workers=workers) as ex:
list(ex.map(_warm_one, mine))
except Exception:
log.exception("warm_loop")
time.sleep(300 if night else 20)
# ───────────────────────── Routes ─────────────────────────
# /bridge/start inakubali POST ya JSON (Content-Type: text/plain inaepuka preflight ya CORS).
async def bridge_start(request: Request):
try:
body = await request.json()
except Exception:
return err(400, "JSON si sahihi.")
if BRIDGE_TOKEN and body.get("token") != BRIDGE_TOKEN:
return err(401, "Token si sahihi.")
try:
sid = await run_in_threadpool(
start_session, body.get("mpd"), body.get("key"),
str(body.get("name") or ""), body.get("reencode"),
)
except BridgeError as e:
return err(e.status, e.detail)
return cors(JSONResponse({"id": sid, "url": public_url(sid)}))
async def bridge_options(request: Request):
r = Response(status_code=204)
r.headers["Access-Control-Allow-Origin"] = "*"
r.headers["Access-Control-Allow-Methods"] = "GET, POST, OPTIONS"
r.headers["Access-Control-Allow-Headers"] = request.headers.get("access-control-request-headers", "*")
return r
async def bridge_stop(sid: str):
if re.fullmatch(r"[a-f0-9]{24}", sid):
await run_in_threadpool(stop_session, sid)
return cors(JSONResponse({"ok": True}))
HLS_PATH_RE = re.compile(r"[A-Za-z0-9_-]{1,40}\.m3u8|[A-Za-z0-9_-]{1,30}/(?:index\.m3u8|seg_\d{5}\.ts)")
async def hls_file(sid: str, path: str):
if not re.fullmatch(r"[a-f0-9]{24}", sid) or not HLS_PATH_RE.fullmatch(path):
return err(404, "Haipatikani")
s = SESSIONS.get(sid)
if not s:
return err(404, "Session haipo")
s["last"] = time.time()
full = os.path.join(s["dir"], path)
if not os.path.exists(full):
return err(404, "Haipatikani")
if path.endswith(".m3u8"):
# no-store: mteja lazima aombe upya kila mara, kamwe asicache playlist
r = FileResponse(full, media_type="application/vnd.apple.mpegurl",
headers={"Cache-Control": "no-store", "Accept-Ranges": "bytes"})
else:
# MPYA: segments ni immutable mara zinapotengenezwa (jina la faili
# halirudiwi) β€” cache ndefu zaidi inapunguza maombi ya mara kwa mara
# kwa CDN/edge na inapunguza uwezekano wa 404 wa muda.
r = FileResponse(full, media_type="video/mp2t",
headers={"Cache-Control": "public, max-age=86400, immutable", "Accept-Ranges": "bytes"})
return cors(r)
async def bridge_log(sid: str, lines: int = 200):
"""MPYA: onyesha mistari ya mwisho ya ffmpeg.log ya session fulani kwa
njia ya browser β€” bila hii, stderr ya ffmpeg (yenye speed=, makosa ya
decode, 'Non-monotonic DTS', n.k.) haionekani popote kwenye Space Logs
kwa sababu kila session inaiandika kwenye faili lake ndani ya /tmp."""
if not re.fullmatch(r"[a-f0-9]{24}", sid):
return err(404, "sid si sahihi")
s = SESSIONS.get(sid)
if not s:
return err(404, "Session haipo")
try:
with open(s["log"], "r", errors="ignore") as f:
content = f.read().strip().splitlines()[-max(1, min(lines, 2000)):]
except FileNotFoundError:
content = []
return cors(Response("\n".join(content) or "(logi tupu)", media_type="text/plain"))
async def bridge_health():
# MPYA: subprocess.run ni blocking β€” ikiwa imeachwa moja kwa moja ndani
# ya route ya async, inaganda event loop NZIMA ya FastAPI wakati CPU
# tayari imelemewa na ffmpeg za re-encode (ndiyo sababu /bridge/health
# ilichukua sekunde 22 β€” si tatizo la health check lenyewe, bali CPU
# contention iliyoathiri hata ombi hili dogo). run_in_threadpool
# inaiweka kwenye thread tofauti ili isizuie maombi mengine.
r = await run_in_threadpool(subprocess.run, ["ffmpeg", "-version"], capture_output=True, text=True)
first = (r.stdout or r.stderr or "").splitlines()[:1]
live = sum(1 for s in SESSIONS.values() if s["proc"].poll() is None)
reencoding = sum(1 for s in SESSIONS.values() if s["proc"].poll() is None and s["reencode"])
return cors(JSONResponse({
"ok": True, "sessions": live, "reencoding_sessions": reencoding,
"cpu_count": os.cpu_count(), "key_option": key_option(),
"ffmpeg": first[0] if first else "haijulikani",
"hls_time": HLS_TIME, "hls_list_size": HLS_LIST_SIZE,
"stall_timeout": STALL_TIMEOUT, "force_reencode": FORCE_REENCODE,
"max_sessions": MAX_SESSIONS, "target_height": TARGET_HEIGHT,
"video_bitrate": VIDEO_BITRATE, "space": f"{SPACE_INDEX}/{SPACE_COUNT}",
"night_mode_eat": is_night_eat(), "hour_eat": datetime.now(EAT).hour,
}))
# ───────────────────────── UI ─────────────────────────
def ui_start(mpd, key, name="", reencode=None):
try:
sid = start_session(mpd, key, name, reencode)
return public_url(sid), "βœ… Imeanza"
except BridgeError as e:
return "", f"❌ {e.detail}"
def ui_list():
now = time.time()
return "\n".join(
f"{sid} idle={int(now - s['last'])}s reencode={s['reencode']} {s['mpd'][:60]}"
for sid, s in SESSIONS.items()
) or "Hakuna session."
def ui_stop_all():
for sid in list(SESSIONS):
stop_session(sid)
return "Zimezimwa."
# ───────────── Channels kutoka Supabase edge function ─────────────
# Secret ya Space: SUPABASE_ANON_KEY (publishable key). Hiari: SUPABASE_BASE.
SUPABASE_BASE = os.environ.get(
"SUPABASE_BASE",
"https://ooqvsqmsnwjqvuzbhczx.supabase.co/functions/v1/jaynes-max-tv",
).rstrip("/")
CHANNELS: dict[str, str] = {} # jina -> id
# ───────────── MPYA: relay ya dodolive.live (cheti chake kimevunjika) ─────────────
# dodolive.live ina TLS cert isiyolingana na domain yake (cert mismatch +
# untrusted). Deno/Supabase Edge Function haiwezi kupuuza hilo kwa fetch()
# ya kawaida, hivyo tunapitisha maombi kupitia hapa (Python requests
# inaweza kuzima uthibitisho wa cheti kwa ombi hili MOJA TU). Badilisha
# BASE kwenye edge function ya DodoLive kuelekeza hapa badala ya moja kwa
# moja dodolive.live:
# const BASE = 'https://<space-yako>.hf.space/relay/dodolive/api/';
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
DODOLIVE_BASE = os.environ.get("DODOLIVE_BASE", "https://dodolive.live").rstrip("/")
async def relay_dodolive(request: Request, path: str):
url = f"{DODOLIVE_BASE}/{path}"
body = await request.body()
fwd_headers = {k: v for k, v in request.headers.items()
if k.lower() not in ("host", "content-length", "accept-encoding")}
try:
r = await run_in_threadpool(
requests.request, request.method, url,
params=dict(request.query_params), data=body, headers=fwd_headers,
timeout=25, verify=False, # ← hapa pekee tunapuuza kosa la cheti cha dodolive.live
)
except requests.RequestException as e:
return err(502, f"Relay kwenda dodolive.live imeshindwa: {e}")
resp_headers = {k: v for k, v in r.headers.items()
if k.lower() not in ("content-encoding", "transfer-encoding", "connection")}
return Response(content=r.content, status_code=r.status_code, headers=resp_headers,
media_type=r.headers.get("content-type"))
def _sb_get(path: str):
tok = os.environ.get("SUPABASE_ANON_KEY") or "sb_publishable_-B4goS_nTpi2UvK8bFyCiA_CV5UH4Ic" # publishable key (ya umma kwa muundo); secret ikiwekwa inachukua nafasi
r = requests.get(
f"{SUPABASE_BASE}{path}",
headers={"Authorization": f"Bearer {tok}", "apikey": tok},
timeout=20,
)
if r.status_code != 200:
raise BridgeError(502, f"Supabase {r.status_code}: {r.text[:120]}")
return r.json()
def _find(obj, names) -> str:
"""Tafuta string ya kwanza yenye jina lolote kwenye `names`, hata ndani ya nested JSON."""
if isinstance(obj, dict):
for n in names:
v = obj.get(n)
if isinstance(v, str) and v.strip():
return v.strip()
for v in obj.values():
r = _find(v, names)
if r:
return r
elif isinstance(obj, list):
for v in obj:
r = _find(v, names)
if r:
return r
return ""
def _strings(obj):
if isinstance(obj, str):
yield obj
elif isinstance(obj, dict):
for v in obj.values():
yield from _strings(v)
elif isinstance(obj, list):
for v in obj:
yield from _strings(v)
def extract_stream(detail) -> tuple[str, str]:
mpd = next((x for x in _strings(detail) if x.startswith("http") and ".mpd" in x), "")
if not mpd:
mpd = _find(detail, ["mpd", "manifest", "manifest_url", "stream_url", "url"])
key = _find(detail, ["key", "clearkey", "clear_key", "license_key", "k"]).split(":")[-1]
return mpd, key
def fetch_channels() -> dict[str, str]:
data = _sb_get("/api/content/channels")
items = data
if isinstance(data, dict):
items = next(
(data[k] for k in ("channels", "data", "items", "results") if isinstance(data.get(k), list)),
next((v for v in data.values() if isinstance(v, list)), []),
)
out: dict[str, str] = {}
for c in items if isinstance(items, list) else []:
if not isinstance(c, dict):
continue
cid = c.get("id") or c.get("_id") or c.get("slug")
if cid is None:
continue
name = str(c.get("name") or c.get("title") or c.get("channel_name") or cid)
if name in out:
name = f"{name} ({cid})"
out[name] = str(cid)
return out
def ui_refresh():
try:
found = fetch_channels()
except Exception as e:
log.exception("fetch_channels imeshindwa")
return gr.update(choices=[]), f"❌ Channels: {getattr(e, 'detail', e)}"
CHANNELS.clear()
CHANNELS.update(found)
return gr.update(choices=list(CHANNELS)), f"βœ… Channels: {len(CHANNELS)}"
def ui_start_channel(name: str) -> tuple[str, str]:
cid = CHANNELS.get(name)
if not cid:
return "", "❌ Chagua channel kwanza"
hit = DETAIL_CACHE.get(cid)
if hit and time.time() - hit[0] < CACHE_TTL:
mpd, key = hit[1]
else:
try:
detail = _sb_get(f"/api/channel/{cid}")
except BridgeError as e:
return "", f"❌ {e.detail}"
except Exception as e:
return "", f"❌ Channel: {e}"
mpd, key = extract_stream(detail)
if not mpd:
fields = list(detail.keys()) if isinstance(detail, dict) else type(detail).__name__
return "", f"❌ Sikupata MPD kwenye jibu la channel. Fields: {fields}"
DETAIL_CACHE[cid] = (time.time(), (mpd, key))
return ui_start(mpd, key, name)
def health_check() -> str:
return "ok"
with gr.Blocks(title="JAYNES MAX β€” HLS Bridge") as demo:
gr.Markdown("## JAYNES MAX β€” HLS Bridge\nMPD + ClearKey β†’ HLS kwa iPhone")
mpd_in = gr.Textbox(label="MPD URL")
key_in = gr.Textbox(label="KEY (hex 32)")
reencode_in = gr.Checkbox(
label=f"Lazimisha re-encode (GOP aligned, {TARGET_HEIGHT}p) β€” zima tu ukitaka copy ya haraka bila GOP fix",
value=FORCE_REENCODE,
)
go = gr.Button("Anza", variant="primary")
out_url = gr.Textbox(label="HLS URL", interactive=False)
out_msg = gr.Markdown()
go.click(ui_start, [mpd_in, key_in, gr.State(""), reencode_in], [out_url, out_msg], api_name=False)
ch_dd = gr.Dropdown(label="Channel (JaynesMaxTV)", choices=[])
with gr.Row():
refresh = gr.Button("Pakia channels")
go_ch = gr.Button("Cheza channel", variant="primary")
refresh.click(ui_refresh, None, [ch_dd, out_msg], api_name=False)
go_ch.click(ui_start_channel, ch_dd, [out_url, out_msg], api_name=False)
demo.load(ui_refresh, None, [ch_dd, out_msg], api_name=False)
sess_out = gr.Textbox(label="Sessions", interactive=False, lines=3)
with gr.Row():
gr.Button("Onyesha sessions").click(ui_list, None, sess_out, api_name=False)
gr.Button("Zima zote").click(ui_stop_all, None, sess_out, api_name=False)
health_out = gr.Textbox(visible=False)
demo.load(fn=health_check, outputs=health_out, api_name="health")
demo.queue(max_size=20)
demo.launch(prevent_thread_lock=True)
# Ongeza routes zetu mbele ya routes za Gradio ili zipate kipaumbele
_fastapi = demo.app
_before = len(_fastapi.router.routes)
_fastapi.add_api_route("/bridge/start", bridge_start, methods=["POST"])
_fastapi.add_api_route("/bridge/start", bridge_options, methods=["OPTIONS"])
_fastapi.add_api_route("/bridge/stop/{sid}", bridge_stop, methods=["POST"])
_fastapi.add_api_route("/bridge/health", bridge_health, methods=["GET"])
_fastapi.add_api_route("/bridge/log/{sid}", bridge_log, methods=["GET"])
_fastapi.add_api_route("/relay/dodolive/{path:path}", relay_dodolive, methods=["GET", "POST", "OPTIONS"])
_fastapi.add_api_route("/hls/{sid}/{path:path}", hls_file, methods=["GET", "HEAD"])
_new = _fastapi.router.routes[_before:]
_fastapi.router.routes[:] = _new + _fastapi.router.routes[:_before]
threading.Thread(target=warm_loop, daemon=True).start()
demo.block_thread()