Skip to content

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.py
index 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.py
index 1797513..655a34b 100644
--- a/freevideo_engine/editor_export.py
+++ b/freevideo_engine/editor_export.py
@@ -13,6 +13,7 @@ import math
import os
import re
import threading
+import tempfile
import time
import uuid
from collections import deque
@@ -22,6 +23,7 @@ from fractions import Fraction
from pathlib import Path
from .editor_frames import display_frame, frame_not_after, last_frame_end
+from .comfy_continuation import audio_lead_in, apply_audio_lead_in
from .editor_text import is_text_track, has_text_data, validate_text_project, paint_project, check_export_text, MissingGlyphs
from . import editor_export_options
from .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 av
self.container = None
try:
@@ -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_base
self.mono = len(self.stream.layout.channels) == 1
+ self.rate = rate
self.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 _safe
target = 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=Non
audio_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 = None
if settings.only != 'sound':
video = output.add_stream('libx264', rate=FPS)
@@ -439,7 +672,7 @@ def render(project: dict, resolve, target: Path, *, progress=None, cancelled=Non
audio.codec_context.time_base = Fraction(1, SAMPLE_RATE)
audio.codec_context.thread_count = 1
indices = {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 None
written = 0
@@ -453,15 +686,20 @@ def render(project: dict, resolve, target: Path, *, progress=None, cancelled=Non
indices[track] = index
clip = clips[index] if index < len(clips) and clips[index]['start'] <= number else None
if 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 None
else _AudioReader(path, _audio_start(clip), cancelled))
decoders[track] = decoder
if video is not None and number >= settings.start:
@@ -485,7 +723,10 @@ def render(project: dict, resolve, target: Path, *, progress=None, cancelled=Non
track_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 None
diff --git a/freevideo_engine/editor_playback.py b/freevideo_engine/editor_playback.py
new file mode 100644
index 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.js
index 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: given
library = 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: given
if (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: given
title.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.js
index 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, err
closeIcon.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, err
clipId = 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, err
if (!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, err
clearPreview();
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, err
preview.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.js
index 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 = () => {}, onGener
const 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 = () => {}, onGener
sourceReads.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 = () => {}, onGener
read(); 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;
},