demuxe 0.3.0-beta.3

package/web/software-full-engine-worker.js

@@ -0,0 +1,234 @@
+let audioChannels=2;
+let YUVPresenter,uploader,gpuPauseIntent;
+function installPresenter(canvas,prior){
+ uploader=new YUVPresenter(canvas);
+ if(prior)uploader.stats={...prior,liveTextures:4,contextRestores:(prior.contextRestores||0)+1};
+ uploader.onLost=()=>{gpuPauseIntent=paused;internalCommand(['set','pause','yes'],()=>{});post({type:'output',data:{kind:'gpu-context-lost'}});};
+ uploader.onRestore=()=>{if(closing)return;const old=uploader,stats={...old.stats};old.destroy(true);const intent=gpuPauseIntent;gpuPauseIntent=undefined;installPresenter(canvas,stats);internalCommand(['set','pause',intent?'yes':'no'],()=>{});force=true;schedulePump(0);post({type:'output',data:{kind:'gpu-context-restored'}});};
+}
+let decoderWorker,decoderStats;
+
+
+let engine, canvas, context, timer, audio, pcm, nativeAudio, epoch = -1, forwarded = 0;
+let renderMs=0,copyMs=0,maxRenderMs=0;
+let rendered = 0, sourceRendered = 0, ticks = 0, force = true, closing = false, presentedPosition=0, frameImage, measureOutput=false, wasWhite=false;
+let ioWorker,ioStats,ioReady,ioClose,ioSession=0,pendingTarget=null,restarted=false,position=0;
+let internalId=0x80000000,demuxFormat='',seekPrerollSeconds=0;
+const internalCommands=new Map();
+function internalCommand(args,done){const id=internalId++;internalCommands.set(id,done);submit(id,args);}
+const CAPACITY = 8192;
+let paused=true,busyUntil=0,pumpFailed=false,nextDiagnostics=0;
+function schedulePump(delay=5){
+ clearTimeout(timer);if(closing||pumpFailed||!engine)return;
+ timer=setTimeout(()=>{
+  schedulePump(paused&&pendingTarget===null&&performance.now()>=busyUntil?100:5);
+  tick();
+ },delay);
+}
+
+function releaseSeek(){if(pendingTarget!==null&&restarted&&Math.abs(position-pendingTarget)<0.15){pendingTarget=null;force=true;post({type:'seek-complete',position});}}
+async function closeIO(){if(!ioWorker)return;const old=ioWorker;engine._web_io_cancel();await new Promise(resolve=>{ioClose=resolve;old.postMessage({type:'close'});setTimeout(resolve,1500);});old.terminate();ioWorker=null;ioClose=null;engine.ccall('web_io_root',null,['number','string'],[0,'']);}
+async function openRemote(data){
+  sourceRendered=0;
+  await closeIO();
+  const pointer=engine._web_io_ptr();
+  ioWorker=new Worker(new URL('./io-worker.js',import.meta.url),{type:'module'});
+  const info=await new Promise((resolve,reject)=>{
+    const timeout=setTimeout(()=>reject(Error('Remote open timed out')),20000);
+    ioWorker.onmessage=({data:message})=>{
+      if(message.type==='ready'){clearTimeout(timeout);resolve(message.info);}
+      else if(message.type==='error'){clearTimeout(timeout);reject(Error(message.message));post({type:'error',id:data.id,message:message.message});}
+      else if(message.type==='stats')ioStats=message.stats;
+      else if(message.type==='refresh')post({type:'refresh',id:message.id,resource:message.resource});
+      else if(message.type==='closed')ioClose?.();
+    };
+    ioWorker.onerror=event=>{clearTimeout(timeout);reject(Error(event.message));};
+    ioWorker.postMessage({type:'init',memory:engine.HEAPU8.buffer,pointer,options:data.options??{},file:data.file,canRefresh:data.canRefresh});
+  });
+  if(closing)throw Error('Player closed');
+  engine._web_io_configure(++ioSession,BigInt(info.size));
+  engine.ccall('web_io_root',null,['number','string'],[info.resource??0,info.url??'']);
+  post({type:'source',info});submit(data.id,['loadfile','brange://source','replace']);
+}
+const post = message => self.postMessage(message);
+function pumpAudio() {
+  // Refresh views after every possible Wasm memory growth.
+  const h = engine.HEAPU32;
+  const at = nativeAudio >>> 2;
+  const nextEpoch = Atomics.load(h, at + 3);
+  if (nextEpoch & 1) return;
+  if (epoch !== nextEpoch) {
+    epoch = nextEpoch;
+    forwarded = 0;
+    Atomics.store(audio, 2, 0);
+    Atomics.store(audio, 0, 0);
+    Atomics.store(audio, 3, epoch);
+    return;
+  }
+  if (Atomics.load(audio, 4) !== epoch) return;
+  const consumed = Atomics.load(audio, 1) >>> 0;
+  Atomics.store(h, at + 7, 0);
+  Atomics.store(h, at + 1, consumed);
+  Atomics.store(h, at + 7, epoch);
+  const written = Atomics.load(h, at);
+  const count = (written - forwarded) >>> 0;
+  if (Atomics.load(h, at + 3) !== epoch) return;
+  if (count > CAPACITY) throw new Error('PCM capacity invariant violated');
+  const source = (nativeAudio + 32) >>> 2;
+  for (let i = 0; i < count; i++) {
+    const index = ((forwarded + i) % CAPACITY) * audioChannels;
+    for(let c=0;c<audioChannels;c++)pcm[index+c]=engine.HEAPF32[source+index+c];
+  }
+  // A reset during the copy discards this batch before publishing it.
+  if (Atomics.load(h, at + 3) !== epoch) return;
+  forwarded = written;
+  Atomics.store(audio, 0, written);
+  Atomics.store(audio, 2, pendingTarget===null?Atomics.load(h, at + 2):0);
+}
+function tick() {
+  if (closing) return;
+  try {
+    pumpAudio();
+    for (let i = 0; i < 64; i++) {
+      const ptr = engine._web_event();
+      if (!ptr) break;
+      const event = JSON.parse(engine.UTF8ToString(ptr));
+      engine._free(ptr);
+      if(event.event==='command-reply'&&internalCommands.has(event.id)){
+        const done=internalCommands.get(event.id);internalCommands.delete(event.id);
+        if(event.error)throw Error(`Playback configuration failed: ${event.error}`);
+        done(event.result);continue;
+      }
+      if(event.event==='property-change'&&event.name==='pause'){paused=!!event.data;busyUntil=performance.now()+300;}
+      if(event.event==='file-loaded'){
+        // Configure from mpv's detected format before resolving the host's open.
+        internalCommand(['expand-text','${file-format}'],format=>{
+          demuxFormat=String(format);seekPrerollSeconds=1;
+          internalCommand(['set','hr-seek-demuxer-offset',String(seekPrerollSeconds)],()=>post({type:'event',event}));
+        });continue;
+      }
+      // Let mpv discard obsolete demux packets after this bounded read completes.
+      // Interrupting stream_cb read_fn mid-packet returns a truncated packet to FFmpeg.
+      // Source replacement/destroy still cancel I/O through closeIO().
+      if(event.event==='property-change'&&event.name==='time-pos'){position=event.data;releaseSeek();}
+      if(event.event==='playback-restart'){restarted=true;releaseSeek();}
+      if(event.event==='log-message')post({type:'log',message:event.prefix+': '+event.text});
+      post({type:'event', event});
+    }
+    if(uploader?.lost)return;
+    const renderStart=performance.now();
+    const ptr = engine._web_render(canvas.width, canvas.height, +force);
+    const renderDuration=performance.now()-renderStart;
+    force = false;
+    if (ptr && pendingTarget===null) {
+      renderMs+=renderDuration;maxRenderMs=Math.max(maxRenderMs,renderDuration);const copyStart=performance.now();
+      if(!uploader){
+      if(!frameImage||frameImage.width!==canvas.width||frameImage.height!==canvas.height)frameImage=new ImageData(canvas.width,canvas.height);
+      const bytes=frameImage.data;bytes.set(engine.HEAPU8.subarray(ptr,ptr+bytes.length));
+      for (let i = 3; i < bytes.length; i += 4) bytes[i] = 255;
+      context.putImageData(frameImage, 0, 0);
+      if(measureOutput){const at=(8*canvas.width+8)*4;const white=bytes[at]>225&&bytes[at+1]>225&&bytes[at+2]>225;if(white&&!wasWhite)post({type:'output',data:{kind:'flash',wallTime:performance.timeOrigin+performance.now(),position}});wasWhite=white;}
+      }
+      copyMs+=performance.now()-copyStart;engine._web_presented();
+      rendered++;sourceRendered++;presentedPosition=position;
+    }
+    ticks++;
+    if(performance.now()>=nextDiagnostics||(ptr&&sourceRendered<=5)){nextDiagnostics=performance.now()+200;post({type:'diagnostics', data:{softwarePresenter:uploader?'experimental-yuv':'rgb',yuv:uploader?{...uploader.stats}:undefined,pumpTicks:ticks,rendered,renderMs,copyMs,maxRenderMs, heapBytes:engine.HEAPU8.byteLength, epoch, path:'wasm', decoder:decoderStats?.active?'webcodecs':'software',decoderStats, demuxFormat,seekPrerollSeconds,presentedPosition, ioPending:(Atomics.load(engine.HEAPU32,engine._web_io_ptr()>>>2)&7)===1, ioSerial:Atomics.load(engine.HEAPU32,(engine._web_io_ptr()>>>2)+1), interruptions:Atomics.load(engine.HEAPU32,(engine._web_io_ptr()>>>2)+14), io:ioStats, seeking:pendingTarget!==null, position, queuedFrames:(Atomics.load(audio,0)-Atomics.load(audio,1))>>>0}});}
+  } catch (error) {pumpFailed=true;clearInterval(timer);post({type:'error',message:String(error.stack || error)}); }
+}
+self.onmessage = async ({data}) => {
+  try {
+    if (data.type === 'init') {
+      if (data.disableBrowserCodecs) for (const name of ['VideoDecoder','AudioDecoder','VideoFrame']) Object.defineProperty(globalThis,name,{value:undefined, configurable:true});
+      measureOutput=!!data.measureOutput;
+      canvas = data.canvas;
+      if(data.softwarePresenter==='experimental-yuv'){({YUVPresenter}=await import('./yuv-presenter.js'));installPresenter(canvas);}else context=canvas.getContext('2d',{alpha:false});
+      audio = new Int32Array(data.audio, 0, 16);
+      pcm = new Float32Array(data.audio, 64);
+      if(data.decoder!=='software')throw Error('This build supports software decoding only');
+      const createEngine=(await import(uploader?'./engine-software-yuv/player.mjs':'./engine-software-full/player.mjs')).default;
+      engine = await createEngine({printErr:message=>post({type:'log',message}),print:message=>post({type:'log',message})});
+      if(uploader){engine.failOutput=message=>{pumpFailed=true;post({type:'error',message});};engine.drawYUV=d=>{try{uploader.draw(engine,d);}catch(e){engine.failOutput(String(e));}};engine.drawRGB=(...a)=>{try{uploader.drawRGB(engine,...a);}catch(e){engine.failOutput(String(e));}};}
+      if (closing) return;
+      engine.FS.mkdir('/fonts');
+      engine.FS.writeFile('/fonts/DejaVuSans.ttf', new Uint8Array(data.font));
+      for(const font of data.fonts??[])engine.FS.writeFile('/fonts/'+font.name,new Uint8Array(font.bytes));
+      const fontSize=engine.FS.stat('/fonts/DejaVuSans.ttf').size;
+      if(Number(fontSize) !== data.font.byteLength) throw new Error('Subtitle font write failed');
+      if(data.decoder==='webcodecs'){
+        decoderWorker=new Worker(new URL('./browser-decoder-worker.js',import.meta.url),{type:'module'});
+        await new Promise((resolve,reject)=>{
+          const deadline=setTimeout(()=>reject(Error('Decoder service initialization timed out')),5000);
+          decoderWorker.onmessage=({data:message})=>{
+            if(message.ready){clearTimeout(deadline);resolve();}
+            if(message.stats)decoderStats=message.stats;
+            if(message.wakeup&&!closing)engine._web_decoder_wakeup();
+            if(message.error)post({type:'log',message:message.error});
+          };
+          decoderWorker.onerror=error=>{clearTimeout(deadline);reject(Error(error.message));};
+          decoderWorker.postMessage({memory:engine.HEAPU8.buffer,pointer:engine._web_decoder_ptr(),disabled:data.disableBrowserCodecs,faultAfter:data.decoderFaultAfter});
+        });
+        engine._web_decoder_enable(1);
+      }
+      audioChannels=data.audioChannels??2;
+      if(engine._web_audio_configure(audioChannels)<0)throw Error("Invalid output channel count");
+      if(engine._web_configure(data.maxDecodePixels??8294400,data.maxAllocationBytes??134217728)<0)throw Error("Invalid decode resource limits");
+      const result = engine._web_create(data.sampleRate);
+      if (result < 0) throw new Error(`mpv initialization failed: ${result}`);
+      nativeAudio = engine._web_audio_ptr();
+      schedulePump();
+      post({type:'ready', browserCodecsAbsent:['VideoDecoder','AudioDecoder','VideoFrame'].every(name=>typeof globalThis[name]==='undefined')});
+    } else if(data.type==='experimental-context-loss'&&uploader){const ext=uploader.gl.getExtension('WEBGL_lose_context');if(!ext)throw Error('Context loss test unavailable');ext.loseContext();setTimeout(()=>{if(!closing)ext.restoreContext();},250);
+    } else if (data.type === 'timing' && engine) {
+      Atomics.store(engine.HEAPU32, (nativeAudio >>> 2) + 5, data.latencyUs);
+      Atomics.store(engine.HEAPU32, (nativeAudio >>> 2) + 6, +data.running);
+    } else if (data.type === 'open-remote' || data.type === 'open-file') {await openRemote(data);
+    } else if(data.type==='refreshed'){ioWorker?.postMessage(data);
+    } else if(data.type==='seek'){sourceRendered=0;pendingTarget=data.seconds;restarted=false;Atomics.store(audio,2,0);submit(data.id,['seek',String(data.seconds),'absolute+exact']);
+    } else if (data.type === 'open') {
+      sourceRendered=0;
+      await closeIO();
+      if (data.bytes.byteLength > 32 * 1024 * 1024) throw new Error('M0 local fixture limit is 32 MiB');
+      try {engine.FS.unlink('/media.mkv');} catch { /* First open. */ }
+      engine.FS.writeFile('/media.mkv', new Uint8Array(data.bytes));
+      if(Number(engine.FS.stat('/media.mkv').size) !== data.bytes.byteLength) throw new Error('Local media write failed');
+      submit(data.id, ['loadfile','/media.mkv','replace']);
+    } else if(data.type==='subtitle'){
+      const path='/subtitle-'+data.id+'.'+data.format;
+      engine.FS.writeFile(path,new Uint8Array(data.bytes));
+      const result=engine.ccall('web_add_subtitle','number',['number','string','string','string','number'],[data.id,path,data.label??'',data.language??'',+data.select]);
+      if(result<0)throw Error('Could not add subtitle: '+result);
+      busyUntil=performance.now()+300;schedulePump(0);
+    } else if (data.type === 'command') {if(uploader?.lost&&data.args[0]==='set'&&data.args[1]==='pause')gpuPauseIntent=data.args[2]==='yes';submit(data.id,data.args);}
+    else if (data.type === 'resize') {busyUntil=performance.now()+300;schedulePump(0);canvas.width=data.width;canvas.height=data.height;force=true;}
+    else if (data.type === 'destroy') {
+      closing = true;
+      internalCommands.clear();
+      clearInterval(timer);
+      if (audio) Atomics.store(audio,2,0);
+      await closeIO();
+      decoderWorker?.postMessage({type:'cancel'});
+      engine?._web_destroy();if(uploader){uploader.destroy();post({type:'output',data:{kind:'yuv-cleanup',...uploader.stats}});}
+      // Native joins precede the queued pthread pool-return messages.
+      const deadline=performance.now()+2000;
+      while(engine?.PThread.runningWorkers.length&&performance.now()<deadline)
+        await new Promise(resolve=>setTimeout(resolve,10));
+      if(engine?.PThread.runningWorkers.length)throw Error('Native thread cleanup did not settle');
+      engine?.PThread.terminateAllThreads();
+      decoderWorker?.terminate();decoderWorker=null;
+      // Let child termination and queued cleanup run before closing their owner.
+      await new Promise(resolve=>setTimeout(resolve,50));
+      post({type:'destroyed',decoderStats});
+      self.close();
+    }
+  } catch (error) {post({type:'error',id:data.id,message:String(error.stack || error)});}
+};
+function submit(id,args) {
+  if (!engine || closing) throw new Error('Player is unavailable');
+  if (args.length > 4 || !args.length) throw new Error('Invalid command arity');
+  busyUntil=performance.now()+300;schedulePump(0);
+  const padded = [...args];
+  while (padded.length < 4) padded.push(null);
+  const result = engine.ccall('web_command_args','number',['number','string','string','string','string'],[id,...padded]);
+  if (result < 0) throw new Error(`mpv command failed: ${result}`);
+}

package/web/source-probe.js

@@ -0,0 +1,28 @@
+// Packet-only metadata preflight. No decoded audio or video is produced.
+export async function probeSource(source,signal,audioAdaptation){
+ if(!crossOriginIsolated)throw Error('Automatic source inspection requires cross-origin isolation');
+ if(signal.aborted)throw new DOMException('Aborted','AbortError');
+ const mailbox=new SharedArrayBuffer(64+262144),workers=[];let abort;
+ try{return await new Promise((resolve,reject)=>{
+  const timer=setTimeout(()=>reject(Error('Source inspection timed out')),20000);
+  const finish=(error,value)=>{clearTimeout(timer);error?reject(error):resolve(value);};
+  abort=()=>finish(new DOMException('Aborted','AbortError'));signal.addEventListener('abort',abort,{once:true});
+  const make=file=>{const w=new Worker(new URL(file,import.meta.url),{type:'module'});workers.push(w);w.onerror=e=>{e.preventDefault();finish(Error('Source inspection worker failed: '+e.message));};w.onmessageerror=()=>finish(Error('Source inspection message error'));return w;};
+  const reader=make('./native-remux-source-worker.js');
+  reader.onmessage=({data})=>{
+   if(signal.aborted)return;
+   if(data.type==='error')finish(Error('Source transport: '+data.message));
+   if(data.type==='refresh')Promise.resolve().then(()=>{if(!source.refreshAuthorization)throw Error('Authorization refresh unavailable');return source.refreshAuthorization(data.resource);}).then(update=>{if(!signal.aborted)reader.postMessage({type:'refreshed',update});},error=>{if(!signal.aborted)reader.postMessage({type:'refreshed',error:String(error)});});
+   if(data.type==='ready'){
+    const probe=make('./native-remux-worker.js');probe.onmessage=({data:message})=>{
+     if(message.type==='error')finish(Error(message.message));
+     if(message.type==='probed')finish(null,{tracks:message.tracks,duration:message.duration,format:message.format,identity:data.identity});
+    };probe.postMessage({type:'probe',size:data.size,mailbox,audioAdaptation});
+   }
+  };
+  const {refreshAuthorization,...transport}=source;reader.postMessage({type:'init',mailbox,...transport});
+ });}finally{
+  signal.removeEventListener('abort',abort);const h=new Int32Array(mailbox,0,16);Atomics.store(h,4,1);Atomics.store(h,0,3);Atomics.notify(h,0);
+  for(const worker of workers)worker.terminate();
+ }
+}

package/web/split-mp4.js

@@ -0,0 +1,159 @@
+// Packaging-only split of the maintained muxer's clear, default-base-is-moof
+// fragments. Sample bytes, decode times, composition offsets and sample metadata
+// are preserved. Other BMFF addressing schemes are rejected, never guessed.
+const text=b=>String.fromCharCode(...b);
+function boxes(bytes){
+ const result=[],view=new DataView(bytes.buffer,bytes.byteOffset,bytes.byteLength);
+ for(let at=0;at<bytes.length;){
+  if(result.length>=4096)throw Error('MP4 box budget exceeded');
+  if(at+8>bytes.length)throw Error('Truncated MP4 box');
+  const size=view.getUint32(at);if(size<8||at+size>bytes.length)throw Error('Unsupported or truncated MP4 box size');
+  result.push({type:text(bytes.subarray(at+4,at+8)),at,bytes:bytes.subarray(at,at+size)});at+=size;
+ }
+ return result;
+}
+const u32=(b,n)=>new DataView(b.buffer,b.byteOffset,b.byteLength).getUint32(n);
+function join(parts){const out=new Uint8Array(parts.reduce((n,p)=>n+p.length,0));let at=0;for(const part of parts){out.set(part,at);at+=part.length;}return out;}
+function box(type,parts){const payload=join(parts),out=new Uint8Array(payload.length+8);new DataView(out.buffer).setUint32(0,out.length);out.set([...type].map(c=>c.charCodeAt(0)),4);out.set(payload,8);return out;}
+const children=b=>boxes(b.subarray(8));
+export class SplitMP4 {
+ constructor(){this.ids=[];this.defaults=new Map();}
+ split(input){
+  if(input.byteLength>8*1024*1024)throw Error('Split MP4 input budget exceeded');
+  const bytes=new Uint8Array(input),top=boxes(bytes),out=[[],[]];
+  for(let n=0;n<top.length;n++){
+   const current=top[n];
+   if(current.type==='ftyp'){for(const lane of out)lane.push(current.bytes);}
+   else if(current.type==='moov'){
+    if(this.ids.length)throw Error('Unexpected MP4 reinitialization');
+    const parts=children(current.bytes),tracks=parts.filter(p=>p.type==='trak');
+    if(tracks.length!==2)throw Error('Split MP4 requires exactly two tracks');
+    const roles=new Map();
+    for(const track of tracks){
+     const sub=children(track.bytes),tkhd=sub.find(p=>p.type==='tkhd')?.bytes,mdia=sub.find(p=>p.type==='mdia')?.bytes;
+     if(!tkhd||!mdia)throw Error('Missing track identity');
+     const handler=children(mdia).find(p=>p.type==='hdlr')?.bytes;
+     if(!handler)throw Error('Missing track handler');
+     const role=text(handler.subarray(16,20)),id=u32(tkhd,tkhd[8]===1?28:20);
+     if(!['vide','soun'].includes(role)||roles.has(role))throw Error('Unsupported track roles');
+     roles.set(role,{id,bytes:track.bytes});
+    }
+    this.ids=['vide','soun'].map(role=>roles.get(role).id);
+    const mvex=parts.find(p=>p.type==='mvex');if(!mvex)throw Error('Missing fragment defaults');
+    for(const p of children(mvex.bytes))if(p.type==='trex')this.defaults.set(u32(p.bytes,12),u32(p.bytes,24));
+    for(let lane=0;lane<2;lane++){
+     const track=roles.get(lane?'soun':'vide');
+     out[lane].push(box('moov',parts.flatMap(p=>p.type==='trak'?(p.bytes===track.bytes?[p.bytes]:[]):p.type==='mvex'?[box('mvex',children(p.bytes).filter(c=>c.type!=='trex'||u32(c.bytes,12)===track.id).map(c=>c.bytes))]:[p.bytes])));
+    }
+   }else if(current.type==='moof'){
+    if(this.ids.length!==2)throw Error('Fragment before track initialization');
+    const data=top[++n];if(data?.type!=='mdat')throw Error('Expected adjacent media data');
+    const used=[],parts=children(current.bytes),header=parts.find(p=>p.type==='mfhd');if(!header)throw Error('Missing fragment sequence');
+    for(const traf of parts.filter(p=>p.type==='traf')){
+     const fields=children(traf.bytes),tfhd=fields.find(p=>p.type==='tfhd')?.bytes;
+     if(!tfhd)throw Error('Missing fragment track identity');
+     const flags=u32(tfhd,8)&0xffffff,id=u32(tfhd,12),lane=this.ids.indexOf(id);
+     if(lane<0||!(flags&0x020000)||(flags&1))throw Error('Unsupported fragment addressing');
+     let at=16;if(flags&2)at+=4;if(flags&8)at+=4;
+     const defaultSize=flags&16?u32(tfhd,at):this.defaults.get(id)??0;
+     const runs=[],payload=[];
+     for(const field of fields){
+      if(!['tfhd','tfdt','trun','sgpd','sbgp'].includes(field.type))throw Error('Unsupported fragment auxiliary data');
+      if(field.type!=='trun')continue;
+      const trun=field.bytes,f=u32(trun,8)&0xffffff,count=u32(trun,12);
+      if(!(f&1)||count>20000)throw Error('Unsupported sample run addressing or count');
+      const start=current.at+new DataView(trun.buffer,trun.byteOffset,trun.length).getInt32(16);
+      let cursor=20+(f&4?4:0),length=0;
+      for(let i=0;i<count;i++){
+       if(f&0x100)cursor+=4;
+       const size=f&0x200?u32(trun,cursor):defaultSize;
+       if(f&0x200)cursor+=4;if(f&0x400)cursor+=4;if(f&0x800)cursor+=4;
+       if(cursor>trun.length||!size)throw Error('Invalid sample description');length+=size;
+      }
+      if(cursor!==trun.length||start<data.at+8||start+length>data.at+data.bytes.length)throw Error('Sample run exceeds media data');
+      if(used.some(([a,b])=>start<b&&start+length>a))throw Error('Overlapping sample runs');
+      used.push([start,start+length]);
+      const copy=trun.slice();runs.push(copy);payload.push(bytes.subarray(start,start+length));field.bytes=copy;
+     }
+     const newTraf=box('traf',fields.map(p=>p.bytes));let offset=8+header.bytes.length+newTraf.length+8;
+     for(let i=0;i<runs.length;i++){new DataView(runs[i].buffer).setInt32(16,offset);offset+=payload[i].length;}
+     out[lane].push(box('moof',[header.bytes,box('traf',fields.map(p=>p.bytes))]),box('mdat',payload));
+    }
+    if(used.reduce((sum,[a,b])=>sum+b-a,0)!==data.bytes.length-8)throw Error('Unaccounted media data');
+   }else if(current.type!=='mfra'&&current.type!=='free')throw Error('Unsupported top-level MP4 box: '+current.type);
+   // mfra is the old combined-file seek index. The source demuxer owns seeking;
+   // MSE does not consume this now-invalid byte-offset index.
+  }
+  return out.map(parts=>join(parts).buffer);
+ }
+}
+
+// Read the maintained muxer's actual presentation intervals. In B-frame MP4,
+// duration follows decode-order deltas and can differ from rounded input packet
+// durations. Do not infer the presented frame solely from the latest input PTS.
+export class MP4VideoTiming {
+ constructor(){this.track=undefined;this.scale=0;this.shift=0;this.defaults=new Map();}
+ read(input){
+  if(input.byteLength>8*1024*1024)throw Error('MP4 timing input budget exceeded');
+  const frames=[];
+  for(const top of boxes(new Uint8Array(input))){
+   if(top.type==='moov'){
+    if(this.track!==undefined)throw Error('Unexpected timing reinitialization');
+    const parts=children(top.bytes),movie=parts.find(p=>p.type==='mvhd')?.bytes;
+    const movieScale=movie?u32(movie,movie[8]===1?28:20):0;
+    for(const p of parts){
+     if(p.type==='mvex')for(const d of children(p.bytes))if(d.type==='trex')this.defaults.set(u32(d.bytes,12),u32(d.bytes,20));
+     if(p.type!=='trak')continue;
+     const fields=children(p.bytes),header=fields.find(p=>p.type==='tkhd')?.bytes,mdia=fields.find(p=>p.type==='mdia')?.bytes;
+     if(!header||!mdia)throw Error('Missing timing track');
+     const media=children(mdia),handler=media.find(p=>p.type==='hdlr')?.bytes,time=media.find(p=>p.type==='mdhd')?.bytes;
+     if(!handler||!time)throw Error('Missing media time base');
+     if(text(handler.subarray(16,20))!=='vide')continue;
+     if(this.track!==undefined)throw Error('Multiple timing video tracks');
+     this.track=u32(header,header[8]===1?28:20);this.scale=u32(time,time[8]===1?28:20);
+     if(!this.scale)throw Error('Invalid media time base');
+     const edits=fields.find(p=>p.type==='edts')?.bytes;
+     if(edits){
+      const list=children(edits).find(p=>p.type==='elst')?.bytes;
+      if(!list||!movieScale||list[8]>1)throw Error('Unsupported video edit timing');
+      const count=u32(list,12),view=new DataView(list.buffer,list.byteOffset,list.length);let cursor=16,movieTime=0,mediaFound=false;
+      if(!count||count>2)throw Error('Unsupported video edit count');
+      for(let i=0;i<count;i++){
+       const wide=list[8]===1,length=wide?Number(view.getBigUint64(cursor)):u32(list,cursor);cursor+=wide?8:4;
+       const time=wide?Number(view.getBigInt64(cursor)):view.getInt32(cursor);cursor+=wide?8:4;
+       if(!Number.isSafeInteger(length)||!Number.isSafeInteger(time)||view.getInt16(cursor)!==1||view.getInt16(cursor+2)!==0)throw Error('Unsupported video edit rate or time');cursor+=4;
+       if(time===-1&&!mediaFound)movieTime+=length/movieScale;
+       else if(time>=0&&!mediaFound){this.shift=movieTime-time/this.scale;mediaFound=true;if(length)throw Error('Finite video edit not qualified for progressive timing');}
+       else throw Error('Unsupported video edit sequence');
+      }
+      if(!mediaFound||cursor!==list.length)throw Error('Invalid video edit timing');
+     }
+    }
+   }
+   if(top.type!=='moof')continue;
+   if(this.track===undefined)throw Error('Timing fragment before initialization');
+   for(const p of children(top.bytes).filter(p=>p.type==='traf')){
+    const fields=children(p.bytes),header=fields.find(p=>p.type==='tfhd')?.bytes,base=fields.find(p=>p.type==='tfdt')?.bytes;
+    if(!header||!base)throw Error('Missing fragment timing');
+    if(u32(header,12)!==this.track)continue;
+    const flags=u32(header,8)&0xffffff;let at=16+(flags&1?8:0)+(flags&2?4:0);
+    const duration=flags&8?u32(header,at):this.defaults.get(this.track);
+    let dts=base[8]===1?Number(new DataView(base.buffer,base.byteOffset,base.length).getBigUint64(12)):u32(base,12);
+    if(!Number.isSafeInteger(dts))throw Error('Unrepresentable fragment decode time');
+    for(const run of fields.filter(p=>p.type==='trun')){
+     const b=run.bytes,f=u32(b,8)&0xffffff,count=u32(b,12);at=16+(f&1?4:0)+(f&4?4:0);
+     if(count+frames.length>4096)throw Error('Video timing sample budget exceeded');
+     for(let i=0;i<count;i++){
+      const length=f&0x100?u32(b,at):duration;if(f&0x100)at+=4;
+      if(f&0x200)at+=4;if(f&0x400)at+=4;
+      const cts=f&0x800?(b[8]===1?new DataView(b.buffer,b.byteOffset,b.length).getInt32(at):u32(b,at)):0;if(f&0x800)at+=4;
+      if(!length||at>b.length||!Number.isSafeInteger(dts+cts+length))throw Error('Invalid video presentation interval');
+      frames.push([(dts+cts)/this.scale+this.shift,length/this.scale]);dts+=length;
+     }
+     if(at!==b.length)throw Error('Unexpected video timing fields');
+    }
+   }
+  }
+  return frames;
+ }
+}

package/web/streaming-manifest.js

@@ -0,0 +1,136 @@
+// Bounded manifest selection and finite DASH-period adaptation. Compressed media
+// is never decoded here; FFmpeg still demuxes segments and owns packet timelines.
+const enc=new TextEncoder();
+const fail=message=>{throw Error(message);};
+const escape=s=>String(s).replaceAll('&','&amp;').replaceAll('"','&quot;').replaceAll('<','&lt;');
+const entities=s=>s.replace(/&(#x[0-9a-f]+|#\d+|amp|lt|gt|quot|apos);/gi,(_,v)=>v[0]==='#'?String.fromCodePoint(v[1].toLowerCase()==='x'?parseInt(v.slice(2),16):Number(v.slice(1))):({amp:'&',lt:'<',gt:'>',quot:'"',apos:"'"})[v]);
+export function parseXML(text){
+ if(/<!DOCTYPE|<!ENTITY|<!\[CDATA\[/i.test(text))fail('Unsupported DASH XML declaration');
+ const root={name:'',attrs:{},children:[],text:''},stack=[root];let count=0;
+ const tokens=text.match(/<!--[\s\S]*?-->|<\?[\s\S]*?\?>|<[^>]*>|[^<]+/g)??[];
+ if(tokens.join('')!==text)fail('Malformed DASH XML');
+ for(const token of tokens){
+  if(token.startsWith('<!--')||token.startsWith('<?'))continue;
+  if(!token.startsWith('<')){stack.at(-1).text+=entities(token);continue;}
+  if(token.startsWith('</')){if(stack.length===1||stack.pop().name!==token.slice(2,-1).trim())fail('Malformed DASH XML');continue;}
+  const name=/^<([\w:.-]+)/.exec(token)?.[1];if(!name||++count>50000||stack.length>32)fail('Invalid DASH XML bounds');
+  const attrs={};let rest=token.slice(name.length+1).replace(/\/?\s*>$/,'');
+  while(rest.trim()){
+   const m=/^\s+([\w:.-]+)\s*=\s*(["'])([\s\S]*?)\2/.exec(rest);if(!m||Object.hasOwn(attrs,m[1]))fail('Malformed DASH attributes');
+   attrs[m[1]]=entities(m[3]);rest=rest.slice(m[0].length);
+  }
+  const node={name,attrs,children:[],text:''};stack.at(-1).children.push(node);if(!/\/\s*>$/.test(token))stack.push(node);
+ }
+ if(stack.length!==1||root.children.length!==1||root.children[0].name!=='MPD')fail('Malformed DASH MPD');return root.children[0];
+}
+const children=(n,name)=>n.children.filter(c=>c.name===name);
+const child=(n,name)=>children(n,name)[0];
+const xml=n=>`<${n.name}${Object.entries(n.attrs).map(([k,v])=>` ${k}="${escape(v)}"`).join('')}>${escape(n.text)}${n.children.map(xml).join('')}</${n.name}>`;
+export function isoDuration(s){const m=/^P(?:(\d+(?:\.\d+)?)D)?(?:T(?:(\d+(?:\.\d+)?)H)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)S)?)?$/.exec(s??'');if(!m)return NaN;return Number(m[1]??0)*86400+Number(m[2]??0)*3600+Number(m[3]??0)*60+Number(m[4]??0);}
+export function chooseVariant(items,options={}){
+ if(!items.length)fail('No streaming representation');
+ if(options.representation!==undefined){const exact=items.find(i=>i.id===String(options.representation));if(!exact)fail('Requested streaming representation is unavailable');return exact;}
+ const limit=options.maxBandwidth??Infinity;if(!(limit>0))fail('Invalid streaming bandwidth limit');
+ const sorted=[...items].sort((a,b)=>a.bandwidth-b.bandwidth);return sorted.filter(i=>i.bandwidth<=limit).at(-1)??sorted[0];
+}
+const attrs=line=>Object.fromEntries([...line.matchAll(/(?:^|[:,])([A-Z0-9-]+)=("[^"]*"|[^,]*)/g)].map(m=>[m[1],m[2].replace(/^"|"$/g,'')]));
+export function selectHLS(text,options={}){
+ const lines=text.split(/\r?\n/),variants=[];
+ for(let i=0;i<lines.length;i++)if(lines[i].startsWith('#EXT-X-STREAM-INF:')){
+  let j=i+1;while(j<lines.length&&!lines[j].trim())j++;
+  if(!lines[j]||lines[j].startsWith('#'))fail('Missing HLS variant URI');
+  variants.push({id:String(variants.length),bandwidth:Number(attrs(lines[i]).BANDWIDTH)||0,line:i,uri:j});
+ }
+ if(variants.length>64)fail('HLS variant limit exceeded');
+ if(!variants.length)return text;
+ const chosen=chooseVariant(variants,options),drop=new Set(variants.filter(v=>v!==chosen).flatMap(v=>[v.line,v.uri]));
+ const chosenAttrs=attrs(lines[chosen.line]);
+ return lines.filter((line,i)=>{
+  if(drop.has(i))return false;
+  if(line.startsWith('#EXT-X-MEDIA:')){const a=attrs(line);return !['AUDIO','SUBTITLES','VIDEO','CLOSED-CAPTIONS'].includes(a.TYPE)||chosenAttrs[a.TYPE]===a['GROUP-ID'];}
+  return true;
+ }).join('\n');
+}
+const baseAt=(node,base)=>child(node,'BaseURL')?new URL(child(node,'BaseURL').text.trim(),base).href:base;
+function templateURL(pattern,rep,time,number){
+ if(!pattern)fail('DASH segment URL is missing');
+ return pattern.replace(/\$\$|\$(RepresentationID|Bandwidth|Time|Number)(?:%0(\d+)d)?\$/g,(all,key,width)=>key?String(key==='RepresentationID'?rep.attrs.id:key==='Bandwidth'?rep.attrs.bandwidth:key==='Time'?time:number).padStart(Number(width)||0,'0'):'$');
+}
+function segmentsFor(rep,adaptation,period,base,duration){
+ base=baseAt(rep,baseAt(adaptation,base));
+ const inherit=name=>{const nodes=[period,adaptation,rep].map(n=>child(n,name)).filter(Boolean);return nodes.length?{...nodes.at(-1),attrs:Object.assign({},...nodes.map(n=>n.attrs)),children:[...new Map(nodes.flatMap(n=>n.children).map(n=>[n.name,n])).values()]}:undefined;};
+ const template=inherit('SegmentTemplate');
+ const list=child(rep,'SegmentList')??child(adaptation,'SegmentList')??child(period,'SegmentList');
+ const spec=template??list;if(!spec)fail('Multiple DASH periods require SegmentTemplate or SegmentList');
+ const scale=Number(spec.attrs.timescale??1),offset=Number(spec.attrs.presentationTimeOffset??0);if(!Number.isSafeInteger(scale)||scale<=0||!Number.isSafeInteger(offset))fail('Invalid DASH timescale');
+ let time=0,number=Number(spec.attrs.startNumber??1);const timeline=child(spec,'SegmentTimeline'),entries=[];
+ if(timeline){
+  const nodes=children(timeline,'S');
+  for(let i=0;i<nodes.length;i++){
+   const s=nodes[i];time=s.attrs.t===undefined?time:Number(s.attrs.t);const d=Number(s.attrs.d);let r=Number(s.attrs.r??0);
+   if(r===-1){const next=nodes[i+1]?.attrs.t;r=Math.ceil(((next===undefined?duration*scale+offset:Number(next))-time)/d)-1;}
+   if(!Number.isSafeInteger(time)||!Number.isSafeInteger(d)||d<=0||!Number.isInteger(r)||r<0||entries.length+r+1>10000)fail('Invalid or unbounded DASH timeline');
+   for(let j=0;j<=r;j++){entries.push({time,duration:d/scale,number:number++});time+=d;}
+  }
+ }else{
+  const d=Number(spec.attrs.duration);if(!(d>0&&duration>0)||Math.ceil(duration*scale/d)>10000)fail('DASH period needs a bounded segment duration');
+  for(let n=0;n<Math.ceil(duration*scale/d);n++)entries.push({time:offset+n*d,duration:Math.min(d/scale,duration-n*d/scale),number:number++});
+ }
+ if(!entries.length)fail('Empty DASH period');
+ const init=template?new URL(templateURL(template.attrs.initialization,rep,0,0),base).href:new URL(child(list,'Initialization')?.attrs.sourceURL??fail('Missing DASH initialization'),base).href;
+ const urls=list?children(list,'SegmentURL'):[];
+ if(list&&urls.length!==entries.length)fail('DASH SegmentList timeline mismatch');
+ if(list&&(child(list,'Initialization')?.attrs.range||urls.some(n=>n.attrs.mediaRange)))fail('Multi-period byte-range DASH requires separate segment resources');
+ return {init,entries:entries.map((e,i)=>({...e,url:new URL(template?templateURL(template.attrs.media,rep,e.time,e.number):urls[i].attrs.media,base).href})),offset:entries[0].time/scale-offset/scale};
+}
+export function prepareDASH(text,url,options={}){
+ const mpd=parseXML(text),periods=children(mpd,'Period');
+ if(!periods.length||periods.length>64)fail('DASH period count limit exceeded');
+ const all=[];const visit=n=>{all.push(n);n.children.forEach(visit);};visit(mpd);
+ if(all.some(n=>['ContentProtection','Location','PatchLocation','EventStream'].includes(n.name)||Object.keys(n.attrs).some(k=>k.startsWith('xlink:'))))fail('Unsupported DASH extension');
+ for(const period of periods)for(const adaptation of children(period,'AdaptationSet')){
+  const reps=children(adaptation,'Representation');if(reps.length>64)fail('DASH representation limit exceeded');
+  const type=adaptation.attrs.contentType??(reps[0]?.attrs.mimeType??adaptation.attrs.mimeType??'').split('/')[0];
+  const selected=chooseRepresentation(reps,type==='video'?options:{});
+  adaptation.children=adaptation.children.filter(n=>n.name!=='Representation'||n===selected);
+ }
+ if(periods.length===1)return {bytes:enc.encode(xml(mpd)),format:'dash',resources:new Map()};
+ if(mpd.attrs.type!=='static')fail('Multiple live DASH periods are unsupported');
+ const resources=new Map(),tracks=new Map(),rootBase=baseAt(mpd,url);let expectedStart=0;
+ for(let i=0;i<periods.length;i++){
+  const period=periods[i],start=period.attrs.start===undefined?expectedStart:isoDuration(period.attrs.start);
+  let duration=isoDuration(period.attrs.duration);
+  if(!Number.isFinite(duration))duration=(i+1<periods.length?isoDuration(periods[i+1].attrs.start):isoDuration(mpd.attrs.mediaPresentationDuration))-start;
+  if(!Number.isFinite(start)||Math.abs(start-expectedStart)>.01||!(duration>0))fail('DASH periods must have contiguous finite durations');
+  const present=new Set();
+  for(const [a,adaptation] of children(period,'AdaptationSet').entries()){
+   const rep=child(adaptation,'Representation'),type=adaptation.attrs.contentType??(rep?.attrs.mimeType??adaptation.attrs.mimeType??'').split('/')[0];
+   if(!rep||!['video','audio'].includes(type))fail('Multi-period DASH requires audio/video fMP4 representations');
+   const key=type+':'+(adaptation.attrs.id??a),mime=rep.attrs.mimeType??adaptation.attrs.mimeType;
+   if(mime&&!mime.endsWith('/mp4'))fail('Multi-period DASH requires fMP4 segments');
+   const info=segmentsFor(rep,adaptation,period,baseAt(period,rootBase),duration);
+   if(Math.abs(info.offset)>.01)fail('DASH period starts must align with their first segment');
+   const language=adaptation.attrs.lang??'und';if(!/^[a-zA-Z0-9-]{1,64}$/.test(language))fail('Invalid DASH language tag');
+   const track=tracks.get(key)??{type,language,parts:[],bandwidth:Number(rep.attrs.bandwidth)||1000000};
+   if(i&&!tracks.has(key))fail('DASH track identity changed across periods');
+   track.parts.push({duration,...info});tracks.set(key,track);present.add(key);
+  }
+  if(present.size!==tracks.size)fail('DASH tracks cannot disappear across periods');expectedStart=start+duration;
+ }
+ const prefix=new URL('__demuxe_periods__/',url).href;let audio=[],video=[];
+ for(const [key,t] of tracks){
+  const uri=prefix+encodeURIComponent(key)+'.m3u8';let body='#EXTM3U\n#EXT-X-VERSION:7\n#EXT-X-TARGETDURATION:'+Math.ceil(Math.max(...t.parts.flatMap(p=>p.entries.map(e=>e.duration))))+'\n#EXT-X-PLAYLIST-TYPE:VOD\n';
+  for(const [i,p] of t.parts.entries()){
+   if(i)body+='#EXT-X-DISCONTINUITY\n';body+='#EXT-X-MAP:URI="'+p.init+'"\n';
+   let remaining=p.duration;for(const e of p.entries){if(remaining<=.000001)break;const d=Math.min(e.duration,remaining);body+=`#EXTINF:${d},\n${e.url}\n`;remaining-=d;}
+   if(remaining>.05)fail('DASH segments do not cover period duration');
+  }
+  body+='#EXT-X-ENDLIST\n';resources.set(uri,enc.encode(body));(t.type==='audio'?audio:video).push({...t,uri,key});
+ }
+ if(video.length>1)fail('Choose one DASH video adaptation set');
+ let master='#EXTM3U\n';for(const [i,a] of audio.entries())master+=`#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="audio-${i}",LANGUAGE="${a.language}",DEFAULT=${i?'NO':'YES'},AUTOSELECT=YES,URI="${a.uri}"\n`;
+ const main=video[0]??audio[0];if(!main)fail('Empty DASH presentation');
+ master+=`#EXT-X-STREAM-INF:BANDWIDTH=${main.bandwidth}${audio.length&&video.length?',AUDIO="audio"':''}\n${main.uri}\n`;
+ return {bytes:enc.encode(master),format:'hls',url:prefix+'master.m3u8',resources};
+}
+function chooseRepresentation(reps,options){return chooseVariant(reps.map(node=>({node,id:node.attrs.id,bandwidth:Number(node.attrs.bandwidth)||0})),options).node;}

package/web/subtitle-overlay.js

@@ -0,0 +1,26 @@
+// Decode bounded mpv A8/color or premultiplied BGRA tiles into cached browser surfaces.
+export class SubtitleOverlay {
+ constructor(){this.serial=-1;this.snapshot={parts:[]};this.stats={updates:0,bytes:0,peakBytes:0,parts:0,renders:0};}
+ read(engine){
+  const ptr=engine._web_subtitle_ptr(),h=new Int32Array(engine.HEAPU8.buffer,ptr,8);
+  this.stats.renders=h[6];if(h[3])throw Error('Subtitle bitmap budget exceeded');
+  if(this.serial===h[0])return this.snapshot;
+  if(h[1]<0||h[1]>512||h[2]<0||h[2]>2*1024*1024)throw Error('Invalid subtitle packet');
+  const parts=[];
+  for(let i=0;i<h[1];i++){
+   const d=new Int32Array(engine.HEAPU8.buffer,ptr+32+i*36,9),[x,y,w,height,dw,dh,format,color,offset]=d;
+   const bpp=format===1?1:4,size=w*height*bpp;
+   if(![1,2].includes(format)||w<=0||height<=0||dw<=0||dh<=0||offset<0||offset+size>h[2])throw Error('Invalid subtitle tile');
+   const input=new Uint8Array(engine.HEAPU8.buffer,ptr+32+512*36+offset,size),image=new ImageData(w,height),rgba=image.data;
+   for(let j=0;j<w*height;j++){
+    if(format===1){rgba[j*4]=color>>>24;rgba[j*4+1]=(color>>>16)&255;rgba[j*4+2]=(color>>>8)&255;rgba[j*4+3]=Math.round(input[j]*(255-(color&255))/255);}
+    else{const a=input[j*4+3];rgba[j*4]=a?Math.min(255,Math.round(input[j*4+2]*255/a)):0;rgba[j*4+1]=a?Math.min(255,Math.round(input[j*4+1]*255/a)):0;rgba[j*4+2]=a?Math.min(255,Math.round(input[j*4]*255/a)):0;rgba[j*4+3]=a;}
+   }
+   const tile=new OffscreenCanvas(w,height);tile.getContext('2d').putImageData(image,0,0);parts.push({tile,x,y,dw,dh});
+  }
+  this.serial=h[0];this.stats.updates++;this.stats.bytes+=h[2];this.stats.peakBytes=Math.max(this.stats.peakBytes,h[2]);this.stats.parts=h[1];
+  return this.snapshot={parts};
+ }
+ draw(context,snapshot){for(const p of snapshot.parts)context.drawImage(p.tile,p.x,p.y,p.dw,p.dh);}
+ clear(){this.serial=-1;this.snapshot={parts:[]};this.stats.parts=0;}
+}