Some checks are pending
Publish to Comfy registry / Publish Custom Node to registry (push) Waiting to run
659 lines
24 KiB
Python
659 lines
24 KiB
Python
from __future__ import annotations
|
|
|
|
import json
|
|
import re
|
|
|
|
import torch
|
|
import torch.nn.functional as F
|
|
|
|
from . import (
|
|
FFMPEG_RESIZE_METHODS,
|
|
audio_db_to_gain,
|
|
audio_is_muted,
|
|
audio_volume_db,
|
|
load_audio_waveform,
|
|
load_image_tensor,
|
|
resize_image,
|
|
resize_video_with_ffmpeg,
|
|
resolve_video_path,
|
|
)
|
|
|
|
|
|
SLOT_REFERENCE_PREFIX = "__slot__:"
|
|
MAX_MULTITRACK_TASK_IMAGES = 9
|
|
_SLOT_ONE_BASED_INDEX_RE = re.compile(
|
|
r"(?:image|audio|video)(\d+)$",
|
|
re.IGNORECASE,
|
|
)
|
|
|
|
|
|
def multitrack_slot_name(content: dict) -> str | None:
|
|
"""Return a canonical slot name from current or legacy media descriptors."""
|
|
if not isinstance(content, dict):
|
|
return None
|
|
|
|
slot_name = content.get("slot_name")
|
|
if isinstance(slot_name, str) and slot_name:
|
|
return slot_name.removeprefix(SLOT_REFERENCE_PREFIX)
|
|
|
|
for key in ("file_path", "local_path", "url", "file_name"):
|
|
value = content.get(key)
|
|
if isinstance(value, str) and value.startswith(SLOT_REFERENCE_PREFIX):
|
|
return value.removeprefix(SLOT_REFERENCE_PREFIX) or None
|
|
|
|
if content.get("source_type") == "slot":
|
|
file_name = content.get("file_name")
|
|
if isinstance(file_name, str) and file_name:
|
|
return file_name
|
|
return None
|
|
|
|
|
|
def canonicalize_multitrack_slot_content(content: dict) -> dict:
|
|
"""Normalize encoded ``__slot__:name`` paths into an explicit slot descriptor."""
|
|
normalized = dict(content)
|
|
slot_name = multitrack_slot_name(normalized)
|
|
if slot_name is None:
|
|
return normalized
|
|
|
|
normalized["source_type"] = "slot"
|
|
normalized["slot_name"] = slot_name
|
|
normalized["file_name"] = slot_name
|
|
for key in ("file_path", "local_path", "url"):
|
|
value = normalized.get(key)
|
|
if isinstance(value, str) and value.startswith(SLOT_REFERENCE_PREFIX):
|
|
normalized.pop(key, None)
|
|
return normalized
|
|
|
|
|
|
def multitrack_is_shared_reference(content: dict) -> bool:
|
|
"""Accept the unified flag and the legacy audio speaker-reference flag."""
|
|
return isinstance(content, dict) and (
|
|
content.get("shared_reference") is True
|
|
or content.get("speaker_reference") is True
|
|
)
|
|
|
|
|
|
def multitrack_is_muted_image(content: dict) -> bool:
|
|
"""Return whether a task image is explicitly bypassed."""
|
|
return isinstance(content, dict) and content.get("muted") is True
|
|
|
|
|
|
def multitrack_media_identity(content: dict) -> tuple[str, str] | None:
|
|
"""Return the source/path identity used to match shared media references."""
|
|
if not isinstance(content, dict):
|
|
return None
|
|
normalized = canonicalize_multitrack_slot_content(content)
|
|
source_type = str(normalized.get("source_type", "input"))
|
|
if source_type == "slot":
|
|
path = normalized.get("slot_name")
|
|
else:
|
|
path = (
|
|
normalized.get("file_path")
|
|
or normalized.get("local_path")
|
|
or normalized.get("url")
|
|
or normalized.get("file_name")
|
|
)
|
|
return (source_type, str(path)) if path else None
|
|
|
|
|
|
def multitrack_shared_task_images(tracks: list) -> list[dict]:
|
|
"""Collect unique explicitly shared task images in stable timeline order."""
|
|
shared: list[dict] = []
|
|
seen: set[tuple[str, str]] = set()
|
|
for track in tracks:
|
|
if not isinstance(track, dict) or track.get("type") != "task":
|
|
continue
|
|
for segment in track.get("segments", []):
|
|
if not isinstance(segment, dict):
|
|
continue
|
|
content = segment.get("content", {})
|
|
images = content.get("images", []) if isinstance(content, dict) else []
|
|
for image in images if isinstance(images, list) else []:
|
|
identity = multitrack_media_identity(image)
|
|
if not multitrack_is_shared_reference(image) or identity is None or identity in seen:
|
|
continue
|
|
normalized = canonicalize_multitrack_slot_content(image)
|
|
normalized["shared_reference"] = True
|
|
normalized.pop("speaker_reference", None)
|
|
shared.append(normalized)
|
|
seen.add(identity)
|
|
return shared[:MAX_MULTITRACK_TASK_IMAGES]
|
|
|
|
|
|
def multitrack_task_images_with_shared(
|
|
images: object,
|
|
shared_images: list[dict],
|
|
) -> list[dict]:
|
|
"""Prefix shared images, auto-matching same-path items, under the 9-image cap."""
|
|
local_images = [image for image in images if isinstance(image, dict)] if isinstance(images, list) else []
|
|
shared_identities = {
|
|
identity
|
|
for image in shared_images
|
|
if (identity := multitrack_media_identity(image)) is not None
|
|
}
|
|
prefixed: list[dict] = []
|
|
for shared_image in shared_images:
|
|
identity = multitrack_media_identity(shared_image)
|
|
matching = next(
|
|
(image for image in local_images if multitrack_media_identity(image) == identity),
|
|
None,
|
|
)
|
|
normalized = canonicalize_multitrack_slot_content(
|
|
matching if matching is not None else shared_image
|
|
)
|
|
if matching is None:
|
|
normalized.pop("muted", None)
|
|
normalized["shared_reference"] = True
|
|
normalized.pop("speaker_reference", None)
|
|
prefixed.append(normalized)
|
|
local = [
|
|
canonicalize_multitrack_slot_content(image)
|
|
for image in local_images
|
|
if multitrack_media_identity(image) not in shared_identities
|
|
]
|
|
return (prefixed + local)[:MAX_MULTITRACK_TASK_IMAGES]
|
|
|
|
|
|
def multitrack_slot_media_types(data: dict) -> set[str]:
|
|
"""Return media types whose track descriptors reference an input slot."""
|
|
required: set[str] = set()
|
|
tracks = data.get("tracks", [])
|
|
if not isinstance(tracks, list):
|
|
return required
|
|
shared_images = multitrack_shared_task_images(tracks)
|
|
|
|
for track in tracks:
|
|
if not isinstance(track, dict):
|
|
continue
|
|
track_type = str(track.get("type", ""))
|
|
segments = track.get("segments", [])
|
|
if not isinstance(segments, list):
|
|
continue
|
|
for segment in segments:
|
|
if not isinstance(segment, dict):
|
|
continue
|
|
content = segment.get("content", {})
|
|
if not isinstance(content, dict):
|
|
continue
|
|
if track_type == "task":
|
|
images = multitrack_task_images_with_shared(
|
|
content.get("images", []), shared_images,
|
|
)
|
|
if any(
|
|
isinstance(image, dict)
|
|
and not multitrack_is_muted_image(image)
|
|
and multitrack_slot_name(image) is not None
|
|
for image in images
|
|
):
|
|
required.add("image")
|
|
elif (
|
|
track_type in {"audio", "video"}
|
|
and content.get("media_type") == track_type
|
|
and multitrack_slot_name(content) is not None
|
|
):
|
|
required.add(track_type)
|
|
return required
|
|
|
|
|
|
def multitrack_segments_in_window(
|
|
track: dict,
|
|
start_frame: int,
|
|
end_frame: int,
|
|
) -> list[dict]:
|
|
"""Clip media segments to a window and shift them to window-local frames."""
|
|
track_type = track.get("type")
|
|
segments = track.get("segments", [])
|
|
if not isinstance(segments, list) or end_frame <= start_frame:
|
|
return []
|
|
|
|
clipped: list[dict] = []
|
|
for segment in segments:
|
|
if not isinstance(segment, dict):
|
|
continue
|
|
content = segment.get("content", {})
|
|
if not isinstance(content, dict) or content.get("media_type") != track_type:
|
|
continue
|
|
try:
|
|
segment_start = int(segment.get("start_frame", 0))
|
|
segment_end = int(segment.get("end_frame", segment_start))
|
|
origin_start = int(segment.get("origin_start_frame", segment_start))
|
|
except (TypeError, ValueError, OverflowError):
|
|
continue
|
|
|
|
overlap_start = max(start_frame, segment_start)
|
|
overlap_end = min(end_frame, segment_end)
|
|
if overlap_end <= overlap_start:
|
|
continue
|
|
|
|
local_segment = dict(segment)
|
|
local_segment["start_frame"] = overlap_start - start_frame
|
|
local_segment["end_frame"] = overlap_end - start_frame
|
|
local_segment["origin_start_frame"] = origin_start - start_frame
|
|
local_segment["content"] = dict(content)
|
|
clipped.append(local_segment)
|
|
return clipped
|
|
|
|
|
|
def multitrack_audio_lock_is_effective(
|
|
info: dict,
|
|
track: dict,
|
|
start_frame: int,
|
|
end_frame: int,
|
|
*,
|
|
has_solo_track: bool | None = None,
|
|
) -> bool:
|
|
"""Return whether a locked track has audible media in a timeline window.
|
|
|
|
Video timing remains independent from this decision. This helper only
|
|
answers whether the track is allowed to provide lock audio.
|
|
"""
|
|
if (
|
|
not isinstance(info, dict)
|
|
or not isinstance(track, dict)
|
|
or track.get("type") not in {"audio", "video"}
|
|
or track.get("audio_locked") is not True
|
|
or audio_is_muted(info)
|
|
or audio_is_muted(track)
|
|
):
|
|
return False
|
|
if has_solo_track is None:
|
|
tracks = info.get("tracks", [])
|
|
has_solo_track = any(
|
|
isinstance(candidate, dict)
|
|
and candidate.get("type") in {"audio", "video"}
|
|
and candidate.get("solo") is True
|
|
for candidate in tracks if isinstance(tracks, list)
|
|
)
|
|
if has_solo_track and track.get("solo") is not True:
|
|
return False
|
|
|
|
track_type = track.get("type")
|
|
return any(
|
|
isinstance(segment, dict)
|
|
and isinstance(segment.get("content"), dict)
|
|
and segment["content"].get("media_type") == track_type
|
|
and not audio_is_muted(segment["content"])
|
|
and _multitrack_frame_value(segment.get("start_frame")) < end_frame
|
|
and _multitrack_frame_value(
|
|
segment.get("end_frame"),
|
|
_multitrack_frame_value(segment.get("start_frame")),
|
|
) > start_frame
|
|
for segment in track.get("segments", [])
|
|
)
|
|
|
|
|
|
def _slot_index(slot_name: str | None) -> int:
|
|
if not slot_name:
|
|
return 0
|
|
slot_text = str(slot_name)
|
|
m = _SLOT_ONE_BASED_INDEX_RE.search(slot_text)
|
|
if m:
|
|
return max(0, int(m.group(1)) - 1)
|
|
return 0
|
|
|
|
def _unwrap_slot_input(value):
|
|
# With is_input_list (and lazy inputs), a value can arrive as a tuple or as a
|
|
# tuple-wrapped list; normalise to a plain list before indexing.
|
|
if isinstance(value, tuple):
|
|
value = list(value)
|
|
if isinstance(value, list) and len(value) == 1 and isinstance(value[0], (list, tuple)):
|
|
inner = value[0]
|
|
return list(inner) if isinstance(inner, tuple) else inner
|
|
return value
|
|
|
|
def _parse_track_data(track_data: str | dict) -> dict:
|
|
if isinstance(track_data, str):
|
|
try:
|
|
parsed = json.loads(track_data)
|
|
except json.JSONDecodeError as exc:
|
|
raise ValueError("Invalid TRACK_DATA JSON.") from exc
|
|
if not isinstance(parsed, dict):
|
|
raise ValueError("TRACK_DATA must decode to an object.")
|
|
return parsed
|
|
if isinstance(track_data, dict):
|
|
return dict(track_data)
|
|
if track_data is None:
|
|
return {}
|
|
raise ValueError("TRACK_DATA must be a JSON string or object.")
|
|
|
|
|
|
MULTITRACK_RUNTIME_CACHE_KEY = "_easy_media_runtime_cache"
|
|
|
|
|
|
def multitrack_runtime_cache(
|
|
track_data: object,
|
|
*,
|
|
create: bool = False,
|
|
) -> dict | None:
|
|
"""Return the runtime cache attached to an upstream TRACKS_INFO object.
|
|
|
|
Dynamic expansion nodes can be evicted before they are reintroduced in a
|
|
later prompt. Keeping their media-only results on the original upstream
|
|
TRACKS_INFO object gives those results the same lifetime as the ordinary
|
|
workflow node without creating a process-global strong reference.
|
|
"""
|
|
while isinstance(track_data, (list, tuple)) and len(track_data) == 1:
|
|
track_data = track_data[0]
|
|
if not isinstance(track_data, dict):
|
|
return None
|
|
cache = track_data.get(MULTITRACK_RUNTIME_CACHE_KEY)
|
|
if isinstance(cache, dict):
|
|
return cache
|
|
if not create:
|
|
return None
|
|
cache = {}
|
|
track_data[MULTITRACK_RUNTIME_CACHE_KEY] = cache
|
|
return cache
|
|
|
|
def _as_list_input(value) -> list:
|
|
if value is None:
|
|
return []
|
|
# is_input_list/lazy plumbing can also deliver a tuple (or tuple-wrapped list).
|
|
if isinstance(value, tuple):
|
|
value = list(value)
|
|
if isinstance(value, list):
|
|
if len(value) == 1 and isinstance(value[0], (list, tuple)):
|
|
inner = value[0]
|
|
return list(inner) if isinstance(inner, tuple) else inner
|
|
return value
|
|
return [value]
|
|
|
|
def _embedded_multitrack_media(info: dict, media_type: str) -> list:
|
|
"""Return eager slot media carried by TRACKS_INFO itself."""
|
|
media = info.get("media")
|
|
if not isinstance(media, dict):
|
|
return []
|
|
return _as_list_input(media.get(media_type))
|
|
|
|
def _media_output_for_index(items: list, index: int):
|
|
if index < 0 or index >= len(items):
|
|
return None
|
|
return items[index]
|
|
|
|
def _index_slot_video(video_input, slot_name: str | None):
|
|
items = _as_list_input(video_input)
|
|
return _media_output_for_index(items, _slot_index(slot_name))
|
|
|
|
def _resolve_multitrack_video(content: dict, video_input):
|
|
from comfy_api.latest import InputImpl
|
|
|
|
slot_name = multitrack_slot_name(content)
|
|
if slot_name is not None:
|
|
return _index_slot_video(video_input, slot_name)
|
|
source_type = str(content.get("source_type", "input"))
|
|
if source_type == "preset":
|
|
return None
|
|
source = resolve_video_path(
|
|
source_type,
|
|
content.get("file_path"),
|
|
content.get("local_path"),
|
|
content.get("url"),
|
|
)
|
|
return InputImpl.VideoFromFile(source)
|
|
|
|
def _resolve_multitrack_audio(content: dict, audio_input, sample_rate: int = 44100) -> 'dict | None':
|
|
slot_name = multitrack_slot_name(content)
|
|
if slot_name is not None:
|
|
return _index_slot_audio(audio_input, slot_name)
|
|
waveform = load_audio_waveform(
|
|
content.get("source_type", "input"),
|
|
content.get("file_path"),
|
|
content.get("local_path"),
|
|
content.get("url"),
|
|
sample_rate,
|
|
)
|
|
if waveform is None:
|
|
return None
|
|
return {"waveform": waveform, "sample_rate": sample_rate}
|
|
|
|
def _video_resize_cache_key(video, width: int, height: int, resize_method: str) -> tuple:
|
|
source = _video_stream_source(video)
|
|
identity = ("source", source) if isinstance(source, str) else ("object", id(video))
|
|
return identity, width, height, resize_method
|
|
|
|
def _resize_multitrack_video(
|
|
video,
|
|
width: int,
|
|
height: int,
|
|
resize_method: str,
|
|
cache: dict[tuple, object],
|
|
progress_callback,
|
|
):
|
|
from comfy_api.latest import InputImpl, Types
|
|
|
|
if tuple(video.get_dimensions()) == (width, height):
|
|
progress_callback(1.0)
|
|
return video
|
|
|
|
cache_key = _video_resize_cache_key(video, width, height, resize_method)
|
|
cached = cache.get(cache_key)
|
|
if cached is not None:
|
|
progress_callback(1.0)
|
|
return cached
|
|
|
|
source = cache_key[0][1] if cache_key[0][0] == "source" else None
|
|
if resize_method in FFMPEG_RESIZE_METHODS and isinstance(source, str):
|
|
resized_path = resize_video_with_ffmpeg(
|
|
source,
|
|
width,
|
|
height,
|
|
resize_method,
|
|
progress_callback=progress_callback,
|
|
)
|
|
if resized_path is not None:
|
|
resized_video = InputImpl.VideoFromFile(resized_path)
|
|
cache[cache_key] = resized_video
|
|
return resized_video
|
|
|
|
components = video.get_components()
|
|
progress_callback(0.5)
|
|
resized_frames = resize_image(components.images, width, height, resize_method)
|
|
resized_video = InputImpl.VideoFromComponents(
|
|
Types.VideoComponents(
|
|
images=resized_frames,
|
|
audio=components.audio,
|
|
frame_rate=components.frame_rate,
|
|
)
|
|
)
|
|
cache[cache_key] = resized_video
|
|
progress_callback(1.0)
|
|
return resized_video
|
|
|
|
def _resample_audio_waveform(
|
|
waveform: torch.Tensor,
|
|
source_rate: int,
|
|
target_rate: int,
|
|
) -> torch.Tensor:
|
|
if source_rate == target_rate:
|
|
return waveform
|
|
target_samples = max(1, round(waveform.shape[-1] * target_rate / source_rate))
|
|
return F.interpolate(waveform, size=target_samples, mode="linear", align_corners=False)
|
|
|
|
def _merge_audio_track(
|
|
segments: list[tuple[dict, dict]],
|
|
total_length: int,
|
|
frame_rate: float,
|
|
base_volume_db: float = 0.0,
|
|
muted: bool = False,
|
|
) -> dict:
|
|
sample_rate = 44100
|
|
channels = 2
|
|
for _segment, audio in segments:
|
|
waveform = audio.get("waveform")
|
|
if isinstance(waveform, torch.Tensor):
|
|
sample_rate = int(audio.get("sample_rate", sample_rate))
|
|
channels = int(waveform.shape[1])
|
|
break
|
|
|
|
total_samples = max(1, round(total_length * sample_rate / frame_rate))
|
|
merged = torch.zeros(1, channels, total_samples)
|
|
if muted:
|
|
return {"waveform": merged, "sample_rate": sample_rate}
|
|
for segment, audio in sorted(segments, key=lambda item: int(item[0].get("start_frame", 0))):
|
|
waveform = audio.get("waveform")
|
|
if not isinstance(waveform, torch.Tensor):
|
|
continue
|
|
source_rate = int(audio.get("sample_rate", sample_rate))
|
|
waveform = _resample_audio_waveform(waveform, source_rate, sample_rate)
|
|
if waveform.shape[1] == 1 and channels > 1:
|
|
waveform = waveform.expand(-1, channels, -1)
|
|
elif waveform.shape[1] != channels:
|
|
waveform = waveform[:, :channels]
|
|
|
|
content = segment.get("content", {})
|
|
if not isinstance(content, dict):
|
|
content = {}
|
|
if audio_is_muted(content):
|
|
continue
|
|
gain = audio_db_to_gain(base_volume_db + audio_volume_db(content))
|
|
|
|
start_frame = max(0, int(segment.get("start_frame", 0)))
|
|
end_frame = min(total_length, max(start_frame, int(segment.get("end_frame", start_frame))))
|
|
start_sample = round(start_frame * sample_rate / frame_rate)
|
|
segment_samples = max(0, round((end_frame - start_frame) * sample_rate / frame_rate))
|
|
origin_start = int(segment.get("origin_start_frame", start_frame))
|
|
source_start_sample = max(0, round((start_frame - origin_start) * sample_rate / frame_rate))
|
|
copy_samples = min(
|
|
segment_samples,
|
|
max(0, waveform.shape[-1] - source_start_sample),
|
|
total_samples - start_sample,
|
|
)
|
|
if copy_samples > 0:
|
|
merged[..., start_sample:start_sample + copy_samples] = (
|
|
waveform[..., source_start_sample:source_start_sample + copy_samples] * gain
|
|
)
|
|
return {"waveform": merged, "sample_rate": sample_rate}
|
|
|
|
def _video_stream_source(video) -> 'str | None':
|
|
try:
|
|
trim_start, trim_duration = video.get_active_trim_window()
|
|
if float(trim_start) != 0.0 or float(trim_duration) != 0.0:
|
|
return None
|
|
except (AttributeError, NotImplementedError, RuntimeError, TypeError, ValueError):
|
|
pass
|
|
try:
|
|
source = video.get_stream_source()
|
|
except (AttributeError, NotImplementedError, RuntimeError, ValueError):
|
|
return None
|
|
return source if isinstance(source, str) else None
|
|
|
|
def _index_slot_image(image_input, slot_name: str | None) -> 'torch.Tensor | None':
|
|
idx = _slot_index(slot_name)
|
|
image_input = _unwrap_slot_input(image_input)
|
|
if image_input is None:
|
|
return None
|
|
candidates = image_input if isinstance(image_input, (list, tuple)) else [image_input]
|
|
flattened: list[torch.Tensor] = []
|
|
for candidate in candidates:
|
|
# Tolerate a nested list/tuple of tensors produced by is_input_list plumbing.
|
|
if isinstance(candidate, (list, tuple)):
|
|
for sub in candidate:
|
|
if not isinstance(sub, torch.Tensor):
|
|
continue
|
|
t2 = _normalize_image_tensor(sub)
|
|
if t2 is not None and not _is_empty_slot_image(t2):
|
|
flattened.extend(t2[i:i + 1] for i in range(t2.shape[0]))
|
|
continue
|
|
if not isinstance(candidate, torch.Tensor):
|
|
continue
|
|
tensor = _normalize_image_tensor(candidate)
|
|
if tensor is None:
|
|
continue
|
|
if _is_empty_slot_image(tensor):
|
|
continue
|
|
flattened.extend(tensor[i:i + 1] for i in range(tensor.shape[0]))
|
|
return flattened[idx] if idx < len(flattened) else None
|
|
|
|
def _normalize_image_tensor(tensor: torch.Tensor) -> 'torch.Tensor | None':
|
|
if tensor.dim() == 3:
|
|
if tensor.shape[0] in (1, 3, 4) and tensor.shape[-1] not in (1, 3, 4):
|
|
tensor = tensor.permute(1, 2, 0)
|
|
tensor = tensor.unsqueeze(0)
|
|
elif tensor.dim() == 4:
|
|
if tensor.shape[1] in (1, 3, 4) and tensor.shape[-1] not in (1, 3, 4):
|
|
tensor = tensor.permute(0, 2, 3, 1)
|
|
else:
|
|
return None
|
|
return tensor
|
|
|
|
def _is_empty_slot_image(tensor: torch.Tensor) -> bool:
|
|
if tensor.dim() == 3:
|
|
return tensor.shape[0] == 1 and tensor.shape[1] == 1
|
|
if tensor.dim() == 4:
|
|
return tensor.shape[1] == 1 and tensor.shape[2] == 1
|
|
return False
|
|
|
|
def _index_slot_audio(audio_input, slot_name: str | None) -> 'dict | None':
|
|
idx = _slot_index(slot_name)
|
|
audio_input = _unwrap_slot_input(audio_input)
|
|
if audio_input is None:
|
|
return None
|
|
if isinstance(audio_input, list):
|
|
if idx < len(audio_input):
|
|
audio = audio_input[idx]
|
|
return audio if isinstance(audio, dict) and 'waveform' in audio else None
|
|
return None
|
|
if isinstance(audio_input, dict) and 'waveform' in audio_input and idx == 0:
|
|
return audio_input
|
|
return None
|
|
|
|
def _resolve_timeline_image_item(item: dict, image_input, image_loader=load_image_tensor) -> 'torch.Tensor | None':
|
|
slot_name = multitrack_slot_name(item)
|
|
if slot_name is not None:
|
|
return _index_slot_image(image_input, slot_name)
|
|
return image_loader(
|
|
item.get("source_type", "input"),
|
|
item.get("file_path"),
|
|
item.get("local_path"),
|
|
item.get("url"),
|
|
)
|
|
|
|
def _multitrack_frame_value(value: object, default: int = 0) -> int:
|
|
try:
|
|
return int(value) if value is not None else default
|
|
except (TypeError, ValueError, OverflowError):
|
|
return default
|
|
|
|
def _multitrack_timeline_end(info: dict) -> int:
|
|
tracks = info.get("tracks", [])
|
|
segment_end = max(
|
|
(
|
|
max(0, _multitrack_frame_value(segment.get("end_frame")))
|
|
for track in tracks
|
|
if isinstance(track, dict)
|
|
for segment in track.get("segments", [])
|
|
if isinstance(segment, dict)
|
|
),
|
|
default=0,
|
|
) if isinstance(tracks, list) else 0
|
|
if info.get("timeline_total_length") is not None:
|
|
return max(
|
|
segment_end,
|
|
max(0, _multitrack_frame_value(info.get("timeline_total_length"))),
|
|
)
|
|
if segment_end > 0:
|
|
return segment_end
|
|
return max(0, _multitrack_frame_value(info.get("total_length")))
|
|
|
|
def _trim_track_audio(
|
|
audio: dict,
|
|
start_frame: int,
|
|
length: int | None,
|
|
frame_rate: float,
|
|
) -> dict:
|
|
waveform = audio.get("waveform")
|
|
sample_rate = int(audio.get("sample_rate", 44100))
|
|
if not isinstance(waveform, torch.Tensor):
|
|
return {"waveform": torch.zeros(1, 1, 1), "sample_rate": sample_rate}
|
|
start_sample = max(0, round(start_frame * sample_rate / frame_rate))
|
|
sample_count = (
|
|
max(1, waveform.shape[-1] - start_sample)
|
|
if length is None
|
|
else max(1, round(length * sample_rate / frame_rate))
|
|
)
|
|
end_sample = min(waveform.shape[-1], start_sample + sample_count)
|
|
trimmed = waveform[..., start_sample:end_sample]
|
|
if trimmed.shape[-1] < sample_count:
|
|
trimmed = F.pad(trimmed, (0, sample_count - trimmed.shape[-1]))
|
|
return {"waveform": trimmed, "sample_rate": sample_rate}
|