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://.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()