v2.12-matchgop: copy-first; on YouTube noData/gopSizeLong switch THIS publisher to same-size closed GOP 2s (not default 720). Cuts live by operator request.

ingest.py

@@ -6,7 +6,7 @@ import os, threading, time
 from datetime import datetime
 from zoneinfo import ZoneInfo
 
-APP_VERSION = 'relay-v2.11-handoff'
+APP_VERSION = 'relay-v2.12-matchgop'
 
 
 def env_rtmp_destination():

relay.py

@@ -162,8 +162,8 @@ class Sender:
            fixed720  -> constant  720x1280 canvas, re-encodes (lighter on CPU)
         """
         mode=(self.mode_override or os.getenv('YOUTUBE_SEND_MODE','auto')).strip().lower()
-        if mode not in ('auto','copy','fixed1080','fixed720'):
-            raise ValueError('وضع الإرسال يجب أن يكون auto أو copy أو fixed1080 أو fixed720')
+        if mode not in ('auto','copy','fixed1080','fixed720','matchgop'):
+            raise ValueError('وضع الإرسال يجب أن يكون auto أو copy أو fixed1080 أو fixed720 أو matchgop')
         # Sticky transcode is for HEVC / layout flap only. Measured 2026-09-27 on cpu-basic:
         # two fixed720 publishers used 1.67–1.85 of 2.0 quota (peak 92.6%) with YouTube
         # health still good — no headroom for a third. If this candidate is H264, copy.
@@ -215,6 +215,24 @@ class Sender:
         cand=self.current_candidate or {}
         blob=(str(cand.get('codec') or '')+' '+str(cand.get('label') or '')+' '+str(cand.get('brief') or '')).lower()
         return any(k in blob for k in ('h264','avc'))
+    def request_sticky(self, mode, user, reason):
+        """Per-broadcaster: stick LIGHT/matchgop and end this FFmpeg only — not the Space."""
+        mode=(mode or 'matchgop').strip().lower()
+        if mode not in ('matchgop','fixed720','fixed1080'): mode='matchgop'
+        if self.sticky_mode==mode and self.session:
+            return False
+        self.sticky_mode=mode
+        self.sticky_since=time.monotonic()
+        self._recovering_copy=False
+        self.log(user, '[HEALTH] %s — sticky %s (this publisher only)'%(reason[:160], mode))
+        sess=self.session
+        if isinstance(sess, dict):
+            sess['force_stop']=True
+        p=self.process
+        if p is not None and p.stdin:
+            try: p.stdin.close()
+            except (OSError, ValueError): pass
+        return True
     def note_format_change(self):
         self.flap.append(time.monotonic())
         if len(self.flap)>=int(os.getenv('YOUTUBE_FLAP_LIMIT','4')):
@@ -254,8 +272,8 @@ class Sender:
         label=str(cand.get('label') or cand.get('brief') or '')
         if any(k in str(declared).lower() for k in ('h264','avc')) or any(k in label.lower() for k in ('h264','avc')):
             return None
-        mode=os.getenv('YOUTUBE_CODEC_FALLBACK_MODE','fixed720').strip().lower()
-        if mode not in ('fixed1080','fixed720'):mode='fixed720'
+        mode=os.getenv('YOUTUBE_CODEC_FALLBACK_MODE','matchgop').strip().lower()
+        if mode not in ('fixed1080','fixed720','matchgop'):mode='matchgop'
         self.sticky_mode=mode
         self.sticky_since=time.monotonic()
         self._recovering_copy=False
@@ -354,14 +372,21 @@ class Sender:
         if mode=='copy':
             video=['-c:v','copy']
         else:
-            width,height,bitrate=(1080,1920,'6000k') if mode=='fixed1080' else (720,1280,'4000k')
-            # VIDEO_BITRATE was documented in the README but never read anywhere; it now caps the
-            # transcode path (copy mode never re-encodes, so it has no bitrate to set).
-            bitrate=os.getenv('VIDEO_BITRATE','').strip() or bitrate
-            bufsize=str(int(int(bitrate[:-1])*1.5))+'k'
-            # A constant canvas is the only thing that guarantees YouTube always receives
-            # frames whose real size matches the signalled one, whatever the phone does.
-            video=['-vf',self.canvas(width,height),'-c:v','libx264','-preset',os.getenv('YOUTUBE_X264_PRESET','veryfast'),
+            if mode=='matchgop':
+                # Same-size closed GOP ~2s: YouTube buffers on open/8s copy (gopSizeLong / noData).
+                # Do NOT squash to 720 unless flap/HEVC policy asked for a constant canvas.
+                w=int((candidate or {}).get('width') or 0); h=int((candidate or {}).get('height') or 0)
+                if w>=16 and h>=16:
+                    vf='scale=%d:%d:flags=lanczos,setsar=1,format=yuv420p'%(w-w%2, h-h%2)
+                else:
+                    vf='scale=trunc(iw/2)*2:trunc(ih/2)*2,setsar=1,format=yuv420p'
+                bitrate=os.getenv('VIDEO_BITRATE','').strip() or '4500k'
+            else:
+                width,height,bitrate=(1080,1920,'6000k') if mode=='fixed1080' else (720,1280,'4000k')
+                vf=self.canvas(width,height)
+                bitrate=os.getenv('VIDEO_BITRATE','').strip() or bitrate
+            bufsize=str(int(int(str(bitrate).rstrip('kK'))*1.5))+'k'
+            video=['-vf',vf,'-c:v','libx264','-preset',os.getenv('YOUTUBE_X264_PRESET','veryfast'),
                    '-tune','zerolatency','-profile:v','high','-crf',os.getenv('YOUTUBE_CRF','22'),
                    # -b:v is what makes VIDEO_BITRATE real: -crf alone lets x264 roam and
                    # -maxrate only clamps the peaks, so a "4000k" promise to YouTube was not kept.

youtube_manager.py

@@ -325,8 +325,8 @@ class ManagedYouTube:
         with self.operations:
             d=self.journal.read()
             clean={k:str(values.get(k,'')).strip() for k in ('name','privacy','title','description','send_mode')}
-            if clean['send_mode'] and clean['send_mode'] not in ('auto','copy','fixed1080','fixed720'):
-                raise ValueError('وضع الإرسال يجب أن يكون auto أو copy أو fixed1080 أو fixed720')
+            if clean['send_mode'] and clean['send_mode'] not in ('auto','copy','fixed1080','fixed720','matchgop'):
+                raise ValueError('وضع الإرسال يجب أن يكون auto أو copy أو fixed1080 أو fixed720 أو matchgop')
             if clean['privacy'] not in ('public','unlisted','private'):raise ValueError('خصوصية غير صالحة')
             if 'send_mode' in values:
                 # The ingestion mode is safe to change mid-broadcast: it only decides what the
@@ -1646,7 +1646,7 @@ class ManagedYouTube:
         (videoResolutionUnsupported / videoCodec) and why playback stalls (gopSizeLong /
         openGop). Surfacing it replaces guesswork with ground truth. Polled on a slower
         cadence than the life-cycle check so it stays inside the quota budget."""
-        interval=max(60,int(os.getenv('YOUTUBE_HEALTH_INTERVAL','180')))
+        interval=max(45,int(os.getenv('YOUTUBE_HEALTH_INTERVAL','60')))
         if time.time()-float(ev.get('last_health') or 0)<interval:return
         stream_id=(self.journal.read()['streams'].get(user) or {}).get('id')
         if not stream_id:return
@@ -1661,9 +1661,23 @@ class ManagedYouTube:
                 issues.append('%s [%s] %s'%(i.get('type',''),sev,i.get('reason','')))
         text=' | '.join(issues)
         prev=ev.get('last_issues')
-        self.event_update(key,youtube_health=health.get('status',''),youtube_issues=text,last_issues=text)
+        status=str(health.get('status') or '')
+        self.event_update(key,youtube_health=status,youtube_issues=text,last_issues=text)
         if text and text!=prev:
             self.log(user,'يوتيوب يشخّص البث: '+text)
+        # Copy that YouTube cannot play (noData / open GOP / long GOP) → same-size closed GOP.
+        # Per-sender only; does not restart the Space or other publishers.
+        blob=(text+' '+status).lower()
+        gop_bad=any(k in blob for k in ('gopsizelong','gopsizeover','opengop'))
+        nodata=status.lower()=='nodata'
+        entry=self.senders.get(key)
+        sender=entry['sender'] if entry and entry.get('thread') and entry['thread'].is_alive() else None
+        if sender and (gop_bad or nodata):
+            snap=sender.snapshot() or {}
+            out=float(snap.get('output_seconds') or 0)
+            mode=(snap.get('send_mode') or sender.send_mode() or '')
+            if out>=20 and mode in ('','auto','copy') and not sender.sticky_mode:
+                sender.request_sticky('matchgop', user, 'YouTube %s (out=%.0fs copy not ingesting for viewers)'%(status or text[:40], out))
     def run_manager(self):
         checked=False
         last_tick=0.0