The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
Add 10-bit video support (#14452)
Alexander Piskunfe54b5e955ed
diff --git a/comfy_api/latest/_input/video_types.py b/comfy_api/latest/_input/video_types.pyindex 8fff52c16..e2e99521f 100644--- a/comfy_api/latest/_input/video_types.py+++ b/comfy_api/latest/_input/video_types.py@@ -27,10 +27,13 @@ class VideoInput(ABC):path: Union[str, IO[bytes]],format: VideoContainer = VideoContainer.AUTO,codec: VideoCodec = VideoCodec.AUTO,- metadata: Optional[dict] = None+ metadata: Optional[dict] = None,+ bit_depth: int | None = None,):"""Abstract method to save the video input to a file.++ bit_depth selects the encoded bit depth; None keeps the video's native depth."""pass@@ -83,6 +86,14 @@ class VideoInput(ABC):components = self.get_components()return components.images.shape[2], components.images.shape[1]+ def get_bit_depth(self) -> int:+ """+ Returns the bit depth of the video (e.g. 8 or 10).++ Default implementation returns 8; subclasses report their real depth.+ """+ return 8+def get_duration(self) -> float:"""Returns the duration of the video in seconds.diff --git a/comfy_api/latest/_input_impl/video_types.py b/comfy_api/latest/_input_impl/video_types.pyindex 4a12ff9c1..dfdf58515 100644--- a/comfy_api/latest/_input_impl/video_types.py+++ b/comfy_api/latest/_input_impl/video_types.py@@ -52,6 +52,12 @@ def get_open_write_kwargs(return open_kwargs+def video_stream_bit_depth(stream) -> int:+ if stream is None or stream.format is None or not stream.format.components:+ return 8+ return max(component.bits for component in stream.format.components)++class VideoFromFile(VideoInput):"""Class representing video input from a file.@@ -97,6 +103,13 @@ class VideoFromFile(VideoInput):return stream.width, stream.heightraise ValueError(f"No video stream found in file '{self.__file}'")+ def get_bit_depth(self) -> int:+ if isinstance(self.__file, io.BytesIO):+ self.__file.seek(0) # Reset the BytesIO object to the beginning+ with av.open(self.__file, mode="r") as container:+ video_stream = container.streams.video[0] if len(container.streams.video) > 0 else None+ return video_stream_bit_depth(video_stream)+def get_duration(self) -> float:"""Returns the duration of the video in seconds.@@ -377,25 +390,32 @@ class VideoFromFile(VideoInput):format: VideoContainer = VideoContainer.AUTO,codec: VideoCodec = VideoCodec.AUTO,metadata: Optional[dict] = None,+ bit_depth: int | None = None,):if isinstance(self.__file, io.BytesIO):self.__file.seek(0) # Reset the BytesIO object to the beginningwith av.open(self.__file, mode='r') as container:container_format = container.format.name- video_encoding = container.streams.video[0].codec.name if len(container.streams.video) > 0 else None+ video_stream = container.streams.video[0] if len(container.streams.video) > 0 else None+ video_encoding = video_stream.codec.name if video_stream is not None else None+ source_bit_depth = video_stream_bit_depth(video_stream)reuse_streams = Trueif format != VideoContainer.AUTO and format not in container_format.split(","):reuse_streams = Falseif codec != VideoCodec.AUTO and codec != video_encoding and video_encoding is not None:reuse_streams = False+ if bit_depth is not None and video_encoding is not None and bit_depth != source_bit_depth:+ reuse_streams = Falseif self.__start_time or self.__duration:reuse_streams = Falseif not reuse_streams:+ if bit_depth is None:+ bit_depth = source_bit_depthcomponents = self.get_components_internal(container)video = VideoFromComponents(components)return video.save_to(- path, format=format, codec=codec, metadata=metadata+ path, format=format, codec=codec, metadata=metadata, bit_depth=bit_depth,)streams = container.streams@@ -451,8 +471,10 @@ class VideoFromComponents(VideoInput):Class representing video input from tensors."""- def __init__(self, components: VideoComponents):+ def __init__(self, components: VideoComponents, bit_depth: int = 8):self.__components = components+ # Tensor components have no inherent bit depth; this is the depth used when encoding.+ self.__bit_depth = bit_depthdef get_components(self) -> VideoComponents:return VideoComponents(@@ -461,18 +483,26 @@ class VideoFromComponents(VideoInput):frame_rate=self.__components.frame_rate,)+ def get_bit_depth(self) -> int:+ return self.__bit_depth+def save_to(self,path: str,format: VideoContainer = VideoContainer.AUTO,codec: VideoCodec = VideoCodec.AUTO,metadata: Optional[dict] = None,+ bit_depth: int | None = None,):"""Save the video to a file path or BytesIO buffer."""if format != VideoContainer.AUTO and format != VideoContainer.MP4:raise ValueError("Only MP4 format is supported for now")if codec != VideoCodec.AUTO and codec != VideoCodec.H264:raise ValueError("Only H264 codec is supported for now")+ # None means "use the depth this video was created with" (CreateVideo's choice).+ if bit_depth is None:+ bit_depth = self.__bit_depth+ is_10bit = bit_depth >= 10extra_kwargs = {}if isinstance(format, VideoContainer) and format != VideoContainer.AUTO:extra_kwargs["format"] = format.value@@ -488,10 +518,11 @@ class VideoFromComponents(VideoInput):frame_rate = Fraction(round(self.__components.frame_rate * 1000), 1000)# Create a video stream+ pix_fmt = "yuv420p10le" if is_10bit else "yuv420p"video_stream = output.add_stream('h264', rate=frame_rate)video_stream.width = self.__components.images.shape[2]video_stream.height = self.__components.images.shape[1]- video_stream.pix_fmt = 'yuv420p'+ video_stream.pix_fmt = pix_fmt# Create an audio streamaudio_sample_rate = 1@@ -505,9 +536,14 @@ class VideoFromComponents(VideoInput):# Encode videofor i, frame in enumerate(self.__components.images):- img = (frame * 255).clamp(0, 255).byte().cpu().numpy() # shape: (H, W, 3)- frame = av.VideoFrame.from_ndarray(img, format='rgb24')- frame = frame.reformat(format='yuv420p') # Convert to YUV420P as required by h264+ if is_10bit:+ # 16-bit RGB keeps float precision through the conversion to 10-bit YUV.+ img = (frame.float() * 65535).clamp(0, 65535).cpu().numpy().astype(np.uint16) # shape: (H, W, 3)+ frame = av.VideoFrame.from_ndarray(img, format="rgb48le")+ else:+ img = (frame * 255).clamp(0, 255).byte().cpu().numpy() # shape: (H, W, 3)+ frame = av.VideoFrame.from_ndarray(img, format='rgb24')+ frame = frame.reformat(format=pix_fmt)packet = video_stream.encode(frame)output.mux(packet)diff --git a/comfy_extras/nodes_video.py b/comfy_extras/nodes_video.pyindex 6f6c416a6..050a897dd 100644--- a/comfy_extras/nodes_video.py+++ b/comfy_extras/nodes_video.py@@ -134,6 +134,17 @@ class CreateVideo(io.ComfyNode):io.Image.Input("images", tooltip="The images to create a video from."),io.Float.Input("fps", default=30.0, min=1.0, max=120.0, step=1.0),io.Audio.Input("audio", optional=True, tooltip="The audio to add to the video."),+ io.Int.Input(+ "bit_depth",+ min=8,+ max=10,+ default=8,+ step=2,+ tooltip="Bit depth of the created video. 10-bit keeps smoother gradients with less"+ " banding, but some players and downstream nodes may not support it.",+ optional=True,+ display_mode=io.NumberDisplay.number,+ ),],outputs=[io.Video.Output(),@@ -141,9 +152,14 @@ class CreateVideo(io.ComfyNode):)@classmethod- def execute(cls, images: Input.Image, fps: float, audio: Optional[Input.Audio] = None) -> io.NodeOutput:+ def execute(+ cls, images: Input.Image, fps: float, audio: Optional[Input.Audio] = None, bit_depth: int = 8,+ ) -> io.NodeOutput:return io.NodeOutput(- InputImpl.VideoFromComponents(Types.VideoComponents(images=images, audio=audio, frame_rate=Fraction(fps)))+ InputImpl.VideoFromComponents(+ Types.VideoComponents(images=images, audio=audio, frame_rate=Fraction(fps)),+ bit_depth=bit_depth,+ ))class GetVideoComponents(io.ComfyNode):@@ -154,7 +170,7 @@ class GetVideoComponents(io.ComfyNode):search_aliases=["extract frames", "split video", "video to images", "demux"],display_name="Get Video Components",category="video",- description="Extracts all components from a video: frames, audio, and framerate.",+ description="Extracts all components from a video: frames, audio, framerate, and bit depth.",inputs=[io.Video.Input("video", tooltip="The video to extract components from."),],@@ -162,13 +178,14 @@ class GetVideoComponents(io.ComfyNode):io.Image.Output(display_name="images"),io.Audio.Output(display_name="audio"),io.Float.Output(display_name="fps"),+ io.Int.Output(display_name="bit_depth"),],)@classmethoddef execute(cls, video: Input.Video) -> io.NodeOutput:components = video.get_components()- return io.NodeOutput(components.images, components.audio, float(components.frame_rate))+ return io.NodeOutput(components.images, components.audio, float(components.frame_rate), video.get_bit_depth())class LoadVideo(io.ComfyNode):diff --git a/tests-unit/comfy_api_test/video_bit_depth_test.py b/tests-unit/comfy_api_test/video_bit_depth_test.pynew file mode 100644index 000000000..6c7bc9163--- /dev/null+++ b/tests-unit/comfy_api_test/video_bit_depth_test.py@@ -0,0 +1,93 @@+import pytest+import torch+import av+import numpy as np+from fractions import Fraction+from comfy_api.latest._input_impl.video_types import VideoFromFile, VideoFromComponents+from comfy_api.latest._util.video_types import VideoComponents++[email protected](scope="module")+def gradient_components():+ """Narrow horizontal ramp (0.25..0.30) that needs more than 8 bits to stay smooth"""+ width, height, frames = 64, 64, 3+ ramp = torch.linspace(0.25, 0.30, width).view(1, 1, width, 1).expand(frames, height, width, 3)+ return VideoComponents(images=ramp.contiguous(), frame_rate=Fraction(30))++[email protected](scope="module")+def src8(gradient_components, tmp_path_factory):+ """8-bit h264 mp4 (Create Video default)"""+ path = str(tmp_path_factory.mktemp("video") / "src8.mp4")+ VideoFromComponents(gradient_components).save_to(path)+ return path++[email protected](scope="module")+def src10(gradient_components, tmp_path_factory):+ """10-bit h264 mp4 (Create Video with bit_depth=10)"""+ path = str(tmp_path_factory.mktemp("video") / "src10.mp4")+ VideoFromComponents(gradient_components, bit_depth=10).save_to(path)+ return path+++def probe(path):+ """(codec, pix_fmt, bit_depth) of the first video stream"""+ with av.open(path) as container:+ stream = container.streams.video[0]+ return (stream.codec.name, stream.format.name, max(c.bits for c in stream.format.components))+++def decoded_levels(path):+ """Unique tonal levels in the first decoded frame (banding measure)"""+ with av.open(path) as container:+ frame = next(container.decode(container.streams.video[0]))+ return len(np.unique(frame.to_ndarray(format="gbrpf32le")[..., 0]))+++def video_packet_bytes(path):+ """Raw video packet payloads; identical to the source's only for a true remux"""+ with av.open(path) as container:+ return [bytes(p) for p in container.demux(container.streams.video[0]) if p.size]+++def test_create_video_bit_depth(src8, src10):+ """Create Video's bit_depth picks the encoded depth (default 8-bit); 10-bit reduces banding"""+ assert probe(src8) == ("h264", "yuv420p", 8)+ assert probe(src10) == ("h264", "yuv420p10le", 10)+ assert decoded_levels(src10) > 2 * decoded_levels(src8)+++def test_save_auto_keeps_source_depth(src8, src10, tmp_path):+ """Save Video (no bit_depth = auto) stream-copies the source, preserving its depth byte-for-byte"""+ for name, src in [("p8", src8), ("p10", src10)]:+ path = str(tmp_path / f"{name}.mp4")+ VideoFromFile(src).save_to(path)+ assert probe(path) == probe(src)+ assert video_packet_bytes(path) == video_packet_bytes(src)+++def test_save_explicit_depth_reencodes(src8, src10, tmp_path):+ """An explicit bit_depth different from the source forces a re-encode to that depth"""+ down = str(tmp_path / "down8.mp4")+ VideoFromFile(src10).save_to(down, bit_depth=8)+ assert probe(down) == ("h264", "yuv420p", 8)++ up = str(tmp_path / "up10.mp4")+ VideoFromFile(src8).save_to(up, bit_depth=10)+ assert probe(up) == ("h264", "yuv420p10le", 10)+++def test_trim_keeps_source_depth(src10, tmp_path):+ """Video Slice re-encodes (trim) but preserves the source's 10-bit depth"""+ path = str(tmp_path / "trim.mp4")+ VideoFromFile(src10).as_trimmed(start_time=0, duration=1 / 30, strict_duration=False).save_to(path)+ assert probe(path) == ("h264", "yuv420p10le", 10)+++def test_get_bit_depth(gradient_components, src8, src10):+ """get_bit_depth reports a video's depth (backs the Get Video Components output)"""+ assert VideoFromFile(src8).get_bit_depth() == 8+ assert VideoFromFile(src10).get_bit_depth() == 10+ assert VideoFromComponents(gradient_components, bit_depth=10).get_bit_depth() == 10+ assert VideoFromComponents(gradient_components).get_bit_depth() == 8