demuxe 0.3.0-beta.3

package/web/resource-loader.js

@@ -0,0 +1,173 @@
+import {validateVODManifest} from './vod-manifest.js';
+import {prepareDASH,selectHLS} from './streaming-manifest.js';
+import {subtitleSegments,mergeWebVTT} from './segmented-subtitles.js';
+// Bounded resource transport. FFmpeg, not this loader, interprets media timelines.
+const MiB=1024*1024;
+const abort=()=>new DOMException('Resource request cancelled','AbortError');
+export class ResourceLoader {
+  constructor(options,refresh){
+    this.options={credentials:'omit',...options};this.refresh=refresh;
+    this.allow=new Set(options.allowedOrigins??[new URL(options.url).origin]);
+    this.virtual=new Map();this.subtitlePlaylists=new Set();this.subtitleMedia=new Set();
+    this.handles=new Map();this.nextId=1;this.epoch=0;this.closed=false;this.busy=false;
+    this.stats={opens:0,requests:0,retries:0,aborts:0,handles:0,retainedBytes:0,peakRetainedBytes:0,fetchedBytes:0};
+    this.resolve(options.url);
+  }
+  resolve(value,base=this.options.url){
+    const u=new URL(value,base);
+    if(u.href.length>4095||!['http:','https:'].includes(u.protocol)||u.username||u.password||!this.allow.has(u.origin))throw Error('Resource URL is not allowed');
+    u.hash='';return u.href;
+  }
+  storeVirtual(additions){
+    const next=new Map([...this.virtual,...additions]);
+    if(next.size>1024||[...next.values()].reduce((n,b)=>n+b.byteLength,0)>4*MiB)throw Error('Virtual resource budget exceeded');
+    this.virtual=next;
+  }
+  beginEpoch(){this.epoch++;this.controller?.abort();this.retryWake?.();this.stats.aborts++;}
+  closeHandle(id){const item=this.handles.get(id);if(!item)return;this.stats.retainedBytes-=item.bytes.byteLength;this.handles.delete(id);this.stats.handles=this.handles.size;}
+  close(){this.closed=true;this.beginEpoch();for(const id of this.handles.keys())this.closeHandle(id);this.subtitlePlaylists.clear();this.subtitleMedia.clear();this.virtual.clear();}
+  read(id,offset,capacity){
+    if(this.closed)throw Error('Resource loader closed');
+    const item=this.handles.get(id);
+    if(!item||typeof offset!=='bigint'||offset<item.start||!Number.isInteger(capacity)||capacity<1||capacity>262144)throw Error('Invalid resource read');
+    const at=offset-item.start;if(at>=BigInt(item.bytes.length))return new Uint8Array();
+    return item.bytes.subarray(Number(at),Number(at)+capacity);
+  }
+  async open(value,{start,end,manifest=false,base}={}){
+    if(this.closed)throw Error('Resource loader closed');
+    if(this.busy)throw Error('Concurrent resource opens are not allowed');
+    if(this.handles.size>=16||(!this.options.streaming?.live&&this.stats.opens>=10000))throw Error('Resource count limit exceeded');
+    if(start!==undefined&&(typeof start!=='bigint'||start<0n||typeof end!=='bigint'||end<=start))throw Error('Invalid resource range');
+    if(start===undefined&&end!==undefined)throw Error('Invalid resource range');
+    const virtual=this.virtual.get(this.resolve(value,base));
+    if(virtual){
+      const total=BigInt(virtual.byteLength),offset=start??0n;
+      if(offset>=total||(end!==undefined&&end>total))throw Error('Invalid virtual resource range');
+      const bytes=start===undefined?virtual:virtual.subarray(Number(start),Number(end));
+      if(this.stats.retainedBytes+bytes.byteLength>16*MiB)throw Error('Resource memory budget exceeded');
+      const id=this.nextId++,url=this.resolve(value,base);this.handles.set(id,{id,url,bytes,start:offset,total});
+      this.stats.opens++;this.stats.retainedBytes+=bytes.byteLength;this.stats.handles=this.handles.size;this.stats.peakRetainedBytes=Math.max(this.stats.peakRetainedBytes,this.stats.retainedBytes);
+      return {id,url,size:String(total),start:String(offset),length:bytes.byteLength};
+    }
+    manifest=manifest||/\.(m3u8?|mpd)$/i.test(new URL(this.resolve(value,base)).pathname);
+    const isSubtitlePlaylist=this.subtitlePlaylists.has(this.resolve(value,base));
+    const isSubtitleMedia=this.subtitleMedia.has(this.resolve(value,base));
+    const limit=manifest||isSubtitleMedia?MiB:8*MiB;
+    if(start!==undefined&&end-start>BigInt(limit))throw Error('Resource size limit exceeded');
+    let url=this.resolve(value,base);manifest=manifest||/\.(m3u8?|mpd)$/i.test(new URL(url).pathname);const epoch=this.epoch;this.busy=true;this.stats.opens++;
+    const controller=this.controller=new AbortController();
+    const timeout=setTimeout(()=>controller.abort(),15000);
+    let refreshed=false;
+    try{
+      for(let attempt=0;attempt<4;attempt++){
+        if(this.closed||epoch!==this.epoch||controller.signal.aborted)throw abort();
+        let response;
+        try{
+          const headers=new Headers(this.options.headers);
+          // Transport owns range semantics, never inherit an unrelated caller range.
+          headers.delete('Range');headers.delete('If-Range');
+          if(start!==undefined)headers.set('Range',`bytes=${start}-${end-1n}`);
+          this.stats.requests++;
+          response=await fetch(url,{headers,credentials:this.options.credentials,redirect:'error',cache:'no-store',signal:controller.signal});
+          if(response.status===401&&this.refresh&&!refreshed){
+            await response.body?.cancel();refreshed=true;
+            const update=await new Promise((resolve,reject)=>{
+              const cancel=()=>reject(abort());controller.signal.addEventListener('abort',cancel,{once:true});
+              Promise.resolve().then(()=>this.refresh({url})).then(resolve,reject).finally(()=>controller.signal.removeEventListener('abort',cancel));
+            });
+            if(this.closed||epoch!==this.epoch||controller.signal.aborted)throw abort();
+            if(update?.url)url=this.resolve(update.url);
+            if(update?.headers)this.options.headers={...this.options.headers,...update.headers};
+            continue;
+          }
+          if([408,429,500,502,503,504].includes(response.status)){
+            await response.body?.cancel();throw Object.assign(Error(`Retryable resource HTTP ${response.status}`),{retryable:true});
+          }
+          if(response.status!==(start===undefined?200:206))throw Error(`Unexpected resource HTTP ${response.status}`);
+          const encoding=response.headers.get('Content-Encoding');
+          if(encoding&&encoding!=='identity')throw Error('Encoded resource bodies are unsupported');
+          let total,expected;
+          if(start!==undefined){
+            const match=/^bytes (\d+)-(\d+)\/(\d+)$/.exec(response.headers.get('Content-Range')??'');
+            if(!match||BigInt(match[1])!==start||BigInt(match[2])+1n!==end||BigInt(match[3])<end)throw Error('Invalid resource Content-Range');
+            total=BigInt(match[3]);expected=Number(end-start);
+          }
+          const length=response.headers.get('Content-Length');
+          if(length!==null){
+            if(!/^\d+$/.test(length)||BigInt(length)>BigInt(limit))throw Error('Resource size limit exceeded');
+            if(expected!==undefined&&Number(length)!==expected)throw Error('Resource length mismatch');
+            expected=Number(length);
+          }
+          if(!response.body)throw Error('Missing resource body');
+          const chunks=[];let count=0;
+          const body=response.body.getReader();
+          try{
+            for(;;){
+              const {value,done}=await body.read();if(done)break;
+              count+=value.byteLength;this.stats.fetchedBytes+=value.byteLength;
+              if(count>limit||(expected!==undefined&&count>expected))throw Error('Resource size limit exceeded');
+              chunks.push(value);
+            }
+          }finally{await body.cancel().catch(()=>{});}
+          if(expected!==undefined&&count!==expected)throw Object.assign(Error('Truncated resource body'),{retryable:true});
+          if(!count)throw Error('Empty resource body');
+          if(this.closed||epoch!==this.epoch||controller.signal.aborted)throw abort();
+          if(this.stats.retainedBytes+count>16*MiB)throw Error('Resource memory budget exceeded');
+          let bytes=new Uint8Array(count);let at=0;for(const chunk of chunks){bytes.set(chunk,at);at+=chunk.length;}
+          const prefix=new TextDecoder().decode(bytes.subarray(0,512)).trimStart();
+          const looksManifest=prefix.startsWith('#EXTM3U')||/^<\?xml\b|^<MPD\b/.test(prefix);
+          if(manifest||looksManifest){
+            if(count>MiB)throw Error('Manifest size limit exceeded');
+            const format=prefix.startsWith('#EXTM3U')?'hls':'dash';
+            if(format==='dash'){
+              const prepared=prepareDASH(new TextDecoder().decode(bytes),url,this.options.streaming);
+              bytes=prepared.bytes;if(prepared.url)url=prepared.url;
+              this.storeVirtual(prepared.resources);
+            }else bytes=new TextEncoder().encode(selectHLS(new TextDecoder().decode(bytes),this.options.streaming));
+            count=bytes.byteLength;if(count>MiB||this.stats.retainedBytes+count>16*MiB)throw Error('Manifest memory budget exceeded');
+            const preparedFormat=new TextDecoder().decode(bytes.subarray(0,7))==='#EXTM3U'?'hls':'dash';
+            const policy=validateVODManifest(bytes,preparedFormat,this.options.streaming);
+            if(policy){
+              const additions=policy.subtitlePlaylists.map(uri=>this.resolve(uri,url));
+              if(new Set([...this.subtitlePlaylists,...additions]).size>16)throw Error('HLS subtitle track limit exceeded');
+              for(const uri of additions)this.subtitlePlaylists.add(uri);
+              if(isSubtitlePlaylist){
+                const parsed=subtitleSegments(new TextDecoder().decode(bytes),url);
+                const parts=[];let totalBytes=0;
+                const nested=new ResourceLoader({...this.options,format:'file'},this.refresh);
+                const cancelled=()=>nested.close();controller.signal.addEventListener('abort',cancelled,{once:true});
+                try{
+                  for(const segment of parsed.segments){
+                    const info=await nested.open(this.resolve(segment.url));const body=nested.handles.get(info.id).bytes;
+                    totalBytes+=body.byteLength;if(totalBytes>MiB)throw Error('Subtitle window exceeds 1 MiB');
+                    parts.push({...segment,text:new TextDecoder('utf-8',{fatal:true}).decode(body)});nested.closeHandle(info.id);
+                  }
+                }finally{controller.signal.removeEventListener('abort',cancelled);nested.close();this.stats.requests+=nested.stats.requests;this.stats.fetchedBytes+=nested.stats.fetchedBytes;}
+                const subtitle=mergeWebVTT(parts),virtualURL=new URL(url);virtualURL.searchParams.set('__demuxe_subtitles','1');
+                const uri=virtualURL.href;this.storeVirtual([[uri,new TextEncoder().encode(subtitle)]]);
+                bytes=new TextEncoder().encode(`#EXTM3U\n#EXT-X-TARGETDURATION:${Math.ceil(parsed.duration)}\n#EXTINF:${parsed.duration},\n${uri}\n#EXT-X-ENDLIST\n`);count=bytes.byteLength;
+              }
+            }
+          }
+          if(isSubtitleMedia){
+            const subtitle=new TextDecoder('utf-8',{fatal:true}).decode(bytes);
+            if(!subtitle.startsWith('WEBVTT')||subtitle.includes('X-TIMESTAMP-MAP'))throw Error('Only full-timeline WebVTT without timestamp maps is supported');
+          }
+          if(this.closed||epoch!==this.epoch||controller.signal.aborted)throw abort();
+          const id=this.nextId++;const item={id,url,bytes,start:start??0n,total:total??BigInt(count)};
+          this.handles.set(id,item);this.stats.handles=this.handles.size;this.stats.retainedBytes+=count;
+          this.stats.peakRetainedBytes=Math.max(this.stats.peakRetainedBytes,this.stats.retainedBytes);
+          return {id,url,size:String(item.total),start:String(item.start),length:count};
+        }catch(error){
+          // Abort response consumption even when validation fails before getReader().
+          await response?.body?.cancel().catch(()=>{});
+          if(this.closed||epoch!==this.epoch||controller.signal.aborted)throw abort();
+          if(attempt===3||!(error.retryable||error instanceof TypeError))throw error;
+          this.stats.retries++;
+          await new Promise(resolve=>{const timer=setTimeout(done,100*(attempt+1));const self=this;function done(){clearTimeout(timer);self.retryWake=null;resolve();}this.retryWake=done;});
+        }
+      }
+      throw Error('Resource request attempts exhausted');
+    }finally{clearTimeout(timeout);this.busy=false;if(this.controller===controller)this.controller=null;}
+  }
+}

package/web/retained-decoder-worker.js

@@ -0,0 +1,200 @@
+import {videoCodecConfig,vp9PacketConfig} from './video-codec-config.js';
+let pendingConfiguration;
+let packetPrefix,needsKey=true;
+let allowSharedPackets=true;
+const noCopy=true;
+// Dedicated service: native decoder pthread waits never block this event loop.
+let memory,pointer,header,view,decoder,configuration,queue=[],generation=0,busy=false;
+let draining=false,flushed=false,failure=null,submitted=0,consumed=0,outputWaitSince=null;
+let faultAfter=0,disabled=false,copiesInFlight=0;
+const copying=new Set(),closed=new WeakSet();
+const packetOffset=80,frameOffset=80+8*1024*1024;
+// errno values are from the pinned Emscripten WASI ABI.
+const AGAIN=-6,EOF=-541478725,IO=-29;
+const stats={packetBytes:0,ownedPacketBytes:0,sharedPacketInputs:0,sharedPacketFallbacks:0,submitted:0,frames:0,receivedFrames:0,closedFrames:0,peakOutstanding:0,peakFrames:0,resets:0,errors:0,copyMs:0};
+const color={bt709:1,bt470bg:5,smpte170m:6,bt2020:9,'bt2020-ncl':9,smpte2084:16,'iec61966-2-1':13};
+function closeFrame(frame){if(closed.has(frame))return;closed.add(frame);frame.close();stats.closedFrames++;}
+function clear(){generation++;if(decoder&&decoder.state!=='closed')decoder.close();decoder=null;for(const frame of queue)closeFrame(frame);for(const frame of copying)closeFrame(frame);queue=[];draining=flushed=false;submitted=consumed=0;outputWaitSince=null;failure=null;}
+async function checkConfiguration(valid){
+ // Keep only descriptive fields: initialization bytes can be large and are not
+ // useful in a UI error. Retain the exact codec string passed to WebCodecs.
+ const describe=config=>({codec:config.codec,codedWidth:config.codedWidth,codedHeight:config.codedHeight,descriptionBytes:config.description?.byteLength??0,hardwareAcceleration:config.hardwareAcceleration,optimizeForLatency:config.optimizeForLatency});
+ const requested=describe(configuration);
+ stats.supportCheck={requested,source:{...stats.input}};
+ let support;
+ try{support=await VideoDecoder.isConfigSupported(configuration);}
+ catch(error){
+  if(!valid())return false;
+  stats.supportCheck.error=String(error);
+  throw Error(`Browser decoder configuration check failed: ${String(error)}\nRequested configuration: ${JSON.stringify(requested)}`);
+ }
+ if(!valid())return false;
+ stats.supportCheck.supported=support.supported;
+ if(support.config)stats.supportCheck.recognized=describe(support.config);
+ if(!support.supported){
+  const family=({1:'H.264 / AVC',2:'H.265 / HEVC',3:'VP8',4:'VP9',5:'AV1'})[stats.input.kind]??'video';
+  const depth=stats.input.depth>0?`${stats.input.depth}-bit`:'not reported by the source';
+  const profile=stats.input.profile>=0?stats.input.profile:'unknown';
+  const level=stats.input.level>=0?stats.input.level:'unknown';
+  throw Error(`Unsupported browser configuration (${family}).\nCodec string: ${requested.codec}\nResolution: ${requested.codedWidth} × ${requested.codedHeight}\nSource bit depth: ${depth}\nSource profile / level IDs: ${profile} / ${level}\nDecoder initialization data: ${requested.descriptionBytes} bytes\nHardware acceleration policy: ${requested.hardwareAcceleration}\nWebCodecs reported supported=false without a specific rejection reason. These details do not establish whether browser support or demuxe's configuration mapping caused the rejection.`);
+ }
+ return true;
+}
+function configure(){
+ if(copiesInFlight)throw Error('Previous copy still pending; use software');
+ const current=generation;
+ decoder=new VideoDecoder({error:error=>{if(current===generation){failure=String(error);stats.errors++;postMessage({wakeup:true});}},output:frame=>{
+  stats.receivedFrames++;
+  if(current!==generation){closeFrame(frame);return;}
+  // Decode completion may release a reorder burst after decodeQueueSize falls.
+  // Stop submitting at eight queued frames; retain bounded burst headroom.
+  if(queue.length>=32){closeFrame(frame);failure='Frame queue limit';stats.errors++;return;}
+  queue.push(frame);postMessage({wakeup:true});stats.peakFrames=Math.max(stats.peakFrames,queue.length);outputWaitSince=null;
+ }});
+ decoder.addEventListener('dequeue',()=>{if(current===generation)postMessage({wakeup:true});});
+ needsKey=true;decoder.configure(configuration);outputWaitSince=null;
+}
+self.onmessage=({data})=>{
+ if(data.type==='cancel'){
+  disabled=true;clear();
+  if(header){const ticket=Atomics.load(header,0);if((ticket&3)===1){header[3]=IO;Atomics.store(header,0,ticket+1);Atomics.notify(header,0);}}
+  postMessage({stats:{...stats,outstanding:0,queued:0,active:false}});
+  return;
+ }
+ memory=data.memory;pointer=data.pointer;header=new Int32Array(memory,pointer,16);view=new DataView(memory,pointer);
+ faultAfter=data.faultAfter??0;disabled=!!data.disabled;
+ if(typeof Atomics.waitAsync==='function')void (async()=>{
+  const channel=new MessageChannel();
+  const yieldTask=()=>new Promise(resolve=>{channel.port1.onmessage=resolve;channel.port2.postMessage(0);});
+  for(;;){
+   void pump();
+   const state=Atomics.load(header,0);
+   // The native thread can publish its next request before this load. Do not
+   // wait for another notification when that request is already ready.
+   if((state&3)===1&&!busy){await yieldTask();continue;}
+   await Atomics.waitAsync(header,0,state,1000).value;
+   await yieldTask();
+  }
+ })();
+ else setInterval(pump,1);
+ postMessage({ready:true});
+};
+async function pump(){
+ if(!header)return;
+ const ticket=Atomics.load(header,0);if((ticket&3)!==1)return;
+ if(busy){
+  if(header[2]===5||header[2]===6){clear();header[3]=header[2]===5?0:IO;Atomics.store(header,0,ticket+1);Atomics.notify(header,0);}
+  return;
+ }
+ busy=true;let result=0;
+ const operation=header[2],current=generation;
+ const valid=()=>Atomics.load(header,0)===ticket;
+ try{
+  if(operation===1){
+   clear();if(disabled||typeof VideoDecoder==='undefined')throw Error('VideoDecoder unavailable');
+   const size=header[4],w=header[5],h=header[6];
+   if(size<0||size>65536)throw Error('Invalid decoder configuration size');
+   const description=new Uint8Array(memory,pointer+packetOffset,size).slice();
+   stats.input={kind:header[13]||1,width:w,height:h,profile:header[14],level:header[15],depth:header[8],descriptionBytes:size};
+   pendingConfiguration=null;
+   if(stats.input.kind===4&&(stats.input.profile<0||!stats.input.depth)){
+    pendingConfiguration={...stats.input,description};configuration=null;return;
+   }
+   const adapted=videoCodecConfig({...stats.input,description,depth:header[8]||8});
+   configuration=adapted.configuration;packetPrefix=adapted.prefix;stats.codec=configuration.codec;
+   if(!await checkConfiguration(valid)||!valid())return;
+   configure();
+  }else if(operation===5){clear();}
+  else if(operation===6){clear();if(configuration)configure();stats.resets++;}
+  else{
+   if(failure)throw Error(failure);
+   if(!decoder&&pendingConfiguration){
+    if(operation===4){result=AGAIN;return;}
+    if(operation!==2)throw Error('VP9 source ended before initialization');
+    const bytes=new Uint8Array(memory,pointer+packetOffset,header[4]);
+    const packetConfig=vp9PacketConfig(bytes);
+    stats.input={...stats.input,...packetConfig};
+    const adapted=videoCodecConfig({...pendingConfiguration,...packetConfig});
+    configuration=adapted.configuration;packetPrefix=adapted.prefix;stats.codec=configuration.codec;
+    if(!await checkConfiguration(valid)||!valid())return;
+    configure();pendingConfiguration=null;
+   }
+   if(!decoder)throw Error('Decoder is closed');
+   if(operation===2){
+    if(decoder.decodeQueueSize+queue.length>=8)result=AGAIN;
+    else{
+     const size=header[4];if(size<1||size>8*1024*1024)throw Error('Packet size limit');
+     let bytes=new Uint8Array(memory,pointer+packetOffset,size);stats.packetBytes+=size;
+     if(!allowSharedPackets){bytes=bytes.slice();stats.ownedPacketBytes+=bytes.length;}
+     if(needsKey&&header[7]&&packetPrefix?.length){const joined=new Uint8Array(packetPrefix.length+bytes.length);joined.set(packetPrefix);joined.set(bytes,packetPrefix.length);bytes=joined;stats.ownedPacketBytes+=joined.length;}
+     const timestamp=view.getFloat64(64,true),duration=view.getFloat64(72,true);
+     if(!Number.isSafeInteger(timestamp)||!Number.isSafeInteger(duration)||duration<0)throw Error(`Invalid timestamps: ${timestamp}, duration ${duration}`);
+     const init={type:header[7]?'key':'delta',timestamp,...(duration?{duration}:{}),data:bytes};
+     let chunk;
+     // EncodedVideoChunk synchronously copies input when no transfer list is
+     // supplied. The producer still owns this mailbox until pump acknowledges
+     // it below. Never transfer or detach the shared Wasm heap.
+     try{chunk=new EncodedVideoChunk(init);if(bytes.buffer===memory)stats.sharedPacketInputs++;}
+     catch(error){
+      if(error?.name!=='TypeError'||bytes.buffer!==memory)throw error;
+      allowSharedPackets=false;stats.sharedPacketFallbacks++;
+      bytes=bytes.slice();stats.ownedPacketBytes+=bytes.length;chunk=new EncodedVideoChunk({...init,data:bytes});
+     }
+     decoder.decode(chunk);
+     needsKey=false;submitted++;stats.submitted++;stats.peakOutstanding=Math.max(stats.peakOutstanding,decoder.decodeQueueSize);
+    }
+   }else if(operation===3){
+    draining=true;const epoch=generation;
+    decoder.flush().then(()=>{if(epoch===generation){flushed=true;postMessage({wakeup:true});}},error=>{if(epoch===generation){failure=String(error);postMessage({wakeup:true});}});
+   }else if(operation===4){
+    if(faultAfter&&stats.frames>=faultAfter)throw Error('Injected decoder failure');
+    if(queue.length){
+     const frame=queue.shift();
+     try{
+      const actualWidth=frame.visibleRect.width,actualHeight=frame.visibleRect.height;
+      stats.actualWidth=actualWidth;stats.actualHeight=actualHeight;stats.pixelFormat=frame.format;
+      const w=noCopy?2:actualWidth,h=noCopy?2:actualHeight;
+      if((!noCopy&&!['I420','NV12'].includes(frame.format))||actualWidth<1||actualHeight<1||actualWidth>(noCopy?8192:1920)||actualHeight>(noCopy?8192:1080)||actualWidth*actualHeight>33554432||w<1||h<1||w>1920||h>1080||(w&1)||(h&1))throw Error('Unsupported decoded frame');
+      const nv12=frame.format==='NV12';
+      const layout=nv12?[{offset:0,stride:w},{offset:w*h,stride:w}]:[{offset:0,stride:w},{offset:w*h,stride:w/2},{offset:w*h*5/4,stride:w/2}];
+      if(!noCopy){
+      const bytes=new Uint8Array(w*h*3/2),started=performance.now();
+      copying.add(frame);copiesInFlight++;
+      try{await frame.copyTo(bytes,{layout,rect:frame.visibleRect});}
+      finally{copiesInFlight--;copying.delete(frame);}
+      stats.copyMs+=performance.now()-started;
+      if(!valid()||current!==generation)return;
+      new Uint8Array(memory,pointer+frameOffset,bytes.length).set(bytes);
+      stats.pixelCopies=(stats.pixelCopies??0)+1;
+      }else{
+       new Uint8Array(memory,pointer+frameOffset,6).set([16,16,16,16,128,128]);
+       stats.placeholderFrames=(stats.placeholderFrames??0)+1;
+      }
+      header[5]=w;header[6]=h;header[8]=+nv12;
+      header[9]=color[frame.colorSpace.primaries]??2;header[10]=color[frame.colorSpace.transfer]??2;
+      header[11]=color[frame.colorSpace.matrix]??2;header[12]=+!!frame.colorSpace.fullRange;
+      view.setFloat64(64,frame.timestamp,true);view.setFloat64(72,frame.duration??0,true);
+      postMessage({retainedFrame:frame,pts:frame.timestamp,generation},[frame]);
+      stats.transferredFrames=(stats.transferredFrames??0)+1;
+      consumed++;stats.frames++;outputWaitSince=null;result=1;
+     }finally{closeFrame(frame);}
+    }else if(draining)result=flushed?EOF:0;
+    else result=decoder.decodeQueueSize+queue.length>=8?0:AGAIN;
+    // Measure an actual blocked receive, not wall time since the last frame:
+    // paused/idle periods and packet reordering do not spend the output budget.
+    const waiting=!queue.length&&!flushed&&(draining||decoder.decodeQueueSize>=8)&&submitted>consumed;
+    if(!waiting)outputWaitSince=null;
+    else if(outputWaitSince===null)outputWaitSince=performance.now();
+    else if(performance.now()-outputWaitSince>3000){
+     stats.watchdog={waitingMs:Math.round(performance.now()-outputWaitSince),decodeQueueSize:decoder.decodeQueueSize,queuedFrames:queue.length,submitted,consumed,draining,flushed,codec:configuration?.codec};
+     throw Error(`Decoder output watchdog: ${JSON.stringify(stats.watchdog)}`);
+    }
+   }else throw Error('Unknown decoder operation');
+  }
+ }catch(error){failure=String(error);stats.errors++;result=IO;postMessage({error:failure});}
+ finally{
+  if(valid()){header[3]=result;Atomics.store(header,0,ticket+1);Atomics.notify(header,0);}
+  if(operation!==4||stats.frames%30===0)postMessage({stats:{...stats,outstanding:decoder?.decodeQueueSize??0,queued:queue.length,active:!!decoder}});
+  busy=false;
+ }
+}

package/web/retained-video.js

@@ -0,0 +1,15 @@
+// Canvas video geometry is independent of the bounded diagnostic sample history.
+export function drawRetainedVideo(context, frame, canvas, track) {
+  const par = Number(track?.['demux-par']);
+  const width = Number.isFinite(par) && par > 0 ? frame.visibleRect.width * par : frame.displayWidth;
+  const height = Number.isFinite(par) && par > 0 ? frame.visibleRect.height : frame.displayHeight;
+  const rotation = ((Number(track?.['demux-rotation']) || 0) % 360 + 360) % 360;
+  const radians = rotation * Math.PI / 180;
+  const sin = Math.abs(Math.sin(radians)), cos = Math.abs(Math.cos(radians));
+  const scale = Math.min(canvas.width / (width * cos + height * sin), canvas.height / (width * sin + height * cos));
+  context.save();
+  context.fillStyle = '#000';context.fillRect(0, 0, canvas.width, canvas.height);
+  context.translate(canvas.width / 2, canvas.height / 2);context.rotate(radians);
+  context.drawImage(frame, -width * scale / 2, -height * scale / 2, width * scale, height * scale);
+  context.restore();
+}

package/web/segmented-subtitles.js

@@ -0,0 +1,37 @@
+// Convert a bounded HLS WebVTT window to one indexed subtitle resource. Preserve
+// cue settings and payload; normalize MPEGTS/LOCAL maps and timestamp wrap.
+const timestamp=s=>{const p=s.split(':').map(Number);if(p.some(n=>!Number.isFinite(n))||p.length<2||p.length>3)throw Error('Invalid WebVTT timestamp');return p.reduce((n,v)=>n*60+v,0);};
+const clock=t=>{t=Math.max(0,Math.round(t*1000));const h=Math.floor(t/3600000),m=Math.floor(t/60000)%60,s=Math.floor(t/1000)%60;return `${String(h).padStart(2,'0')}:${String(m).padStart(2,'0')}:${String(s).padStart(2,'0')}.${String(t%1000).padStart(3,'0')}`;};
+export function subtitleSegments(text,base){
+ const segments=[];let duration,at=0,discontinuity=false;
+ for(const raw of text.split(/\r?\n/)){
+  const line=raw.trim();if(line.startsWith('#EXTINF:'))duration=Number(line.slice(8).split(',')[0]);
+  else if(line==='#EXT-X-DISCONTINUITY')discontinuity=true;
+  else if(line&&!line.startsWith('#')){if(!(duration>0)||segments.length>=10000)throw Error('Invalid subtitle segment duration');segments.push({url:new URL(line,base).href,start:at,duration,discontinuity});at+=duration;duration=undefined;discontinuity=false;}
+ }
+ return {segments,duration:at};
+}
+export function mergeWebVTT(parts){
+ let firstMap,previousMap,discontinuityOffset=0;const cues=[],seen=new Set(),styles=new Set();
+ for(const part of parts){
+  const text=part.text.replace(/^\uFEFF/,'').replaceAll('\r\n','\n');if(!text.startsWith('WEBVTT'))throw Error('Invalid HLS WebVTT');
+  const map=/X-TIMESTAMP-MAP\s*=([^\n]+)/.exec(text)?.[1];let shift=0;
+  if(map){
+   const local=/LOCAL:([^,\s]+)/.exec(map)?.[1],mpeg=/MPEGTS:(\d+)/.exec(map)?.[1];if(!local||!mpeg)throw Error('Invalid WebVTT timestamp map');
+   let offset=Number(mpeg)/90000-timestamp(local);const wrap=2**33/90000;
+   if(previousMap!==undefined)offset+=Math.round((previousMap-offset)/wrap)*wrap;
+   firstMap??=offset;if(part.discontinuity)discontinuityOffset=firstMap+part.start-offset;
+   shift=offset+discontinuityOffset;previousMap=offset;
+  }
+  for(const block of text.split(/\n\s*\n/).slice(1)){
+   if(/^(STYLE|REGION)(?:\n|$)/.test(block)){styles.add(block);continue;}
+   if(/^NOTE(?:\s|$)/.test(block)||!block.trim())continue;
+   const lines=block.split('\n'),i=lines.findIndex(l=>l.includes('-->'));if(i<0)continue;
+   const m=/^(\S+)\s+-->\s+(\S+)(.*)$/.exec(lines[i]);if(!m)throw Error('Invalid WebVTT cue');
+   const start=timestamp(m[1])+shift,end=timestamp(m[2])+shift;if(end<=start)throw Error('Invalid WebVTT cue interval');
+   lines[i]=`${clock(start)} --> ${clock(end)}${m[3]}`;const cue=lines.join('\n');if(!seen.has(cue)){seen.add(cue);cues.push({start,cue});}
+  }
+ }
+ const output='WEBVTT\n\n'+[...styles,...cues.sort((a,b)=>a.start-b.start).map(c=>c.cue)].join('\n\n')+'\n';
+ if(new TextEncoder().encode(output).byteLength>1024*1024)throw Error('Combined subtitles exceed 1 MiB');return output;
+}