"""Render each three-episode base as one calibrated, normalized bundle.""" from __future__ import annotations import argparse,fcntl,gzip,json,math,os,shutil,time,traceback from pathlib import Path import numpy as np import soundfile as sf from dynamic_demo.render import make_dry,two_time_convolution from exhibition_dataset.render import NativeRenderer,source_mask,fixed_source from .noise import waveform as noise_waveform from .common import * from .geometry import audit from .resume_binding import compatible_cleanup_only def code_binding(): repo=Path(__file__).resolve().parents[1] names=['exhibition_v3/render.py','exhibition_v3/common.py','exhibition_v3/geometry.py', 'exhibition_dataset/render.py','exhibition_dataset/noise.py','exhibition_v3/noise.py','dynamic_demo/render.py', 'dynamic_dataset/common.py','dynamic_demo/common.py','exhibition_dataset/common.py'] return {name:sha(repo/name) for name in names} def noise_component(root,episode,receiver,engine): count=episode['duration_samples'];pre=math.ceil(engine.recipe['renderer']['irTime']*SR) dry=noise_waveform(episode['noise'],count+pre,root) dry=np.r_[dry,np.zeros(pre+1,np.float32)] rn=sorted(set([0.,pre/SR]+[round(t+pre/SR,9) for t in rir_nodes(receiver)])) source=fixed_source(episode['noise']) rendered=two_time_convolution(dry,[0.],rn, lambda te,tr:engine.kernel(source,receiver,0.,max(0.,tr-pre/SR)), max_tail_s=engine.recipe['renderer']['irTime']+.001) return rendered[pre:pre+count] def run(root,group,gpu,cache): ensure_compute();root=root.resolve();cache=cache.resolve() result_path=root/'reports/bases'/f"{group['index']:04d}.json" binding=dict(plan_sha256=sha(root/'private/plans'/f"{group['index']:04d}.json"),code=code_binding()) if result_path.exists(): result=read(result_path) if result['binding']!=binding and not compatible_cleanup_only(result['binding'],binding): raise ValueError('Completed bundle uses different plan or rendering code') for record in result['recordings']: if sha(root/record['path'])!=record['sha256']:raise ValueError('Completed FOA checksum mismatch') return result cache.mkdir(parents=True,exist_ok=True) started=time.monotonic();engine_root=cache/'engine';(engine_root/'assets').mkdir(parents=True,exist_ok=True) link=engine_root/'assets/room' if not link.exists():link.symlink_to(root/'shared/rooms'/group['room_id']/'assets/room',target_is_directory=True) engine=NativeRenderer(engine_root,group,cache/'rirs',gpu) original=engine.kernel def kernel(source,receiver,te,tr): write(root/'operations/progress'/f"{group['index']:04d}.json",dict(time_unix=time.time(), base_index=group['index'],source_id=source['entity_id'],receiver_id=receiver['entity_id'], source_time_s=te,receiver_time_s=tr,gpu=gpu,pid=os.getpid(),host=os.environ.get('HOSTNAME'))) return original(source,receiver,te,tr) engine.kernel=kernel components={};records=[];measurements=[];waves={};checks=[] try: episodes=group['static_episodes']+group['dynamic_episodes'];base=episodes[0] dry,gains=make_dry(root,base) calibration=None;noise_gain=0. if base['noise']['enabled']: target=base['humans'][0];receiver=base['robots'][0] rendered=two_time_convolution(dry[target['entity_id']],[0.],[0.], lambda te,tr:engine.kernel(target,receiver,te,tr),max_tail_s=group['renderer']['irTime']+.001) noise=noise_component(root,base,receiver,engine);mask=source_mask(target,len(dry[target['entity_id']])) signal_power=float(np.mean(rendered[mask,0].astype(float)**2));noise_power=float(np.mean(noise[mask,0].astype(float)**2)) if signal_power<=0 or noise_power<=0:raise ValueError('Invalid static SNR reference power') noise_gain=math.sqrt(signal_power/(noise_power*10**(base['noise']['nominal_snr_db']/10))) calibration=dict(reference_episode_id=base['episode_id'],reference_human='H01',reference_receiver='R01', channel='W',mask='emitted H01 speech activity',signal_power=signal_power,unit_noise_power=noise_power, nominal_snr_db=base['noise']['nominal_snr_db'],shared_noise_emission_gain=noise_gain, policy='unchanged across every derivative and receiver; received SNR is separately measured') for episode in episodes: if audit(episode,group['room']) is None:raise ValueError('Independent geometry acceptance failed') eid=episode['episode_id'];mode=episode['mode'];dry,current_gains=make_dry(root,episode) if current_gains!=gains:raise ValueError('Dry emission gains changed between base derivatives') for receiver in episode['robots']: rid=receiver['entity_id'];stems={} for source in episode['humans']+episode['playback_sources']: sid=source['entity_id'] if sid==rid:continue key=uid('stem',source,receiver,episode['duration_samples']) if key not in components: components[key]=two_time_convolution(dry[sid],rir_nodes(source),rir_nodes(receiver), lambda te,tr,s=source:engine.kernel(s,receiver,te,tr),max_tail_s=group['renderer']['irTime']+.001) stems[sid]=components[key] noise=np.zeros((episode['duration_samples'],4),np.float32) if episode['noise']['enabled']: key=uid('noise',episode['noise'],receiver,episode['duration_samples']) if key not in components:components[key]=noise_component(root,episode,receiver,engine)*noise_gain noise=components[key] speech=sum((x.astype(np.float64) for x in stems.values()),np.zeros_like(noise,dtype=np.float64)) wave=(speech+noise).astype(np.float32) if not np.isfinite(wave).all() or not np.any(wave):raise ValueError('Invalid or silent FOA') waves[(eid,rid)]=wave records.append(dict(recording_id=uid(eid,rid,'recording'),episode_id=eid,scene_id=group['scene_id'], base_scene_id=group['base_scene_id'],receiver_robot_id=rid,mode=mode, path=f'{mode}/public/audio/test/{eid}/{rid}_foa.wav',num_samples=len(wave),sample_rate_hz=SR, num_channels=4,channels=['W','Y','Z','X'],ordering='ACN',normalization='SN3D',subtype='FLOAT',global_start_sample=0, raw_peak=float(np.max(np.abs(wave))))) checks.append(dict(episode_id=eid,receiver_id=rid,source_ids=list(stems),own_playback_excluded=rid not in stems, noise_included=episode['noise']['enabled'],finite=True, mixture_reconstruction_error=float(np.max(np.abs(wave.astype(float)-speech-noise))))) for human in episode['humans']: mask=source_mask(human,len(wave));target=stems[human['entity_id']][:,0].astype(float) competing=speech[:,0]-target powers=[float(np.mean(x[mask]**2)) for x in [target,competing,noise[:,0].astype(float)]] sp,ip,npower=powers ratio=lambda denom:10*math.log10(sp/denom) if sp>0 and denom>1e-30 else None snr=ratio(npower) if calibration and eid==base['episode_id'] and rid=='R01' and human['entity_id']=='H01': if abs(snr-base['noise']['nominal_snr_db'])>.001:raise ValueError('Static anchor SNR calibration failed') measurements.append(dict(episode_id=eid,receiver_id=rid,source_id=human['entity_id'], target_power=sp,competing_speech_power=ip,environmental_noise_power=npower, snr_db=snr,sir_db=ratio(ip),sinr_db=ratio(ip+npower),mask='emitted target speech activity; received W channel', nominal_static_anchor_snr_db=episode['noise'].get('nominal_snr_db'))) print('EPISODE',group['index'],episode['variant_id'],'rirs',len(engine.records),flush=True) # ONE common scale preserves all cross-receiver and static/dynamic energy ratios. scale=min(1.,.9/max(record['raw_peak'] for record in records)) for record in records: wave=waves[(record['episode_id'],record['receiver_robot_id'])]*scale path=root/record['path'];path.parent.mkdir(parents=True,exist_ok=True);temporary=path.with_suffix('.part.wav') write_float_wav(temporary,wave);temporary.replace(path) back,rate=sf.read(path,dtype='float32');np.testing.assert_array_equal(back,wave) if rate!=SR:raise ValueError('FOA sample rate differs') record.update(sha256=sha(path),common_final_gain=scale,final_peak=float(np.max(np.abs(wave)))) rir_path=root/'private/rir_audits'/f"{group['index']:04d}.jsonl.gz";rir_path.parent.mkdir(parents=True,exist_ok=True) with gzip.open(rir_path,'wt') as f: for record in sorted(engine.records.values(),key=lambda r:r['rir_id']):f.write(json.dumps(record,separators=(',',':'))+'\n') result=dict(passed=True,binding=binding,base_scene_id=group['base_scene_id'],index=group['index'],room_id=group['room_id'], recordings=records,acoustic_measurements=measurements,audio_checks=checks,noise_calibration=calibration, dry_gains=gains,common_final_gain=scale,final_normalization_applied=True,rir_count=len(engine.records), rir_audit_path=str(rir_path.relative_to(root)),rir_audit_sha256=sha(rir_path), wall_seconds=time.monotonic()-started,completed_unix=time.time(),host=os.environ.get('HOSTNAME'),gpu=gpu) write(result_path,result);print('BASE COMPLETE',group['index'],round(result['wall_seconds'],1),flush=True) return result finally:engine.close() def worker(root,gpu,shard,shards,cache_root,limit=800): ensure_compute() for index in range(shard,limit,shards): path=root/'private/plans'/f'{index:04d}.json' if not path.exists():raise ValueError('Frozen plan missing: '+str(path)) lock_path=root/'operations/locks'/f'{index:04d}.lock';lock_path.parent.mkdir(parents=True,exist_ok=True) with lock_path.open('a+') as lock: fcntl.flock(lock,fcntl.LOCK_EX) cache=cache_root/f'{index:04d}' try: run(root,read(path),gpu,cache) if cache.exists():shutil.rmtree(cache) error=root/'reports/errors'/f'{index:04d}.json' if error.exists():error.unlink() except Exception as exc: write(root/'reports/errors'/f'{index:04d}.json',dict(index=index,error=repr(exc),traceback=traceback.format_exc(),time_unix=time.time())) print('BASE FAILED',index,repr(exc),flush=True) raise write(root/'operations/workers'/f'{shard:02d}.json',dict(complete=True,shard=shard,shards=shards)) if __name__=='__main__': p=argparse.ArgumentParser();p.add_argument('--root',type=Path,required=True);p.add_argument('--gpu',type=int,required=True) p.add_argument('--shard',type=int,default=0);p.add_argument('--shards',type=int,default=16);p.add_argument('--limit',type=int,default=800) p.add_argument('--cache-root',type=Path,required=True);a=p.parse_args();worker(a.root,a.gpu,a.shard,a.shards,a.cache_root,a.limit)