Spaces:
Paused
Paused
Download app.py from JAYNESTV/iphone-stream: direct link, hf CLI and curl.
- Browser
- Download file 42.8 kB
-
https://huggingface.co/spaces/JAYNESTV/iphone-stream/resolve/refs%2Fpr%2F2/app.py
- Command line
-
hf download hf://spaces/JAYNESTV/iphone-stream@refs/pr/2/app.py
-
curl -L -o app.py https://huggingface.co/spaces/JAYNESTV/iphone-stream/resolve/refs%2Fpr%2F2/app.py
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 | |
| 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() | |