Make videos on the computer you already own. FreeVideo runs MiniMax H3 in as little as 8 GB of VRAM and 16 GB of RAM, and adapts its acceleration path to your hardware.
Editor playback: where one generated part continues another, play the joined sound across the seam
Bowen Xuef90302dc8071
diff --git a/freevideo_engine/comfy_editor.py b/freevideo_engine/comfy_editor.pyindex 0d7cdd0..f28a9ff 100644--- a/freevideo_engine/comfy_editor.py+++ b/freevideo_engine/comfy_editor.py@@ -1077,6 +1077,25 @@ def _local_page(request):return False+def _same_origin_audio(request):+ if request.headers.get('Sec-Fetch-Site') in ('same-site', 'cross-site'):+ return False+ if not _local_page(request):+ return False+ referer = request.headers.get('Referer')+ if referer:+ try:+ page = urlsplit(referer)+ origin = urlsplit(request.scheme + '://' + request.host)+ return (page.scheme == origin.scheme and page.hostname == origin.hostname+ and (page.port or (443 if page.scheme == 'https' else 80)) ==+ (origin.port or (443 if origin.scheme == 'https' else 80))+ and not page.username and not page.password)+ except ValueError:+ return False+ return True # Non-browser clients are not authenticated by these headers.++async def _body(request):if request.content_length is not None and request.content_length > BODY_BYTES:raise TooLarge('Project body is too large')@@ -1159,6 +1178,39 @@ def register():raise ValueError('Too many sources')return web.json_response(dict(sources=await asyncio.to_thread(sources, root(), keys)), headers=_HEADERS)+ @endpoint('post', '/freevideo/editor/audio-chains')+ async def audio_chains(request):+ if not _same_origin_audio(request):+ return web.json_response(dict(error='Same origin required'), status=403, headers=_HEADERS)+ from .editor_playback import prepare+ body = await _body(request)+ stopped = threading.Event()+ connected = hasattr(request, 'transport')+ def cancelled():+ transport = getattr(request, 'transport', None)+ return stopped.is_set() or (connected and (transport is None or transport.is_closing()))+ worker = asyncio.create_task(asyncio.to_thread(prepare, root(), body.get('project'), cancelled))+ try:+ result = await asyncio.shield(worker)+ except asyncio.CancelledError:+ stopped.set()+ try:+ await worker+ except Exception:+ pass+ raise+ return web.json_response(result, headers=_HEADERS)++ @endpoint('get', '/freevideo/editor/audio-chain')+ async def audio_chain(request):+ if not _same_origin_audio(request):+ return web.json_response(dict(error='Same origin required'), status=403, headers=_HEADERS)+ from .editor_playback import lease_audio+ path = await asyncio.to_thread(lease_audio, root(), request.query.get('id'), request.query.get('key'))+ if not path.is_file():+ raise FileNotFoundError('Playback audio unavailable')+ return web.FileResponse(path, headers={'Content-Type': 'audio/wav', 'Cross-Origin-Resource-Policy': 'same-origin', **_HEADERS})+@endpoint('post', '/freevideo/editor/import')async def upload(request):value = await receive(request, root())diff --git a/freevideo_engine/editor_export.py b/freevideo_engine/editor_export.pyindex 1797513..655a34b 100644--- a/freevideo_engine/editor_export.py+++ b/freevideo_engine/editor_export.py@@ -13,6 +13,7 @@ import mathimport osimport reimport threading+import tempfileimport timeimport uuidfrom collections import deque@@ -22,6 +23,7 @@ from fractions import Fractionfrom pathlib import Pathfrom .editor_frames import display_frame, frame_not_after, last_frame_end+from .comfy_continuation import audio_lead_in, apply_audio_lead_infrom .editor_text import is_text_track, has_text_data, validate_text_project, paint_project, check_export_text, MissingGlyphsfrom . import editor_export_optionsfrom .editor_speed import validate_clip, changed as speed_changed, audio_changed, independent_join, VideoReader, AudioReader@@ -233,7 +235,7 @@ class _VideoReader:class _AudioReader:"""One resampled packet at a time; timestamps preserve offsets and seek alignment."""- def __init__(self, path, first_sample, cancelled):+ def __init__(self, path, first_sample, cancelled, *, rate=SAMPLE_RATE):import avself.container = Nonetry:@@ -243,10 +245,11 @@ class _AudioReader:origin_stream = next(iter(self.container.streams.video), self.stream)self.origin = Fraction(origin_stream.start_time or 0) * origin_stream.time_baseself.mono = len(self.stream.layout.channels) == 1+ self.rate = rateself.resampler = av.AudioResampler(format='fltp', layout='mono' if self.mono else 'stereo',- rate=SAMPLE_RATE)- if first_sample > SAMPLE_RATE:- stamp = self.origin + Fraction(first_sample, SAMPLE_RATE) - Fraction(1, 10)+ rate=rate)+ if first_sample > rate:+ stamp = self.origin + Fraction(first_sample, rate) - Fraction(1, 10)if self.stream.duration is not None:# A legal picture range may extend past the sound's end.# Seek into its last packet, then let samples() pad with zero.@@ -271,7 +274,7 @@ class _AudioReader:for frame in self.container.decode(self.stream):_check(self.cancelled)for item in self.resampler.resample(frame):- stamp = (round((Fraction(item.pts) * item.time_base - self.origin) * SAMPLE_RATE)+ stamp = (round((Fraction(item.pts) * item.time_base - self.origin) * self.rate)if item.pts is not None else fallback)data = item.to_ndarray()if self.mono:@@ -366,6 +369,222 @@ def _audio_frame(samples, **kwargs):return av.AudioFrame.from_ndarray(samples, **kwargs)+def _native_audio_length(path, cancelled=None):+ """Only generated stereo 32 kHz media with an exact duration can join."""+ import av+ with av.open(str(path)) as source:+ if len(source.streams.audio) != 1:+ return None+ stream = source.streams.audio[0]+ origin = next(iter(source.streams.video), stream)+ if (stream.rate != SPLICE_RATE or stream.layout.name != 'stereo'+ or stream.duration is None+ or Fraction(stream.start_time or 0) * stream.time_base !=+ Fraction(origin.start_time or 0) * origin.time_base):+ return None+ count = Fraction(stream.duration) * stream.time_base * SPLICE_RATE+ if count.denominator != 1 or count <= 0:+ return None+ # MP4 edit lists can make the first decoded frame appear at zero while+ # a later frame still starts late. Verify the whole native clock with+ # one decoded packet in memory, including availability of the tail.+ expected = Fraction(origin.start_time or 0) * origin.time_base+ heard = 0+ for frame in source.decode(stream):+ _check(cancelled)+ if (not heard and stream.codec_context.name == 'aac'+ and frame.samples != (stream.codec_context.frame_size or 1024)):+ return None # a leading edit/offset hidden by an MP4 edit list+ if (frame.pts is None or frame.time_base is None+ or Fraction(frame.pts) * frame.time_base != expected):+ return None+ heard += frame.samples+ expected += Fraction(frame.samples, SPLICE_RATE)+ return int(count) if heard >= count else None+++class _LeadStore:+ """Snapshot accepted seam data on disk, retaining one small window in RAM.++ The continuation retention task may remove records while a long export is+ running. Never silently switch a planned chain to a different audio clock.+ """+ def __init__(self, directory):+ self.file = tempfile.TemporaryFile(dir=directory)++ def save(self, lead):+ offset = self.file.seek(0, 2)+ self.file.write(lead['samples'].tobytes(order='C'))+ return offset++ def load(self, offset):+ import numpy as np+ self.file.seek(offset)+ data = self.file.read(12240 * 2 * 4)+ return dict(samples=np.frombuffer(data, dtype=np.float32).reshape(12240, 2),+ before=12000, fade=240, sample_rate=SPLICE_RATE)++ def close(self):+ self.file.close()+++def _audio_chains(clips, resolve, cancelled, lead_store=None, joinable=None):+ """Plan eligible runs; keep paths/counts, never all the lead-in tensors."""+ from av import FFmpegError+ chains, lengths = {}, {}++ def part(clip):+ path = _media(resolve, clip, 'audio')+ if path is None:+ return None+ if path not in lengths:+ try:+ lengths[path] = _native_audio_length(path, cancelled)+ except FFmpegError:+ # Full-source preflight may encounter damage beyond the kept+ # range. Let the ordinary reader validate only exported audio.+ lengths[path] = None+ length = lengths[path]+ first_output = _audio_start(clip)+ desired = Fraction(first_output, SAMPLE_RATE) * SPLICE_RATE+ first = round(desired)+ if length is None or first < 0:+ return None+ # 32 -> 48 kHz has a two-native-sample phase cycle. Frame trims+ # need not land on a native sample. Decode a little earlier on that+ # grid and drop the exact 48 kHz prefix after rate conversion.+ first = max(0, (int(desired) // 2) * 2 - 64) if first_output else 0+ skip_output = first_output - first * SAMPLE_RATE // SPLICE_RATE+ count = length - first+ if clip['in'] + clip['frames'] < clip['length']:+ count = min(count, math.ceil(Fraction(clip['frames'] * SAMPLES_PER_FRAME + skip_output,+ SAMPLE_RATE) * SPLICE_RATE))+ return dict(clip=clip, path=path, first=first, count=count, skip_output=skip_output,+ usable=count - math.ceil(Fraction(skip_output, SAMPLE_RATE) * SPLICE_RATE))++ run = []+ for previous, current in zip(clips, clips[1:]):+ _check(cancelled)+ if (previous['start'] + previous['frames'] != current['start']+ or previous['in'] + previous['frames'] != previous['length']+ or current['in'] != 0 or _audio_start(current) != 0+ or previous.get('volume', 1) != 1 or current.get('volume', 1) != 1+ or not previous.get('source') or not current.get('source')+ or joinable is not None and not joinable(previous, current)):+ run = []+ continue+ left_path = _media(resolve, previous, 'audio')+ right_path = _media(resolve, current, 'audio')+ lead = audio_lead_in(right_path, previous=left_path)+ if lead is None:+ run = []+ continue+ left, right = part(previous), part(current)+ if (left is None or right is None+ or left['usable'] < lead['before'] + (lead['fade'] if run else 0)+ or right['usable'] < lead['fade']):+ run = []+ continue+ if not run:+ run = [left]+ chains[previous['id']] = run+ if lead_store is not None:+ run[-1]['lead_offset'] = lead_store.save(lead)+ run.append(right)+ chains[current['id']] = run+ return chains+++class _JoinedAudioReader(_AudioReader):+ """Bounded native seam windows, then one resampler on a continuous clock."""+ def __init__(self, parts, cancelled, lead_store=None):+ self.parts, self.cancelled = parts, cancelled+ self.lead_store = lead_store+ self.container = None+ self.chunks = iter(self._joined_chunks())+ self.chunk = None+ try:+ self.chunk = next(self.chunks, None)+ if self.chunk is None:+ raise ExportError('unreadable')+ except BaseException:+ self.close()+ raise++ def _native_chunks(self):+ import numpy as np+ reader = None+ try:+ reader = _AudioReader(self.parts[0]['path'], self.parts[0]['first'], self.cancelled,+ rate=SPLICE_RATE)+ consumed = 0+ for index, part in enumerate(self.parts):+ _check(self.cancelled)+ next_part = self.parts[index + 1] if index + 1 < len(self.parts) else None+ lead = (self.lead_store.load(part['lead_offset']) if self.lead_store is not None+ else audio_lead_in(next_part['path'], previous=part['path'])) if next_part else None+ before = lead['before'] if lead is not None else 0+ # Leave just the replacement window undecoded until the next+ # block's head is ready. Prefix storage is independent of length.+ stop = part['count'] - before+ while consumed < stop:+ count = min(8192, stop - consumed)+ yield reader.samples(part['first'] + consumed, count)+ consumed += count+ tail = reader.samples(part['first'] + consumed, before) if before else None+ reader.close()+ if next_part is None:+ break+ reader = _AudioReader(next_part['path'], next_part['first'], self.cancelled,+ rate=SPLICE_RATE)+ consumed = 0+ if lead is not None:+ head = reader.samples(next_part['first'], lead['fade'])+ previous_samples = np.ascontiguousarray(tail.T)+ samples = np.ascontiguousarray(head.T)+ apply_audio_lead_in(previous_samples, samples, lead)+ yield previous_samples.T.copy()+ yield samples.T.copy()+ consumed = lead['fade']+ finally:+ if reader is not None:+ reader.close()++ @classmethod+ def native_chunks(cls, parts, cancelled=None, lead_store=None):+ """The export's exact native samples, also used by editor playback."""+ reader = cls.__new__(cls)+ reader.parts, reader.cancelled, reader.lead_store = parts, cancelled, lead_store+ return reader._native_chunks()++ def _joined_chunks(self):+ import av+ resampler = av.AudioResampler(format='fltp', layout='stereo', rate=SAMPLE_RATE)+ native_position, output_position = 0, -self.parts[0].get('skip_output', 0)+ chunks = self._native_chunks()+ try:+ for data in chunks:+ _check(self.cancelled)+ frame = _audio_frame(data, format='fltp', layout='stereo')+ frame.sample_rate = SPLICE_RATE+ frame.pts, frame.time_base = native_position, Fraction(1, SPLICE_RATE)+ native_position += data.shape[1]+ for item in resampler.resample(frame):+ yield output_position, item.to_ndarray()+ output_position += item.samples+ for item in resampler.resample(None):+ _check(self.cancelled)+ yield output_position, item.to_ndarray()+ output_position += item.samples+ finally:+ chunks.close()++ def close(self):+ if self.chunks is not None:+ self.chunks.close()+ self.chunk = self.chunks = None++def _checked_target(target, root=None):from .comfy_editor import _safetarget = Path(target).absolute()@@ -380,9 +599,10 @@ def render(project: dict, resolve, target: Path, *, progress=None, cancelled=Non"""Render exactly the saved timeline, publishing atomically after encoder flush.Resolve returns local Paths, never HTTP URLs. Memory contains at most one- video decoder, one main audio decoder per track, and one separate extra- reader at a time. Reverse RGB windows and crossfade buffers are bounded;- duration changes disk/time usage, not resident media storage.+ video decoder, at most two native audio decoders per audio track, small+ seam windows, one separate extra reader at a time and the current output+ frame. Reverse RGB windows and crossfade buffers are bounded; duration+ changes disk/time usage, not resident media storage.Raises ExportError(reason) or ExportCancelled and removes owned partials.Existing destinations are refused and never removed."""@@ -425,8 +645,21 @@ def render(project: dict, resolve, target: Path, *, progress=None, cancelled=Nonaudio_tracks = {track['id']: track for track in project['tracks'] if track['kind'] == 'audio'}envelopes = {key: _CrossfadeReads(track, resolved.__getitem__, cancelled)for key, track in audio_tracks.items()}++ def joinable(track):+ # A continuation joins its sound only where nothing else shapes that seam:+ # no speed or reverse, no fade or crossfade there, and both parts audible.+ row, reads = audio_tracks[track], envelopes[track]+ return lambda left, right: not (+ audio_changed(left) or audio_changed(right) or left.get('fade_out') or right.get('fade_in')+ or left['id'] in reads.outgoing or right['id'] in reads.incoming+ or not clip_audible(left, row, project['tracks']) or not clip_audible(right, row, project['tracks']))with ExitStack() as readers, av.open(str(temporary), 'w', format=settings.container,options=settings.container_options) as output:+ lead_store = _LeadStore(target.parent)+ readers.callback(lead_store.close)+ chains = {track: _audio_chains(clips, resolved.__getitem__, cancelled, lead_store, joinable(track))+ for track, clips in tracks.items() if track != 'v1'}video = Noneif settings.only != 'sound':video = output.add_stream('libx264', rate=FPS)@@ -439,7 +672,7 @@ def render(project: dict, resolve, target: Path, *, progress=None, cancelled=Nonaudio.codec_context.time_base = Fraction(1, SAMPLE_RATE)audio.codec_context.thread_count = 1indices = {track: 0 for track in tracks}- active, decoders = {}, {}+ active, decoders, decoder_keys = {}, {}, {}readers.callback(lambda: [decoder.close() for decoder in decoders.values()])black = np.zeros((height, width, 3), dtype=np.uint8) if video is not None else Nonewritten = 0@@ -453,15 +686,20 @@ def render(project: dict, resolve, target: Path, *, progress=None, cancelled=Nonindices[track] = indexclip = clips[index] if index < len(clips) and clips[index]['start'] <= number else Noneif clip is not active.get(track):- if decoders.get(track):+ chain = chains.get(track, {}).get(clip['id']) if clip is not None else None+ key = chain if chain is not None else clip+ changed = key is not decoder_keys.get(track)+ if changed and decoders.get(track):decoders.pop(track).close()active[track] = clip- if clip is not None and (track == 'v1' or clip_audible(clip, audio_tracks[track], project['tracks'])):+ decoder_keys[track] = key+ if changed and clip is not None and (track == 'v1' or clip_audible(clip, audio_tracks[track], project['tracks'])):path = _media(resolved.__getitem__, clip, 'video' if track == 'v1' else 'audio')if path is not None:decoder = (VideoReader(path, clip, width, height, cancelled) if track == 'v1' and speed_changed(clip)- else AudioReader(path, clip, cancelled) if track != 'v1' and audio_changed(clip)else _VideoReader(path, clip['in'], width, height, cancelled, clip) if track == 'v1'+ else AudioReader(path, clip, cancelled) if audio_changed(clip)+ else _JoinedAudioReader(chain, cancelled, lead_store) if chain is not Noneelse _AudioReader(path, _audio_start(clip), cancelled))decoders[track] = decoderif video is not None and number >= settings.start:@@ -485,7 +723,10 @@ def render(project: dict, resolve, target: Path, *, progress=None, cancelled=Nontrack_block = np.zeros_like(mixed)if clip is not None and track in decoders:local = (number - clip['start']) * SAMPLES_PER_FRAME- samples = decoders[track].samples(_audio_start(clip) + local, SAMPLES_PER_FRAME)+ chain = chains[track].get(clip['id'])+ start = ((number - chain[0]['clip']['start']) * SAMPLES_PER_FRAME if chain is not None+ else _audio_start(clip) + local)+ samples = decoders[track].samples(start, SAMPLES_PER_FRAME)positions = local + np.arange(SAMPLES_PER_FRAME)clips = tracks[track]; index = indices[track]previous = clips[index - 1] if index else Nonediff --git a/freevideo_engine/editor_playback.py b/freevideo_engine/editor_playback.pynew file mode 100644index 0000000..dcb15b7--- /dev/null+++ b/freevideo_engine/editor_playback.py@@ -0,0 +1,295 @@+"""Bounded, content-addressed native audio for the local editor player."""+from contextlib import closing, contextmanager, suppress+import hashlib+from fractions import Fraction+import json+import math+import os+from pathlib import Path+import re+import tempfile+import threading+import time+from urllib.parse import urlencode++from . import comfy_editor as editor+from . import editor_export as export++MAX_FILES = 64+MAX_BYTES = 256 * 1024 * 1024+_LOCK = threading.Lock() # One CPU preparation; never one thread per decoder.+_KEY = re.compile(r'[0-9a-f]{64}')+++def _folder(root, identity):+ if identity is None:+ return editor._editor_path(root, 'playback-audio')+ parent = editor._project_path(root, identity).parent+ return editor._safe(root, (parent / 'playback-audio').relative_to(Path(root).resolve()).as_posix())+++def audio_path(root, identity, key):+ if not isinstance(key, str) or not _KEY.fullmatch(key):+ raise ValueError('Invalid playback key')+ folder = _folder(root, identity)+ return editor._safe(root, (folder / (key + '.wav')).relative_to(Path(root).resolve()).as_posix())+++def _files(root):+ base = editor._editor_path(root, 'projects')+ candidates = list(base.glob('*/playback-audio/*.wav'))+ candidates += list(_folder(root, None).glob('*.wav'))+ # Temporary WAVs are not published cache entries.+ return [editor._safe(root, path.relative_to(Path(root).resolve()).as_posix())+ for path in candidates if _KEY.fullmatch(path.stem)]+++def _project_exists(root, identity):+ if identity is not None and not editor._project_path(root, identity).is_file():+ raise editor.MissingProject('Playback project no longer exists')+++@contextmanager+def _guard(root, cancelled=None):+ # Both threads and service processes serialize publication, eviction and leases.+ while not _LOCK.acquire(timeout=.05):+ export._check(cancelled)+ try:+ base = editor._editor_path(root, '')+ base.mkdir(parents=True, exist_ok=True)+ path = editor._editor_path(root, '.playback.lock')+ with path.open('a+b') as handle:+ if os.name == 'nt':+ import msvcrt+ if handle.tell() == 0:+ handle.write(b'0'); handle.flush()+ def lock():+ handle.seek(0); msvcrt.locking(handle.fileno(), msvcrt.LK_NBLCK, 1)+ def unlock():+ handle.seek(0); msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)+ else:+ import fcntl+ def lock():+ fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)+ def unlock():+ fcntl.flock(handle.fileno(), fcntl.LOCK_UN)+ while True:+ export._check(cancelled)+ try:+ lock(); break+ except (BlockingIOError, PermissionError):+ time.sleep(.05)+ try:+ yield+ finally:+ unlock()+ finally:+ _LOCK.release()+++def _lease_path(root, path):+ return editor._safe(root, path.with_suffix('.lease').relative_to(Path(root).resolve()).as_posix())+++def lease_audio(root, identity, key):+ """Pin the file for this read and subsequent Range requests, with an expiry."""+ with _guard(root):+ path = audio_path(root, identity, key)+ size = path.stat().st_size+ os.utime(path, None)+ lease = _lease_path(root, path)+ lease.touch()+ # At least two minutes, or the complete native playback plus one minute.+ expiry = time.time() + max(120, size / (export.SPLICE_RATE * 8) + 60)+ os.utime(lease, (expiry, expiry))+ return path+++def _reserve(root, size=0, count=0, protected=()):+ if size > MAX_BYTES or count > MAX_FILES:+ return False+ files = sorted(_files(root), key=lambda p: (p.stat().st_mtime_ns, p.name))+ total, remaining = sum(path.stat().st_size for path in files), len(files)+ for path in files:+ if remaining + count <= MAX_FILES and total + size <= MAX_BYTES:+ return True+ lease = _lease_path(root, path)+ if path in protected or (lease.exists() and lease.stat().st_mtime > time.time()):+ continue+ try:+ length = path.stat().st_size+ path.unlink(missing_ok=True)+ except OSError:+ continue # A platform may forbid deleting an open media file.+ total -= length; remaining -= 1+ with suppress(OSError):+ lease.unlink(missing_ok=True)+ return remaining + count <= MAX_FILES and total + size <= MAX_BYTES+++def _prune(root):+ return _reserve(root)+++def _reap_temporary(root):+ # The process lock proves that no participating writer is still active.+ folders = list(editor._editor_path(root, 'projects').glob('*/playback-audio'))+ folders.append(_folder(root, None))+ for folder in folders:+ for path in folder.glob('.preparing-*.wav'):+ path = editor._safe(root, path.relative_to(Path(root).resolve()).as_posix())+ with suppress(OSError):+ path.unlink(missing_ok=True)+++def _audio_size(parts):+ duration = Fraction(sum(p['clip']['frames'] for p in parts), editor.FPS)+ offset = Fraction(parts[0].get('skip_output', 0), export.SAMPLE_RATE)+ count = math.ceil((duration + offset) * export.SPLICE_RATE)+ return max(count, sum(part['count'] for part in parts)) * 8 + 128+++def _fingerprint(path, cancelled):+ digest = hashlib.sha256()+ with path.open('rb') as stream:+ while True:+ export._check(cancelled)+ data = stream.read(1024 * 1024)+ if not data:+ return digest.hexdigest()+ digest.update(data)+++def _write_audio(path, parts, lead_store, cancelled):+ """Float PCM avoids quantization; retain the export's trim phase prefix."""+ import av+ import numpy as np+ temporary = None+ try:+ with tempfile.NamedTemporaryFile(prefix='.preparing-', suffix='.wav', dir=path.parent, delete=False) as file:+ temporary = Path(file.name)+ # The native clock includes a small prefix for trimmed first clips.+ duration = Fraction(sum(p['clip']['frames'] for p in parts), editor.FPS)+ offset = Fraction(parts[0].get('skip_output', 0), export.SAMPLE_RATE)+ count = math.ceil((duration + offset) * export.SPLICE_RATE)+ if _audio_size(parts) > MAX_BYTES:+ raise ValueError('Playback chain exceeds cache capacity')+ with av.open(str(temporary), 'w', format='wav') as output:+ sound = output.add_stream('pcm_f32le', rate=export.SPLICE_RATE)+ sound.layout = 'stereo'+ written = 0++ def emit(data):+ nonlocal written+ export._check(cancelled)+ data = np.ascontiguousarray(data.T).reshape(1, -1)+ frame = av.AudioFrame.from_ndarray(data, format='flt', layout='stereo')+ frame.sample_rate = export.SPLICE_RATE+ for packet in sound.encode(frame):+ output.mux(packet)+ written += frame.samples++ with closing(export._JoinedAudioReader.native_chunks(parts, cancelled, lead_store)) as chunks:+ for data in chunks:+ # Keep the whole native tail, including any samples beyond+ # the selected timeline, just as the export's resampler does.+ emit(data)+ while written < count:+ emit(np.zeros((2, min(8192, count - written)), np.float32))+ for packet in sound.encode(None):+ output.mux(packet)+ export._check(cancelled)+ with temporary.open('r+b') as file:+ os.fsync(file.fileno())+ if temporary.stat().st_size > _audio_size(parts):+ raise ValueError('Playback audio exceeded its reserved size')+ temporary.replace(path)+ finally:+ if temporary is not None:+ with suppress(OSError):+ temporary.unlink(missing_ok=True)+++def prepare(root, record, cancelled=None):+ """Return each eligible track run; a failed preparation keeps legacy audio."""+ import av+ record = editor.validate(record)+ identity = record['id']+ _project_exists(root, identity)+ with _guard(root, cancelled):+ export._check(cancelled)+ _project_exists(root, identity)+ _reap_temporary(root)+ _prune(root)+ folder = _folder(root, identity)+ # Never recreate the parent of a deleted saved project.+ folder.mkdir(parents=identity is None, exist_ok=True)+ protected = set()+ resolved, fingerprints, result = {}, {}, []++ def resolve(key):+ if key not in resolved:+ path = editor.media_path(root, key)+ resolved[key] = dict(audio=path)+ return resolved[key]++ with closing(export._LeadStore(folder)) as leads, av.logging.Capture(local=True):+ for track in record['tracks'][1:]:+ try:+ planned = export._audio_chains(track['clips'], resolve, cancelled, leads)+ except (export.ExportError, OSError, ValueError, av.FFmpegError):+ continue+ seen = set()+ for parts in planned.values():+ if id(parts) in seen:+ continue+ seen.add(id(parts))+ start = parts[0]['clip']['start']+ end = parts[-1]['clip']['start'] + parts[-1]['clip']['frames']+ row = dict(track=track['id'], clips=[p['clip']['id'] for p in parts],+ start=start, frames=end - start, duration=(end - start) / editor.FPS,+ offset=parts[0].get('skip_output', 0) / export.SAMPLE_RATE,+ ready=False, audio=None)+ created = False+ path = None+ try:+ digest = hashlib.sha256(b'editor-native-float-wav-v1')+ for part in parts:+ export._check(cancelled)+ media = part['path']+ if media not in fingerprints:+ fingerprints[media] = _fingerprint(media, cancelled)+ digest.update(fingerprints[media].encode())+ digest.update(json.dumps(part['clip'], sort_keys=True, separators=(',', ':')).encode())+ if 'lead_offset' in part:+ digest.update(leads.load(part['lead_offset'])['samples'].tobytes())+ key = digest.hexdigest()+ path = audio_path(root, identity, key)+ if not path.exists():+ if not _reserve(root, _audio_size(parts), 1, protected):+ raise ValueError('Playback cache capacity is in use')+ _project_exists(root, identity)+ _write_audio(path, parts, leads, cancelled)+ created = True+ # Content changes during planning/decoding must not publish stale audio.+ for media in {p['path'] for p in parts}:+ if _fingerprint(media, cancelled) != fingerprints[media]:+ raise ValueError('Playback source changed')+ export._check(cancelled)+ _project_exists(root, identity)+ os.utime(path, None)+ protected.add(path)+ row.update(key=key, ready=True, audio='/freevideo/editor/audio-chain?' ++ urlencode(dict(key=key, **({'id': identity} if identity else {}))))+ except BaseException as error:+ if created and path is not None:+ with suppress(OSError):+ path.unlink(missing_ok=True)+ if isinstance(error, (export.ExportCancelled, KeyboardInterrupt, SystemExit)):+ raise+ result.append(row)+ _prune(root)+ for row in result:+ if row['ready'] and not audio_path(root, identity, row['key']).exists():+ row.update(ready=False, audio=None)+ return dict(chains=result)diff --git a/web/editor.js b/web/editor.jsindex a000ce8..a3d9290 100644--- a/web/editor.js+++ b/web/editor.js@@ -83,7 +83,7 @@ export function suspendCanvasPointer(canvas) {};}-// `components` replaces the optional progress module (see loadEditorComponents).+// `components` replaces the optional progress module (see loadEditorComponents); tests also pass their generation stand-in here.export function openEditor({api, app, from = null, panel = {}, components: given = undefined, onView = view => viewChanged(view)}) {if (opened) { opened.element.focus(); return opened; }const t = (en, zh) => String(language()).toLowerCase().startsWith('zh') ? zh : en;@@ -191,7 +191,7 @@ export function openEditor({api, app, from = null, panel = {}, components: given}notify(t('Could not complete. Try again.', '没有完成,请重试'));}- const store = createEditorStore(api, {t, notify, onGenerationReady: ready => {+ const store = createEditorStore(api, {t, notify, standIn: given?.generationStandIn, onGenerationReady: ready => {if (disposed) return;genHost.hidden = !ready; element.dataset.generationReady = String(ready);tracks?.refresh?.(); genbar?.update(mostRecentJob ? barJob(jobStatuses.get(mostRecentJob)) : null);@@ -207,7 +207,7 @@ export function openEditor({api, app, from = null, panel = {}, components: given}, {onStatus: () => {if (!queue.dirty) { discardOnSwitch = false; saveWarning.hidden = true; }}});- const player = createEditorPlayer(preview, transport, {state, sources: store.sources, api, t, error, readAudioSamples: panel.readAudioSamples || readSpeedAudioSamples, preservePreview: () => initializing});+ const player = createEditorPlayer(preview, transport, {state, sources: store.sources, api, t, error, readAudioSamples: panel.readAudioSamples || readSpeedAudioSamples, preservePreview: () => initializing, prepareAudio: () => !initializing});function selectionClips(selection = state.selection) {if (selection?.kind !== 'clip') return [];return state.record.tracks[0].clips.filter(clip => selection.ids.includes(clip.id) || selection.ids.includes(clip.link));@@ -777,7 +777,8 @@ export function openEditor({api, app, from = null, panel = {}, components: givenlibrary = createEditorLibrary(libraryHost, {store, t, actions, state});opened = handle; document.body.append(element); element.showModal(); viewChanged('editor'); navigation.querySelector('[data-view=editor]').focus();handle.ready = (async () => {- const componentsReady = Promise.allSettled([import('./editor_tracks.js'), given || loadEditorComponents()]);+ const progressComponents = given && Object.hasOwn(given, 'generationStandIn') && Object.keys(given).length === 1 ? null : given;+ const componentsReady = Promise.allSettled([import('./editor_tracks.js'), progressComponents || loadEditorComponents()]);await editorStyles; if (closing || disposed) return;let record = null, key = null;try {@@ -808,7 +809,7 @@ export function openEditor({api, app, from = null, panel = {}, components: givenif (from?.work && !state.record.id) queue.enqueue(state.record);} catch (value) { error(value); }if (closing || disposed) return;- initializing = false; savedContent = content(state.record);+ initializing = false; savedContent = content(state.record); player.refresh();genHost.inert = false; genHost.classList.remove('fv-ed-pending');updateTop(); updateTransport();const [trackResult, componentResult] = await componentsReady; if (closing || disposed) return;@@ -851,7 +852,7 @@ export function openEditor({api, app, from = null, panel = {}, components: giventitle.disabled = false; genHost.inert = toolbar.inert = false;tracksHost.inert = !tracks;for (const host of [tracksHost, genHost, toolbar]) host.classList.remove('fv-ed-pending');- if (!closing && !disposed) { updateTop(); updateTransport(); }+ if (!closing && !disposed) { player.refresh(); updateTop(); updateTransport(); }});updateTop(); return handle;}diff --git a/web/editor_player.js b/web/editor_player.jsindex ea85cc0..c310839 100644--- a/web/editor_player.js+++ b/web/editor_player.js@@ -16,7 +16,17 @@ export const transportTime = frames => {const seconds = Math.floor(Math.max(0, frames) / 24);return `${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, '0')}`;};-export function createEditorPlayer(host, transport, {state, sources, api, t, error = () => {}, readAudioSamples = null, preservePreview = () => false}) {++// Only changes to playable audio ask the server again; transport ticks never do.+export const playbackAudioSignature = record => JSON.stringify([record.id, record.tracks.filter(t => t.kind === 'audio').map(track =>+ [track.id, track.clips.map(c => [c.id, c.source, c.start, c.frames, c.in, c.length, c.volume, c.splice])])]);+export function selectAudioChain(chains, track, clip, position, volumePreview = new Map()) {+ const chain = chains.find(c => c.ready && c.audio && c.track === track && c.clips.includes(clip?.id)+ && position >= c.start && position < c.start + c.frames+ && !c.clips.some(id => volumePreview.has(id) && volumePreview.get(id) !== 1));+ return chain ? {chain, seconds: (position - chain.start) / 24 + (chain.offset || 0)} : null;+}+export function createEditorPlayer(host, transport, {state, sources, api, t, error = () => {}, readAudioSamples = null, preservePreview = () => false, prepareAudio = () => true}) {const frame = el('div', 'fv-ed-picture'); frame.setAttribute('aria-label', t('Video preview', '视频预览'));const empty = el('div', 'fv-ed-empty-preview'), pictureIcon = document.createElementNS('http://www.w3.org/2000/svg', 'svg');pictureIcon.setAttribute('viewBox', '0 0 24 24'); pictureIcon.setAttribute('aria-hidden', 'true');@@ -29,13 +39,18 @@ export function createEditorPlayer(host, transport, {state, sources, api, t, errcloseIcon.setAttribute('viewBox', '0 0 16 16'); closeIcon.setAttribute('aria-hidden', 'true'); closePath.setAttribute('d', 'm4 4 8 8M12 4l-8 8'); closeIcon.append(closePath); closePreview.append(closeIcon); frame.append(closePreview);const videos = [el('video'), el('video')]; videos.forEach(video => { video.playsInline = true; video.preload = 'auto'; video.controls = false; video.setAttribute('aria-hidden', 'true'); frame.append(video); });const audio = [el('audio'), el('audio')]; audio.forEach(value => { value.preload = 'auto'; frame.append(value); });+ const chainAudio = new Map(); // Separate players keep the other track's media slot stable.+ const allMedia = () => [...videos, ...audio, ...chainAudio.values()];const pictureGuide = createPictureGuide(host, frame, {state, t});const pictureEdit = pictureSession(state, t);const picturePreview = createPreviewPicture(host, frame, {state, t});const playButton = el('button', 'fv-ed-play'); playButton.type = 'button'; playButton.title = t('Space', '空格');const time = el('span', 'fv-ed-time'); time.setAttribute('aria-live', 'off'); transport.append(playButton, time);let active = 0, clipId = null, playing = false, disposed = false, raf = null, clockStart = 0, frameStart = 0, ticking = false, preview = null, previewSize = null, previewProject = null;- let audioContext = null, textRenderer = null;+ let audioContext = null, textRenderer = null, chains = [], chainSignature = null, chainRequest = null, chainEpoch = 0;+ const failedChains = new Set(), entries = new Map();+ let seekGeneration = 0;+ const chainSeconds = (chain, position) => Math.max(0, (position - chain.start) / 24 + (chain.offset || 0));const playback = createPlaybackClock();const gains = new WeakMap(), volumePreview = new Map();const audioPreview = createAudioPreview({state, sources, api, volumePreview, readSamples: readAudioSamples, error});@@ -63,10 +78,133 @@ export function createEditorPlayer(host, transport, {state, sources, api, t, err}if (running) { if (media.paused) media.play().catch(() => {}); } else media.pause();}- function stopMedia(media) { media.pause(); media._editorRunning = false; }- for (const media of [...videos, ...audio]) {+ function stopMedia(media) { media.pause(); media._editorRunning = false; delete media.dataset.audioChain; }+ function metadataHandler(media) {media.onloadedmetadata = () => { if (disposed) return; try { media.currentTime = media._editorTime || 0; } catch {} if (media._editorRunning) media.play().catch(() => {}); };}+ [...videos, ...audio].forEach(metadataHandler);+ function failChain(media) {+ if (disposed || media._chainEpoch !== chainEpoch) return;+ clearTimeout(media._startTimer);+ failedChains.add(media._chain.key);+ stopMedia(media); media.muted = true; media._attempt = null;+ render();+ }+ function chainMedia(chain) {+ if (!chainAudio.has(chain.key)) {+ const media = el('audio'); media.preload = 'auto'; media.muted = true;+ media._chain = chain; media._chainEpoch = chainEpoch;+ media.dataset.preparedChain = chain.key;+ media.dataset.source = mediaURL(api, chain.audio); media.src = media.dataset.source;+ const prepared = () => {+ if (disposed || media._chainEpoch !== chainEpoch) return;+ if (!media._editorRunning && !media.seeking) {+ const target = chainSeconds(chain, state.playhead);+ if (Math.abs(media.currentTime - target) > .001) {+ try { media.currentTime = target; } catch {}+ }+ }+ };+ media.onloadedmetadata = prepared;+ media.onerror = () => failChain(media);+ media.onwaiting = media.onstalled = () => {+ // Once selected, a buffer underrun restores the original path.+ if (media._editorRunning) failChain(media);+ };+ chainAudio.set(chain.key, media); frame.append(media); media.load();+ }+ return chainAudio.get(chain.key);+ }+ function resetEntries() {+ seekGeneration++; entries.clear();+ for (const media of chainAudio.values()) {+ clearTimeout(media._startTimer);+ stopMedia(media); media.muted = true; media.playbackRate = 1; media._attempt = null;+ const target = chainSeconds(media._chain, state.playhead);+ if (media.readyState >= 1 && Math.abs(media.currentTime - target) > .001) {+ try { media.currentTime = target; } catch {}+ }+ }+ }+ function removeChains() {+ resetEntries();+ for (const media of chainAudio.values()) {+ media.onloadedmetadata = media.onerror = media.onwaiting = media.onstalled = null;+ media.removeAttribute('src'); media.load(); media.remove();+ }+ chainAudio.clear();+ }+ function useChain(joined, track) {+ if (!joined) { entries.delete(track); return null; }+ const {chain, seconds} = joined, media = chainMedia(chain);+ if (!playing) {+ stopMedia(media); media.muted = true; media._editorTime = seconds;+ if (media.readyState >= 1 && !media.seeking && Math.abs(media.currentTime - seconds) > .001) {+ try { media.currentTime = seconds; } catch {}+ }+ // Paused positioning is preparation, never a sound takeover.+ media.dataset.audioChain = chain.key;+ return null;+ }+ let entry = entries.get(track);+ if (!entry || entry.key !== chain.key) {+ entry = {key: chain.key, mode: 'legacy', epoch: chainEpoch, generation: seekGeneration};+ entries.set(track, entry);+ // Lock this passage to originals if data or the seek target is not ready.+ if (media.readyState < 3 || media.seeking || Math.abs(media.currentTime - seconds) > .08) return null;+ entry.mode = 'starting'; media._editorRunning = true; media.muted = true;+ media.dataset.audioChain = chain.key; media._attempt = entry;+ const url = media.dataset.source;+ const current = () => !disposed && playing && entries.get(track) === entry+ && entry.epoch === chainEpoch && entry.generation === seekGeneration+ && media._attempt === entry && media.dataset.source === url;+ const rejected = () => { if (current()) failChain(media); };+ media._startTimer = setTimeout(rejected, 1500);+ try {+ Promise.resolve(media.play()).then(() => {+ if (!current()) return;+ const target = chainSeconds(chain, state.playhead);+ if (media.paused || media.seeking || media.readyState < 3 || Math.abs(media.currentTime - target) > .08) {+ rejected(); return;+ }+ clearTimeout(media._startTimer); entry.mode = 'active'; render();+ }, rejected);+ } catch { rejected(); }+ }+ if (entry.mode !== 'active') return null;+ if (media.paused || media.seeking || media.readyState < 3) { failChain(media); return null; }+ const drift = seconds - media.currentTime;+ // 80 ms triggers gentle clock correction, not a bound on presented A/V.+ // Explicit user seeks reset the entry; normal ticks do not repeatedly seek.+ if (Math.abs(drift) > .25) { failChain(media); return null; }+ media.playbackRate = Math.abs(drift) > .08 ? (drift > 0 ? 1.03 : .97) : 1;+ media.muted = false; media.dataset.audioChain = chain.key;+ return joined;+ }+ function refreshChains() {+ if (!prepareAudio()) return;+ const signature = playbackAudioSignature(state.record);+ if (chainSignature === signature) return;+ chainSignature = signature; chains = []; failedChains.clear(); chainRequest?.abort(); removeChains();+ const epoch = ++chainEpoch;+ if (typeof api.fetchApi !== 'function') return;+ chainRequest = new AbortController();+ // Send the current edit, including unsaved trims; do not wait for autosave.+ api.fetchApi('/freevideo/editor/audio-chains', {method: 'POST', headers: {'Content-Type': 'application/json'},+ body: JSON.stringify({project: model.serialize(state.record)}), signal: chainRequest.signal})+ .then(response => response.ok ? response.json() : null).then(value => {+ if (disposed || epoch !== chainEpoch) return;+ chains = Array.isArray(value?.chains) ? value.chains : [];+ // Preload independently of selection; a late response never takes+ // over a passage which started with the original sound.+ for (const chain of chains) if (chain.ready && chain.audio) {+ chainMedia(chain);+ if (playing && state.playhead >= chain.start && state.playhead < chain.start + chain.frames)+ entries.set(chain.track, {key: chain.key, mode: 'legacy'});+ }+ render();+ }).catch(() => { /* Missing route, cancellation or preparation failure: ordinary playback. */ });+ }function located(record, position) {// The model owns which content covers the frame. Normalize its query rows.const value = model.at(record, position);@@ -82,6 +220,7 @@ export function createEditorPlayer(host, transport, {state, sources, api, t, err}function render() {if (disposed) return;+ refreshChains();// The total is what export writes (picture and sound); text past it is not exported.const record = state.record, position = state.playhead, total = model.exportFrames(record);const hasContent = record.tracks.some(track => track.clips.some(clip => clip.source || isText(clip)));@@ -110,7 +249,16 @@ export function createEditorPlayer(host, transport, {state, sources, api, t, errclipId = clip.id;}const linked = hasPicture ? [...map.values()].find(row => row.clip.id === clip.link) : null;- const processedAudio = audioPreview.render({record, position, playing: playing && playback.rate > 0, playbackRate: playback.rate}), separate = processedAudio || !!linked?.clip.splice || !hasPicture || separateSpeedAudio(linked?.clip);+ const processedAudio = audioPreview.render({record, position, playing: playing && playback.rate > 0, playbackRate: playback.rate});+ // The joined sound is the plain forward path only: sound edits, changed speed and+ // backward playback keep their own routes and the original sound.+ const plainSpeed = id => !separateSpeedAudio(model.find(record, id));+ const availableChains = processedAudio || playback.rate !== 1 ? [] : chains.filter(c => !failedChains.has(c.key) && c.clips.every(plainSpeed));+ const selected = new Map([...map].filter(([track]) => track !== 'v1').map(([track, row]) =>+ [track, useChain(selectAudioChain(availableChains, track, row.clip, position, volumePreview), track)]));+ const linkedChain = linked && [...selected.values()].some(value => value?.chain.clips.includes(linked.clip.id));+ const originalSeparate = processedAudio || !!linked?.clip.splice || !hasPicture || separateSpeedAudio(linked?.clip);+ const separate = originalSeparate || linkedChain;if (hasPicture) {const video = videos[active], speedPlayback = previewSpeed(video, clip, playing, linked?.clip); video.muted = !linked || separate || playback.rate < 0 || speedPlayback.muted;seekMedia(video, mediaURL(api, source.video), (videoRow.frame + (playing && playback.rate > 0 ? 0 : .5)) / 24, speedPlayback.running && map.get('v1')?.clip.id === clip.id, clipVolume(linked?.clip));@@ -118,16 +266,33 @@ export function createEditorPlayer(host, transport, {state, sources, api, t, err}picturePreview.update({clip: hasPicture ? clip : null, size: hasPicture && clipPictureSize(clip, sources), video: videos[active], preview: !!preview, playing});let slot = 0;+ const usedChains = new Set();for (const [track, row] of map) {if (processedAudio) break;- if (isText(row.clip) || track === 'v1' || (hasPicture && row.clip.link === clip.id && !separate)) continue;+ if (isText(row.clip) || track === 'v1') continue;const metadata = sources.get(sourceKey(row.clip.source));- if (!metadata || metadata.missing || slot >= audio.length) continue;+ if (!metadata || metadata.missing) continue;+ const carriedByVideo = hasPicture && row.clip.link === clip.id && !originalSeparate;+ const joined = selected.get(track);+ if (joined) {+ usedChains.add(joined.chain.key);+ // Reserve precisely the slot this row used before joining.+ if (!carriedByVideo && metadata.audio && slot < audio.length) stopMedia(audio[slot++]);+ continue;+ }+ if (carriedByVideo || slot >= audio.length) continue;const url = mediaURL(api, metadata.audio); if (!url) continue;- const sound = audio[slot++], playback = previewSpeed(sound, row.clip, playing); sound.muted = playback.muted;- seekMedia(sound, url, audioSeconds(row.clip, speedAudioFrame(row.clip, position - row.clip.start)), playback.running, clipVolume(row.clip));+ const media = audio[slot++], speed = previewSpeed(media, row.clip, playing); delete media.dataset.audioChain; media.muted = speed.muted;+ seekMedia(media, url, audioSeconds(row.clip, speedAudioFrame(row.clip, shown - row.clip.start)), speed.running, clipVolume(row.clip));}while (slot < audio.length) stopMedia(audio[slot++]);+ for (const [key, media] of chainAudio) if (!usedChains.has(key)) {+ if (media._attempt && entries.get(media._chain.track) === media._attempt && media._attempt.mode === 'starting') continue;+ const pausedSelection = !playing && availableChains.some(c => c.key === key+ && selectAudioChain([c], c.track, map.get(c.track)?.clip, position, volumePreview));+ stopMedia(media); media.muted = true;+ if (pausedSelection) media.dataset.audioChain = key;+ }const next = record.tracks[0].clips.find(value => value.start >= (clip ? clip.start + clip.frames : position) && value.source);const metadata = next && sources.get(sourceKey(next.source));if (metadata?.video && !metadata.missing) {@@ -140,7 +305,9 @@ export function createEditorPlayer(host, transport, {state, sources, api, t, errif (!playing || disposed) return;const total = model.exportFrames(state.record), {frame: position, stop} = playback.advance(now, total);const target = stop && playback.rate > 0 && !playback.range ? Math.max(0, total - 1) : position;- ticking = true; state.seek(target); ticking = false; render();+ // A loop that starts over is a jump like a user's: the joined sound starts again from there.+ // A loop that starts over is a jump like a user's: the joined sound and the clock start again from there.+ ticking = (target - state.playhead) * playback.rate >= 0; state.seek(target); ticking = false; render();if (stop) { pause(); return; }raf = requestAnimationFrame(tick);}@@ -152,16 +319,17 @@ export function createEditorPlayer(host, transport, {state, sources, api, t, errclearPreview();const total = model.exportFrames(state.record), restart = !playback.range && !playback.loop && playback.rate > 0 && state.playhead >= Math.max(0, total - 1);state.seek(playback.begin(restart ? 0 : state.playhead, total));- playing = true; clockStart = performance.now(); frameStart = state.playhead; render(); raf = requestAnimationFrame(tick);+ resetEntries(); playing = true; clockStart = performance.now(); frameStart = state.playhead; render(); raf = requestAnimationFrame(tick);playback.reset(clockStart, frameStart);}- function pause() { playing = false; playback.rate = 1; cancelAnimationFrame(raf); [...videos, ...audio].forEach(stopMedia); render(); }+ function pause() { playing = false; playback.rate = 1; resetEntries(); cancelAnimationFrame(raf); allMedia().forEach(stopMedia); render(); }playButton.onclick = () => playing ? pause() : play();const unsubscribe = state.subscribe(event => {if (event.type === 'selection') { if (pictureEdit.panelOpen && pictureEdit.selected()) clearPreview(); render(); return; }if (event.type !== 'playhead' && event.type !== 'record') return;if (preview && preservePreview()) previewProject = pictureLayout(state.record);else if (event.type === 'playhead' || previewProject !== pictureLayout(state.record)) clearPreview();+ if (!ticking) resetEntries();if (playing && !ticking) { clockStart = performance.now(); frameStart = state.playhead; }if (playing && !ticking) playback.reset(clockStart, frameStart);render();@@ -192,7 +360,7 @@ export function createEditorPlayer(host, transport, {state, sources, api, t, errpreview.onended = () => { clearPreview(); render(); };preview.src = mediaURL(api, metadata.video || metadata.audio); frame.append(preview); closePreview.hidden = false; render(); preview.play().catch(() => {});},- dispose() { disposed = true; playing = false; cancelAnimationFrame(raf); unsubscribe(); stopPictureEdit(); clearPreview(); audioPreview.dispose();- [...videos, ...audio].forEach(media => { media.pause(); media.onloadedmetadata = null; media.removeAttribute('src'); delete media.dataset.source; media.load(); media.remove(); }); playButton.onclick = closePreview.onclick = null; picturePreview.dispose(); pictureGuide.dispose(); audioContext?.close().catch(() => {}); },+ dispose() { disposed = true; playing = false; chainRequest?.abort(); removeChains(); cancelAnimationFrame(raf); unsubscribe(); stopPictureEdit(); clearPreview(); audioPreview.dispose();+ allMedia().forEach(media => { media.pause(); media.onloadedmetadata = media.onerror = null; media.removeAttribute('src'); delete media.dataset.source; media.load(); media.remove(); }); playButton.onclick = closePreview.onclick = null; picturePreview.dispose(); pictureGuide.dispose(); audioContext?.close().catch(() => {}); },};}diff --git a/web/editor_store.js b/web/editor_store.jsindex 02a597e..7115957 100644--- a/web/editor_store.js+++ b/web/editor_store.js@@ -4,8 +4,6 @@ import {generationSize} from './editor_generation.js';const clockDefault = {now: () => Date.now(), setTimeout: (fn, ms) => setTimeout(fn, ms), clearTimeout: id => clearTimeout(id)};const copy = value => structuredClone(value);const memoryProjects = new Map();-const fakeJobs = new Map();-const fakeSources = new Map();const errorFor = response => Object.assign(new Error('editor_request'), {status: response.status});const post = value => ({method: 'POST', headers: {'Content-Type': 'application/json'}, body: JSON.stringify(value)});export const sourceKey = source => source ? `${source.kind}:${source.id}` : null;@@ -226,7 +224,7 @@ export function mediaURL(api, value) {return api.apiURL?.(path) || path;}-export function createEditorStore(api, {t = en => en, notify = () => {}, onGenerationReady = () => {}, clock = clockDefault, pollMs = 2000} = {}) {+export function createEditorStore(api, {t = en => en, notify = () => {}, onGenerationReady = () => {}, clock = clockDefault, pollMs = 2000, standIn: injected = null} = {}) {const sources = new Map(), sourceReads = new Map(), watchers = new Set(), pollers = new Set(), once = new Set();let recovered = null, capabilityPoll = null;let generationAvailable = true, generationProbe = null;@@ -256,55 +254,20 @@ export function createEditorStore(api, {t = en => en, notify = () => {}, onGenerconst poller = createPoller(read, deliver, {clock, interval: pollMs}); pollers.add(poller);return () => { poller.dispose(); pollers.delete(poller); };}- function fakeEnabled() { try { return localStorage.getItem('fv-editor-fake') === '1'; } catch { return false; } }function generationAbsent() {if (!generationAvailable) return;generationAvailable = false;if (!disposed) onGenerationReady(false);}- function persistFake(job) {- fakeJobs.set(job.id, copy(job));- try { localStorage.setItem('fv-editor-job:' + job.id, JSON.stringify(job)); } catch {}- }- function fakeJob(id) {- if (fakeJobs.has(id)) return fakeJobs.get(id);- try { const value = JSON.parse(localStorage.getItem('fv-editor-job:' + id)); if (value) fakeJobs.set(id, value); return value; } catch { return null; }- }- function fakeState(id) {- const job = fakeJob(id); if (!job) return null;- let elapsed = job.elapsed + (job.active ? clock.now() - job.started : 0);- let failed = false;- const blocks = job.blocks.map(block => {- const fraction = Math.max(0, Math.min(1, elapsed / 4000)); elapsed -= 4000;- const material = job.materials.find(row => (row.geometry?.frames || row.frames || 0) >= block.frames);- let state = fraction === 1 ? 'done' : fraction > 0 ? 'running' : 'pending';- if (failed || (!job.active && state !== 'done')) state = 'cancelled';- const error = !material ? 'no_material' : block.text.startsWith('!fail') ? 'gpu_memory' : null;- if (error && fraction > 0 && !failed) { state = 'failed'; failed = true; }- const output = state === 'done' ? material?.video : null;- if (output) {- const metadata = {...material.geometry, _fallback: true, video: mediaURL(api, output), audio: mediaURL(api, output),- path: output, has_video: true, has_audio: true, sample_rate: 32000, missing: false,- thumbnail: api.apiURL?.('/freevideo/library/thumbnail?' + new URLSearchParams({id: material.id}))};- fakeSources.set('generated:' + output, metadata); sources.set('generated:' + output, metadata);- }- return {...block, state, fraction: state === 'done' ? 1 : fraction, inputs: {frames: block.frames}, output,- skip_frames: block.after ? 22 : 0, skip_audio_samples: block.after ? 29333 : 0,- remaining_seconds: Math.ceil((1 - fraction) * 4), error};- });- return {id, state: failed ? 'failed' : blocks.every(b => b.state === 'done') ? 'done' : job.active ? 'running' : 'cancelled', blocks};- }- async function startFake(payload) {- const rows = await json('/freevideo/library?limit=48', undefined, {items: []});- const id = 'fake-' + (globalThis.crypto?.randomUUID?.() || clock.now() + '-' + Math.random());- persistFake({id, blocks: copy(payload.blocks), materials: rows.items || [], elapsed: 0, started: clock.now(), active: true});- return fakeState(id);- }+ // Optional adapter (or factory): startChain, owns, chain, chainAction, and+ // optional restoreSources. Production callers provide none.+ const standIn = typeof injected === 'function'+ ? injected({clock, sources, request: json, mediaURL: value => mediaURL(api, value)}) : injected;const store = {sources, cache,- get generationAvailable() { return fakeEnabled() || generationAvailable; },+ get generationAvailable() { return !!standIn || generationAvailable; },generationReady() {- if (fakeEnabled()) return Promise.resolve(true);+ if (standIn) return Promise.resolve(true);if (!generationAvailable) return Promise.resolve(false);// One bounded request per store, shared by concurrent callers. Only// an explicit 404 hides generation; outages leave the editor usable.@@ -391,7 +354,7 @@ export function createEditorStore(api, {t = en => en, notify = () => {}, onGenersourceReads.set(signature, (async () => {const value = await json('/freevideo/editor/sources?' + query, undefined, {sources: {}});cache(value.sources);- for (const key of missing) if (fakeSources.has(key) && (!sources.has(key) || sources.get(key).missing)) sources.set(key, fakeSources.get(key));+ standIn?.restoreSources?.(missing);})().finally(() => sourceReads.delete(signature)));}await sourceReads.get(signature); return sources;@@ -472,26 +435,21 @@ export function createEditorStore(api, {t = en => en, notify = () => {}, onGenerread(); return fallback;},async startChain(payload) {- if (fakeEnabled()) return startFake(payload);+ if (standIn) return standIn.startChain(payload);if (!generationAvailable) return null;const response = await request(chainRoute(), post(payload));if (response.status === 404) {generationAbsent();- notice('generate', 'Generating is unavailable until you restart after updating.', '更新后重启即可生成。');+ notice('generate', 'Restart FreeVideo to generate.', '请重新启动 FreeVideo 后再生成。');return null;}if (!response.ok) throw errorFor(response);- return (await response.json()).chain;+ return (await response.json())?.chain || null;},- async chain(id) { return fakeEnabled() && id.startsWith('fake-') ? fakeState(id) : (await json(chainRoute(id)))?.chain || null; },+ async chain(id) { return standIn?.owns(id) ? standIn.chain(id) : (await json(chainRoute(id)))?.chain || null; },watchChain(id, fn) { return watch(() => store.chain(id), fn); },async chainAction(id, action) {- if (fakeEnabled() && id.startsWith('fake-')) {- const job = fakeJob(id); if (!job) return null;- if (action === 'cancel' && job.active) { job.elapsed += clock.now() - job.started; job.active = false; }- if (action === 'resume' && !job.active) { job.started = clock.now(); job.active = true; }- persistFake(job); return fakeState(id);- }+ if (standIn?.owns(id)) return standIn.chainAction(id, action);const payload = action === 'resume' && api.clientId ? {client_id: api.clientId} : {};return (await json(chainRoute(id, action), post(payload)))?.chain || null;},