git-subtree-dir: vendor/dumas_h3_continuum git-subtree-split: d07ed31b442d283d6a1740f875a843b9feda4c91
179 lines
8.4 KiB
Python
179 lines
8.4 KiB
Python
from __future__ import annotations
|
|
|
|
import copy
|
|
import gc
|
|
from types import SimpleNamespace
|
|
|
|
import pytest
|
|
import torch
|
|
|
|
from ComfyUI_H3_Continuum_Join import driving_audio
|
|
from ComfyUI_H3_Continuum_Join.v3 import driving_nodes
|
|
from ComfyUI_H3_Continuum_Join.v3.nodes import _apply_review_decode_scope
|
|
from ComfyUI_H3_Continuum_Join.v3.plan import (
|
|
AssemblyPlanError, REVIEW_AUDIO_PROJECTION_KEY, make_review_audio_projection,
|
|
prepare_physical_decode_entries, validate_assembly_plan,
|
|
)
|
|
from ComfyUI_H3_Continuum_Join.v3.second_pass import update_second_pass_geometry
|
|
from ComfyUI_H3_Continuum_Join.v3.file_backed_buffer import get_file_backed_image_manager
|
|
from . import test_v38_review_run_storage as review
|
|
from . import test_p23_assembly_v35 as assembly
|
|
|
|
|
|
def scope(*, chunk=2, finish=False):
|
|
contract = review._contract(chunks=4)
|
|
entries = [review._entry(position, contract) for position in range(3)]
|
|
decoded, full_plan = prepare_physical_decode_entries(
|
|
entries, chunk_seconds=5, preserve_final_frame=False, terminal_merged=False,
|
|
)
|
|
result = {"session": {"chunks": entries}, "report": "source"}
|
|
outputs = ([{"samples": entry["video"]} for entry in decoded],
|
|
[{"samples": entry["audio"]} for entry in decoded], full_plan, result)
|
|
storage = SimpleNamespace(review_generation_mode="Review Each Chunk",
|
|
review_execution=SimpleNamespace(finish_remaining=finish,
|
|
next_review_unit_start=chunk, next_review_unit_end=chunk,
|
|
partial_review=True, smart_regenerate=False))
|
|
scoped = _apply_review_decode_scope(
|
|
outputs, storage=storage, capture_refine_context=False, configured_chunks=4,
|
|
chunk_seconds=5, first_frame=None, last_frame=None, timeline_video_source=None,
|
|
)
|
|
return scoped, outputs
|
|
|
|
|
|
def finalize(plan, source, *, exact=False, backend="RAM", direct=False):
|
|
images, generated = assembly._decoded(plan, sample_rate=32000)
|
|
if not direct:
|
|
plan = dict(plan, _h3_continuum_driving_audio_v1=source)
|
|
return driving_nodes.H3ContinuumAssembleSeamV35().assemble(
|
|
images, generated, plan, exact, "Off", "Off", backend, "Off",
|
|
driving_audio=source if direct else None,
|
|
)
|
|
|
|
|
|
@pytest.fixture
|
|
def buffer_root(tmp_path, monkeypatch):
|
|
original = driving_nodes.assemble_decoded_chunks_v35
|
|
def assemble_at_test_root(**kwargs):
|
|
return original(**kwargs, backing_root=tmp_path)
|
|
monkeypatch.setattr(driving_nodes, "assemble_decoded_chunks_v35", assemble_at_test_root)
|
|
yield tmp_path
|
|
gc.collect()
|
|
get_file_backed_image_manager(tmp_path).collect_ready()
|
|
|
|
|
|
@pytest.mark.parametrize("rate", [32000, 44100, 48000])
|
|
@pytest.mark.parametrize("channels", [1, 2])
|
|
@pytest.mark.parametrize("exact", [False, True])
|
|
@pytest.mark.parametrize("backend", ["RAM", "Disk-backed", "Auto"])
|
|
def test_finalize_uses_natural_absolute_pcm_origin(rate, channels, exact, backend, buffer_root):
|
|
scoped, original = scope()
|
|
plan = scoped[2]
|
|
unit = original[2]["chunks"][1]
|
|
samples = round(20 * rate)
|
|
waveform = torch.arange(samples, dtype=torch.float32).view(1, 1, -1).repeat(1, channels, 1)
|
|
source = {"waveform": waveform, "sample_rate": rate}
|
|
frozen = waveform.clone()
|
|
start = round(unit["frame_start"] * rate / 24)
|
|
stop = round(unit["frame_stop"] * rate / 24)
|
|
assert unit["frame_start"] == 124 and unit["frame_stop"] == 243
|
|
expected = waveform[..., start:stop]
|
|
if exact:
|
|
wanted = round(plan["target_frames"] * rate / 24)
|
|
padding = max(0, wanted - expected.shape[-1])
|
|
# The unchanged V3.9 Exact rule repeats the final available PCM sample.
|
|
expected = torch.cat((expected[..., :wanted], expected[..., -1:].expand(1, channels, padding)), dim=-1)
|
|
for direct in (False, True):
|
|
images, audio, _ = finalize(plan, source, exact=exact, backend=backend, direct=direct)
|
|
assert torch.equal(audio["waveform"], expected)
|
|
assert audio["sample_rate"] == rate
|
|
assert images.shape[0] == (120 if exact else 119)
|
|
del images, audio
|
|
assert torch.equal(waveform, frozen)
|
|
assert scoped[3]["session"] is original[3]["session"]
|
|
assert len(original[3]["session"]["chunks"]) == 3
|
|
assert REVIEW_AUDIO_PROJECTION_KEY not in original[2]
|
|
assert REVIEW_AUDIO_PROJECTION_KEY not in original[3]["session"]
|
|
|
|
|
|
@pytest.mark.parametrize("length", [160000, 0])
|
|
@pytest.mark.parametrize("exact", [False, True])
|
|
def test_short_or_empty_review_audio_only_pads_when_required(length, exact, buffer_root):
|
|
plan = scope()[0][2]
|
|
waveform = torch.ones((1, 2, length), dtype=torch.float64)
|
|
source = {"waveform": waveform, "sample_rate": 32000}
|
|
images, output, report = finalize(plan, source, exact=exact)
|
|
assert output["waveform"].dtype == waveform.dtype
|
|
# Chunk 2 begins after these short sources. Use the selected output's real size.
|
|
assert output["waveform"].shape == (1, 2, round(images.shape[0] * 32000 / 24))
|
|
assert not torch.count_nonzero(output["waveform"])
|
|
assert "Empty Review interval" in report
|
|
assert torch.equal(source["waveform"], waveform)
|
|
|
|
|
|
def test_partial_short_audio_is_not_padded_with_exact_off(buffer_root):
|
|
plan = scope()[0][2]
|
|
start = round(124 * 32000 / 24)
|
|
waveform = torch.arange(start + 1000, dtype=torch.float32).view(1, 1, -1)
|
|
_, output, report = finalize(plan, {"waveform": waveform, "sample_rate": 32000})
|
|
assert torch.equal(output["waveform"], waveform[..., start:])
|
|
assert output["waveform"].shape[-1] == 1000
|
|
assert "silence added" not in report
|
|
|
|
|
|
def test_finalize_repeat_does_not_cut_the_pcm_twice(buffer_root):
|
|
plan = scope()[0][2]
|
|
source = {"waveform": torch.arange(640000, dtype=torch.float32).view(1, 1, -1), "sample_rate": 32000}
|
|
plan["_h3_continuum_driving_audio_v1"] = source
|
|
before = source["waveform"].clone()
|
|
first = finalize(plan, source)
|
|
second = finalize(plan, source)
|
|
assert torch.equal(first[1]["waveform"], second[1]["waveform"])
|
|
assert first[1]["waveform"][0, 0, 0] == round(124 * 32000 / 24)
|
|
assert torch.equal(plan["_h3_continuum_driving_audio_v1"]["waveform"], before)
|
|
|
|
|
|
def test_full_projection_keeps_source_pcm_unchanged(buffer_root):
|
|
scoped, full = scope(finish=True)
|
|
assert scoped is full
|
|
assert REVIEW_AUDIO_PROJECTION_KEY not in full[2]
|
|
source = {"waveform": torch.arange(640000, dtype=torch.float32).view(1, 1, -1), "sample_rate": 32000}
|
|
_, output, _ = finalize(full[2], source, exact=False)
|
|
assert torch.equal(output["waveform"], source["waveform"])
|
|
|
|
|
|
def test_terminal_physical_group_cannot_be_split():
|
|
plan = assembly._plan("long_terminal_3x5")
|
|
projection = make_review_audio_projection(plan, start_chunk=2, end_chunk=3)
|
|
group = plan["decode_groups"][1]
|
|
assert (projection["source_start_frame"], projection["source_stop_frame"]) == (group["frame_start"], group["frame_stop"])
|
|
with pytest.raises(AssemblyPlanError, match="split"):
|
|
make_review_audio_projection(plan, start_chunk=3, end_chunk=3)
|
|
|
|
|
|
@pytest.mark.parametrize("field,value", [
|
|
("version", 2), ("coordinate_space", "local"), ("fps", 30),
|
|
("start_chunk", 1), ("source_start_frame", -1), ("source_stop_frame", 242),
|
|
("source_stop_frame", 124),
|
|
])
|
|
def test_broken_metadata_has_no_first_audio_fallback(field, value):
|
|
plan = scope()[0][2]
|
|
plan[REVIEW_AUDIO_PROJECTION_KEY][field] = value
|
|
with pytest.raises(AssemblyPlanError, match="Review audio projection"):
|
|
driving_audio.slice_review_source_audio({"waveform": torch.ones(1, 1, 200), "sample_rate": 32000}, plan)
|
|
|
|
|
|
def test_second_pass_geometry_copy_preserves_projection_and_source():
|
|
scoped, _ = scope()
|
|
plan = scoped[2]
|
|
source = {"waveform": torch.arange(100, dtype=torch.float32).view(1, 1, -1), "sample_rate": 32000}
|
|
plan["_h3_continuum_driving_audio_v1"] = source
|
|
before = copy.deepcopy(plan[REVIEW_AUDIO_PROJECTION_KEY])
|
|
group = plan["second_pass_contract"]["physical_groups"][0]
|
|
shape = (group["source_batch"], group["latent_channels"], group["source_latent_t"],
|
|
group["source_latent_h"] * 2, group["source_latent_w"] * 2)
|
|
updated = update_second_pass_geometry(plan, [{"samples": torch.zeros(shape)}])
|
|
assert updated[REVIEW_AUDIO_PROJECTION_KEY] == before
|
|
assert torch.equal(updated["_h3_continuum_driving_audio_v1"]["waveform"], source["waveform"])
|
|
assert plan[REVIEW_AUDIO_PROJECTION_KEY] == before
|
|
validate_assembly_plan(updated)
|